From d72e78a76dd3bdc629cb5fb4db0f6b3b28b337c5 Mon Sep 17 00:00:00 2001 From: heppen Date: Mon, 28 Aug 2023 16:34:11 +0800 Subject: [PATCH 1/5] remove useless dependencies --- 0001-remove-useless-dependencies.patch | 323 +++++++++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 0001-remove-useless-dependencies.patch diff --git a/0001-remove-useless-dependencies.patch b/0001-remove-useless-dependencies.patch new file mode 100644 index 0000000..2b5cfd2 --- /dev/null +++ b/0001-remove-useless-dependencies.patch @@ -0,0 +1,323 @@ +From feaa1b46fbd01dc2c0bfda5c6ef1e5a8d7f7158e Mon Sep 17 00:00:00 2001 +From: heppen +Date: Tue, 1 Aug 2023 16:52:49 +0800 +Subject: [PATCH] remove useless dependencies + +--- + bundle.json | 24 ++----------------- + frameworks/js/napi/dataability/BUILD.gn | 2 +- + frameworks/js/napi/rdb/BUILD.gn | 6 ++--- + frameworks/js/napi/relationalstore/BUILD.gn | 6 ++--- + frameworks/native/rdb/src/rdb_store_impl.cpp | 2 +- + frameworks/native/rdb/src/security_policy.cpp | 12 ++++++---- + .../native/rdb/src/sqlite_sql_builder.cpp | 4 ++-- + interfaces/inner_api/rdb/BUILD.gn | 4 ++-- + .../rdb/include/abs_shared_result_set.h | 2 +- + .../rdb_data_ability_adapter/BUILD.gn | 12 +++++----- + .../inner_api/rdb_data_share_adapter/BUILD.gn | 16 ++++++------- + test/native/rdb_data_share_adapter/BUILD.gn | 2 +- + 12 files changed, 38 insertions(+), 54 deletions(-) + +diff --git a/bundle.json b/bundle.json +index f6b926a..d837179 100644 +--- a/bundle.json ++++ b/bundle.json +@@ -73,16 +73,14 @@ + "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/appdatafwk:native_appdatafwk", + "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/dataability:native_dataability", + "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb_data_share_adapter:rdb_data_share_adapter", +- "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb", +- "//foundation/distributeddatamgr/relational_store/frameworks/js/napi/dataability:dataability", +- "//foundation/distributeddatamgr/relational_store/frameworks/js/napi/rdb:rdb", +- "//foundation/distributeddatamgr/relational_store/frameworks/js/napi/relationalstore:relationalstore" ++ "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb" + ], + "inner_kits": [ + { + "name": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb", + "header": { + "header_files": [ ++ "abs_predicates.h", + "abs_rdb_predicates.h", + "abs_result_set.h", + "abs_shared_result_set.h", +@@ -119,24 +117,6 @@ + ], + "header_base": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/dataability/include" + } +- }, +- { +- "name": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb_data_share_adapter:rdb_data_share_adapter", +- "header": { +- "header_files": [ +- "rdb_utils.h" +- ], +- "header_base": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb_data_share_adapter/include" +- } +- }, +- { +- "name": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb_data_ability_adapter:rdb_data_ability_adapter", +- "header": { +- "header_files": [ +- "rdb_data_ability_utils.h" +- ], +- "header_base": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb_data_ability_adapter/include" +- } + } + ], + "test": [ +diff --git a/frameworks/js/napi/dataability/BUILD.gn b/frameworks/js/napi/dataability/BUILD.gn +index 6e8d1bd..523f7df 100644 +--- a/frameworks/js/napi/dataability/BUILD.gn ++++ b/frameworks/js/napi/dataability/BUILD.gn +@@ -39,7 +39,7 @@ ohos_shared_library("dataability") { + + external_deps = [ + "hilog_native:libhilog", +- "napi:ace_napi", ++ # "napi:ace_napi", + "relational_store:native_dataability", + "relational_store:native_rdb", + ] +diff --git a/frameworks/js/napi/rdb/BUILD.gn b/frameworks/js/napi/rdb/BUILD.gn +index 2145263..089d1f5 100644 +--- a/frameworks/js/napi/rdb/BUILD.gn ++++ b/frameworks/js/napi/rdb/BUILD.gn +@@ -12,7 +12,7 @@ + # limitations under the License. + import("//build/ohos.gni") + import("//build/ohos/ace/ace.gni") +-import("//foundation/distributeddatamgr/data_share/datashare.gni") ++# import("//foundation/distributeddatamgr/data_share/datashare.gni") + import("//foundation/distributeddatamgr/relational_store/relational_store.gni") + + ohos_copy("relational_store_declaration") { +@@ -79,8 +79,8 @@ ohos_shared_library("rdb") { + ] + + external_deps = [ +- "ability_runtime:abilitykit_native", +- "ability_runtime:napi_base_context", ++ # "ability_runtime:abilitykit_native", ++ # "ability_runtime:napi_base_context", + "c_utils:utils", + "hilog_native:libhilog", + "hitrace_native:hitrace_meter", +diff --git a/frameworks/js/napi/relationalstore/BUILD.gn b/frameworks/js/napi/relationalstore/BUILD.gn +index 0e99278..c15db9c 100644 +--- a/frameworks/js/napi/relationalstore/BUILD.gn ++++ b/frameworks/js/napi/relationalstore/BUILD.gn +@@ -12,7 +12,7 @@ + # limitations under the License. + import("//build/ohos.gni") + import("//build/ohos/ace/ace.gni") +-import("//foundation/distributeddatamgr/data_share/datashare.gni") ++# import("//foundation/distributeddatamgr/data_share/datashare.gni") + import("//foundation/distributeddatamgr/relational_store/relational_store.gni") + + ohos_copy("relational_store_declaration") { +@@ -78,8 +78,8 @@ ohos_shared_library("relationalstore") { + ] + + external_deps = [ +- "ability_runtime:abilitykit_native", +- "ability_runtime:napi_base_context", ++ # "ability_runtime:abilitykit_native", ++ # "ability_runtime:napi_base_context", + "c_utils:utils", + "hilog_native:libhilog", + "hitrace_native:hitrace_meter", +diff --git a/frameworks/native/rdb/src/rdb_store_impl.cpp b/frameworks/native/rdb/src/rdb_store_impl.cpp +index e414050..8093610 100644 +--- a/frameworks/native/rdb/src/rdb_store_impl.cpp ++++ b/frameworks/native/rdb/src/rdb_store_impl.cpp +@@ -934,7 +934,7 @@ int RdbStoreImpl::SetDistributedTables(const std::vector &tables) + RdbSecurityManager::KeyFileType::PUB_KEY_FILE, true); + } + +- LOG_ERROR("success"); ++ LOG_INFO("success"); + return E_OK; + } + +diff --git a/frameworks/native/rdb/src/security_policy.cpp b/frameworks/native/rdb/src/security_policy.cpp +index 910069f..1b513ce 100644 +--- a/frameworks/native/rdb/src/security_policy.cpp ++++ b/frameworks/native/rdb/src/security_policy.cpp +@@ -17,14 +17,16 @@ + + #include "logger.h" + #include "rdb_errno.h" +-#include "security_label.h" ++// #include "security_label.h" + + namespace OHOS { + namespace NativeRdb { + int SecurityPolicy::SetFileSecurityLevel(const std::string &filePath, const std::string &securityLevel) + { +- bool result = DistributedFS::ModuleSecurityLabel::SecurityLabel::SetSecurityLabel(filePath, securityLevel); +- return result ? E_OK : E_ERROR; ++ // bool result = DistributedFS::ModuleSecurityLabel::SecurityLabel::SetSecurityLabel(filePath, securityLevel); ++ (void)filePath; ++ (void)securityLevel; ++ return E_OK; + } + + std::string SecurityPolicy::GetSecurityLevelValue(SecurityLevel securityLevel) +@@ -45,7 +47,9 @@ std::string SecurityPolicy::GetSecurityLevelValue(SecurityLevel securityLevel) + + std::string SecurityPolicy::GetFileSecurityLevel(const std::string &filePath) + { +- return DistributedFS::ModuleSecurityLabel::SecurityLabel::GetSecurityLabel(filePath); ++ (void)filePath; ++ return ""; ++ // return DistributedFS::ModuleSecurityLabel::SecurityLabel::GetSecurityLabel(filePath); + } + + int SecurityPolicy::SetSecurityLabel(const RdbStoreConfig &config) +diff --git a/frameworks/native/rdb/src/sqlite_sql_builder.cpp b/frameworks/native/rdb/src/sqlite_sql_builder.cpp +index 2b0ddd1..d992755 100644 +--- a/frameworks/native/rdb/src/sqlite_sql_builder.cpp ++++ b/frameworks/native/rdb/src/sqlite_sql_builder.cpp +@@ -306,12 +306,12 @@ std::string SqliteSqlBuilder::PredicatesNormalize(const std::string &source, int + } + + auto index = source.rfind("(*"); +- if (index != -1) { ++ if (index != std::string::npos) { + return source; + } + + index = source.rfind("."); +- if (index == -1) { ++ if (index == std::string::npos) { + return StringUtils::SurroundWithQuote(source, "`"); + } + +diff --git a/interfaces/inner_api/rdb/BUILD.gn b/interfaces/inner_api/rdb/BUILD.gn +index 2c0f223..53dd9c6 100644 +--- a/interfaces/inner_api/rdb/BUILD.gn ++++ b/interfaces/inner_api/rdb/BUILD.gn +@@ -147,8 +147,8 @@ ohos_shared_library("native_rdb") { + external_deps = [ + "c_utils:utils", + "hilog_native:libhilog", +- "hitrace_native:hitrace_meter", +- "hitrace_native:libhitracechain", ++ # "hitrace_native:hitrace_meter", ++ # "hitrace_native:libhitracechain", + "huks:libhukssdk", + "ipc:ipc_core", + ] +diff --git a/interfaces/inner_api/rdb/include/abs_shared_result_set.h b/interfaces/inner_api/rdb/include/abs_shared_result_set.h +index 616f729..af9633f 100644 +--- a/interfaces/inner_api/rdb/include/abs_shared_result_set.h ++++ b/interfaces/inner_api/rdb/include/abs_shared_result_set.h +@@ -22,7 +22,7 @@ + #include + + #include "abs_result_set.h" +-#include "message_parcel.h" ++// #include "message_parcel.h" + #include "parcel.h" + #include "shared_block.h" + #include "shared_result_set.h" +diff --git a/interfaces/inner_api/rdb_data_ability_adapter/BUILD.gn b/interfaces/inner_api/rdb_data_ability_adapter/BUILD.gn +index c45f376..edfd798 100644 +--- a/interfaces/inner_api/rdb_data_ability_adapter/BUILD.gn ++++ b/interfaces/inner_api/rdb_data_ability_adapter/BUILD.gn +@@ -11,18 +11,18 @@ + # See the License for the specific language governing permissions and + # limitations under the License. + import("//build/ohos.gni") +-import("//foundation/distributeddatamgr/data_share/datashare.gni") ++# import("//foundation/distributeddatamgr/data_share/datashare.gni") + import("//foundation/distributeddatamgr/relational_store/relational_store.gni") + + config("rdb_data_ability_adapter_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", +- "${datashare_base_path}/interfaces/inner_api/common/include", +- "${datashare_base_path}/interfaces/inner_api/consumer/include", +- "${datashare_base_path}/interfaces/inner_api/provider/include", ++ # "${datashare_base_path}/interfaces/inner_api/common/include", ++ # "${datashare_base_path}/interfaces/inner_api/consumer/include", ++ # "${datashare_base_path}/interfaces/inner_api/provider/include", + "${relational_store_innerapi_path}/rdb/include", +- "${datashare_common_native_path}/include", ++ # "${datashare_common_native_path}/include", + ] + } + +@@ -30,7 +30,7 @@ config("rdb_data_ability_adapter_public_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", +- "${datashare_base_path}/interfaces/inner_api/provider/include", ++ # "${datashare_base_path}/interfaces/inner_api/provider/include", + ] + } + +diff --git a/interfaces/inner_api/rdb_data_share_adapter/BUILD.gn b/interfaces/inner_api/rdb_data_share_adapter/BUILD.gn +index 8af6b42..6493c76 100644 +--- a/interfaces/inner_api/rdb_data_share_adapter/BUILD.gn ++++ b/interfaces/inner_api/rdb_data_share_adapter/BUILD.gn +@@ -11,18 +11,18 @@ + # See the License for the specific language governing permissions and + # limitations under the License. + import("//build/ohos.gni") +-import("//foundation/distributeddatamgr/data_share/datashare.gni") ++# import("//foundation/distributeddatamgr/data_share/datashare.gni") + import("//foundation/distributeddatamgr/relational_store/relational_store.gni") + + config("rdb_data_share_adapter_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", +- "${datashare_base_path}/interfaces/inner_api/common/include", +- "${datashare_base_path}/interfaces/inner_api/consumer/include", +- "${datashare_base_path}/interfaces/inner_api/provider/include", ++ # "${datashare_base_path}/interfaces/inner_api/common/include", ++ # "${datashare_base_path}/interfaces/inner_api/consumer/include", ++ # "${datashare_base_path}/interfaces/inner_api/provider/include", + "${relational_store_innerapi_path}/rdb/include", +- "${datashare_common_native_path}/include", ++ # "${datashare_common_native_path}/include", + ] + } + +@@ -30,14 +30,14 @@ config("rdb_data_share_adapter_public_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", +- "${datashare_base_path}/interfaces/inner_api/provider/include", ++ # "${datashare_base_path}/interfaces/inner_api/provider/include", + ] + } + + ohos_shared_library("rdb_data_share_adapter") { + sources = [ +- "${relational_store_native_path}/rdb_data_share_adapter/src/rdb_result_set_bridge.cpp", +- "${relational_store_native_path}/rdb_data_share_adapter/src/rdb_utils.cpp", ++ # "${relational_store_native_path}/rdb_data_share_adapter/src/rdb_result_set_bridge.cpp", ++ # "${relational_store_native_path}/rdb_data_share_adapter/src/rdb_utils.cpp", + ] + + configs = [ ":rdb_data_share_adapter_config" ] +diff --git a/test/native/rdb_data_share_adapter/BUILD.gn b/test/native/rdb_data_share_adapter/BUILD.gn +index 9e4ad9b..de513b3 100644 +--- a/test/native/rdb_data_share_adapter/BUILD.gn ++++ b/test/native/rdb_data_share_adapter/BUILD.gn +@@ -11,7 +11,7 @@ + # See the License for the specific language governing permissions and + # limitations under the License. + import("//build/test.gni") +-import("//foundation/distributeddatamgr/data_share/datashare.gni") ++# import("//foundation/distributeddatamgr/data_share/datashare.gni") + import("//foundation/distributeddatamgr/relational_store/relational_store.gni") + + module_output_path = "relational_store/rdb_data_share_adapter" +-- +2.33.0 + From 670b63e0ba11605e3becce17a5bbc4d88511187e Mon Sep 17 00:00:00 2001 From: heppen Date: Mon, 28 Aug 2023 16:35:22 +0800 Subject: [PATCH 2/5] add huks component --- 0002-add-huks-component.patch | 2517 +++++++++++++++++++++++++++++++++ 1 file changed, 2517 insertions(+) create mode 100644 0002-add-huks-component.patch diff --git a/0002-add-huks-component.patch b/0002-add-huks-component.patch new file mode 100644 index 0000000..25db6e6 --- /dev/null +++ b/0002-add-huks-component.patch @@ -0,0 +1,2517 @@ +From 9a6bac08ef537d7c07a09ed083b92677e37af193 Mon Sep 17 00:00:00 2001 +From: wang--ge +Date: Tue, 18 Jul 2023 17:19:47 +0800 +Subject: [PATCH] add huks component + +--- + huks/BUILD.gn | 0 + huks/bundle.json | 77 ++++++ + .../huks_standard/main/common/BUILD.gn | 13 + + .../main/common/include/hks_ability.h | 123 +++++++++ + .../main/common/include/hks_base_check.h | 118 ++++++++ + .../main/common/include/hks_cfi.h | 30 +++ + .../main/common/include/hks_check_paramset.h | 62 +++++ + .../main/common/include/hks_cmd_id.h | 78 ++++++ + .../main/common/include/hks_common_check.h | 69 +++++ + .../main/common/include/hks_config.h | 228 ++++++++++++++++ + .../main/common/include/hks_config_base.h | 177 ++++++++++++ + .../main/common/include/hks_config_lite.h | 111 ++++++++ + .../main/common/include/hks_config_small.h | 136 ++++++++++ + .../main/common/include/hks_crypto_adapter.h | 58 ++++ + .../main/common/include/hks_crypto_hal.h | 255 ++++++++++++++++++ + .../main/common/include/hks_errcode_adapter.h | 51 ++++ + .../main/common/include/hks_log.h | 64 +++++ + .../main/common/include/hks_mem.h | 62 +++++ + .../main/common/include/hks_template.h | 75 ++++++ + .../main/common/include/hks_type_inner.h | 94 +++++++ + .../huks_standard/main/os_dependency/BUILD.gn | 10 + + .../ipc/include/hks_client_ipc.h | 90 +++++++ + .../os_dependency/ipc/include/hks_ipc_check.h | 55 ++++ + .../ipc/include/hks_ipc_serialization.h | 76 ++++++ + .../os_dependency/ipc/include/hks_ipc_slice.h | 34 +++ + .../os_dependency/ipc/include/hks_request.h | 69 +++++ + .../ipc/include/hks_samgr_client.h | 32 +++ + .../innerkits/huks_standard/main/BUILD.gn | 23 ++ + .../innerkits/huks_standard/main/include | 1 + + 29 files changed, 2271 insertions(+) + create mode 100644 huks/BUILD.gn + create mode 100644 huks/bundle.json + create mode 100644 huks/frameworks/huks_standard/main/common/BUILD.gn + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_ability.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_base_check.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_cfi.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_check_paramset.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_cmd_id.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_common_check.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_config.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_config_base.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_config_lite.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_config_small.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_crypto_adapter.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_crypto_hal.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_errcode_adapter.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_log.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_mem.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_template.h + create mode 100644 huks/frameworks/huks_standard/main/common/include/hks_type_inner.h + create mode 100644 huks/frameworks/huks_standard/main/os_dependency/BUILD.gn + create mode 100644 huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_client_ipc.h + create mode 100644 huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_check.h + create mode 100644 huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_serialization.h + create mode 100644 huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_slice.h + create mode 100644 huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_request.h + create mode 100644 huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_samgr_client.h + create mode 100644 huks/interfaces/innerkits/huks_standard/main/BUILD.gn + create mode 120000 huks/interfaces/innerkits/huks_standard/main/include + +diff --git a/huks/BUILD.gn b/huks/BUILD.gn +new file mode 100644 +index 0000000..e69de29 +diff --git a/huks/bundle.json b/huks/bundle.json +new file mode 100644 +index 0000000..be04db1 +--- /dev/null ++++ b/huks/bundle.json +@@ -0,0 +1,77 @@ ++{ ++ "name": "@ohos/huks", ++ "description": "The provider of key and certificate manangement capbility, which belongs to security subsystem", ++ "version": "3.1", ++ "license": "Apache License 2.0", ++ "publishAs": "code-segment", ++ "segment": { ++ "destPath": "base/security/huks" ++ }, ++ "dirs":{}, ++ "scripts": { ++ "install": "DEST_PATH=${DEP_BUNDLE_BASE}/base/security/huks && mkdir -p $DEST_PATH && cp -r ./* $DEST_PATH" ++ }, ++ "author": {}, ++ "repository": "", ++ "component": { ++ "name": "huks", ++ "subsystem": "security", ++ "syscap": [ ++ "SystemCapability.Security.Huks", ++ "SystemCapability.Security.Cipher" ++ ], ++ "features": [], ++ "adapted_system_type": [ ++ "standard", ++ "small", ++ "mini" ++ ], ++ "rom": "5000KB", ++ "ram": "500kB", ++ "deps": { ++ "components": [ ++ "ability_base", ++ "access_token", ++ "bundle_framework", ++ "common", ++ "common_event_service", ++ "hisysevent_native", ++ "hitrace_native", ++ "hiviewdfx_hilog_native", ++ "ipc", ++ "napi", ++ "os_account", ++ "safwk", ++ "samgr", ++ "thirdparty_bounds_checking_function", ++ "c_utils" ++ ], ++ "third_party": [ ++ "openssl", ++ "bounds_checking_function" ++ ] ++ }, ++ "build": { ++ "group_type": { ++ "base_group": [], ++ "fwk_group": [ ++ ++ ], ++ "service_group": [ ++ ++ ] ++ }, ++ "inner_kits": [ ++ { ++ "name": "//base/security/huks/interfaces/innerkits/huks_standard/main:libhukssdk", ++ "header": { ++ "header_files": [ ++ "hks_api.h" ++ ], ++ "header_base": "//base/security/huks/interfaces/innerkits/huks_standard/main/include" ++ } ++ } ++ ] ++ } ++ } ++ } +diff --git a/huks/frameworks/huks_standard/main/common/BUILD.gn b/huks/frameworks/huks_standard/main/common/BUILD.gn +new file mode 100644 +index 0000000..4927ee3 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/BUILD.gn +@@ -0,0 +1,13 @@ ++import("//build/ohos.gni") ++ ++config("huks_config") { ++ include_dirs = [ ++ "include", ++ "//base/security/huks/interfaces/innerkits/huks_standard/main/include", ++ ] ++ libs = ("huks_common_standard_static") ++} ++ ++group("libhuks_common_standard_static") { ++ public_configs = [ ":huks_config" ] ++} +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_ability.h b/huks/frameworks/huks_standard/main/common/include/hks_ability.h +new file mode 100644 +index 0000000..56525e9 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_ability.h +@@ -0,0 +1,123 @@ ++/* ++ * Copyright (c) 2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_ABILITY_H ++#define HKS_ABILITY_H ++ ++#include ++ ++enum HksAbilityType { ++ HKS_ABILITY_CRYPTO = 1, ++ HKS_ABILITY_AUTH, ++}; ++ ++enum HksOperationType { ++ HKS_OPERATION_GENERATE_KEY = 0x1, /* generate key */ ++ HKS_OPERATION_GET_PUBLIC_KEY = 0x2, /* get public key */ ++ HKS_OPERATION_DERIVE_KEY = 0x3, /* derive key */ ++ HKS_OPERATION_AGREE_KEY = 0x4, /* agree key */ ++ HKS_OPERATION_SIGN = 0x5, /* sign */ ++ HKS_OPERATION_VERIFY = 0x6, /* verify */ ++ HKS_OPERATION_HMAC_INIT = 0x7, /* hmac init */ ++ HKS_OPERATION_HMAC_UPDATE = 0x8, /* hmac update */ ++ HKS_OPERATION_HMAC_FINAL = 0x9, /* hmac final */ ++ HKS_OPERATION_HASH_INIT = 0xa, /* hash init */ ++ HKS_OPERATION_HASH_UPDATE = 0xb, /* hash update */ ++ HKS_OPERATION_HASH_FINAL = 0xc, /* hash final */ ++ HKS_OPERATION_ENCRYPT_INIT = 0xd, /* encrypt init */ ++ HKS_OPERATION_ENCRYPT_UPDATE = 0xe, /* encrypt update */ ++ HKS_OPERATION_ENCRYPT_FINAL = 0xf, /* encrypt final */ ++ HKS_OPERATION_DECRYPT_INIT = 0x10, /* decrypt init */ ++ HKS_OPERATION_DECRYPT_UPDATE = 0x11, /* decrypt update */ ++ HKS_OPERATION_DECRYPT_FINAL = 0x12, /* decrypt final */ ++ HKS_OPERATION_GET_MAIN_KEY = 0x13, /* get root main key */ ++ HKS_OPERATION_FILL_RANDOM = 0x14, /* fill random */ ++ HKS_OPERATION_HMAC = 0x15, ++ HKS_OPERATION_HASH = 0x16, ++ HKS_OPERATION_ENCRYPT = 0x17, ++ HKS_OPERATION_DECRYPT = 0x18, ++ HKS_OPERATION_BN_EXP_MOD = 0x19, ++ HKS_OPERATION_HASH_FREE_CTX = 0x1a, /* hash free ctx */ ++ HKS_OPERATION_HMAC_FREE_CTX = 0x1b, /* hmac free ctx */ ++ HKS_OPERATION_ENCRYPT_FREE_CTX = 0x1c, /* encrypt free ctx */ ++ HKS_OPERATION_DECRYPT_FREE_CTX = 0x1d, /* decrypt free ctx */ ++ HKS_OPERATION_FILL_PRI_RANDOM = 0x1e, /* fill private random */ ++}; ++ ++struct HksAbility { ++ uint32_t id; ++ void *func; ++}; ++ ++#define HKS_ABILITY_MAX_SIZE 128 ++ ++#define HKS_ABILITY_SHIFT 24 ++#define HKS_CRYPTO_OPERATION_SHIFT 16 ++ ++#define HKS_CRYPTO_ABILITY(type, alg) \ ++ ((HKS_ABILITY_CRYPTO << HKS_ABILITY_SHIFT) | ((type) << HKS_CRYPTO_OPERATION_SHIFT) | (alg)) ++ ++#define HKS_CRYPTO_ABILITY_GENERATE_KEY(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_GENERATE_KEY, alg) ++#define HKS_CRYPTO_ABILITY_GET_PUBLIC_KEY(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_GET_PUBLIC_KEY, alg) ++#define HKS_CRYPTO_ABILITY_DERIVE_KEY(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_DERIVE_KEY, alg) ++#define HKS_CRYPTO_ABILITY_AGREE_KEY(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_AGREE_KEY, alg) ++#define HKS_CRYPTO_ABILITY_SIGN(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_SIGN, alg) ++#define HKS_CRYPTO_ABILITY_VERIFY(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_VERIFY, alg) ++ ++#define HKS_CRYPTO_ABILITY_HMAC HKS_CRYPTO_ABILITY(HKS_OPERATION_HMAC, 0) ++#define HKS_CRYPTO_ABILITY_HMAC_INIT HKS_CRYPTO_ABILITY(HKS_OPERATION_HMAC_INIT, 0) ++#define HKS_CRYPTO_ABILITY_HMAC_UPDATE HKS_CRYPTO_ABILITY(HKS_OPERATION_HMAC_UPDATE, 0) ++#define HKS_CRYPTO_ABILITY_HMAC_FINAL HKS_CRYPTO_ABILITY(HKS_OPERATION_HMAC_FINAL, 0) ++#define HKS_CRYPTO_ABILITY_HMAC_FREE_CTX HKS_CRYPTO_ABILITY(HKS_OPERATION_HMAC_FREE_CTX, 0) ++ ++#define HKS_CRYPTO_ABILITY_HASH HKS_CRYPTO_ABILITY(HKS_OPERATION_HASH, 0) ++#define HKS_CRYPTO_ABILITY_HASH_INIT HKS_CRYPTO_ABILITY(HKS_OPERATION_HASH_INIT, 0) ++#define HKS_CRYPTO_ABILITY_HASH_UPDATE HKS_CRYPTO_ABILITY(HKS_OPERATION_HASH_UPDATE, 0) ++#define HKS_CRYPTO_ABILITY_HASH_FINAL HKS_CRYPTO_ABILITY(HKS_OPERATION_HASH_FINAL, 0) ++#define HKS_CRYPTO_ABILITY_HASH_FREE_CTX HKS_CRYPTO_ABILITY(HKS_OPERATION_HASH_FREE_CTX, 0) ++ ++#define HKS_CRYPTO_ABILITY_ENCRYPT(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_ENCRYPT, alg) ++#define HKS_CRYPTO_ABILITY_ENCRYPT_INIT(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_ENCRYPT_INIT, alg) ++#define HKS_CRYPTO_ABILITY_ENCRYPT_UPDATE(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_ENCRYPT_UPDATE, alg) ++#define HKS_CRYPTO_ABILITY_ENCRYPT_FINAL(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_ENCRYPT_FINAL, alg) ++#define HKS_CRYPTO_ABILITY_ENCRYPT_FREE_CTX(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_ENCRYPT_FREE_CTX, alg) ++ ++#define HKS_CRYPTO_ABILITY_DECRYPT(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_DECRYPT, alg) ++#define HKS_CRYPTO_ABILITY_DECRYPT_INIT(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_DECRYPT_INIT, alg) ++#define HKS_CRYPTO_ABILITY_DECRYPT_UPDATE(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_DECRYPT_UPDATE, alg) ++#define HKS_CRYPTO_ABILITY_DECRYPT_FINAL(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_DECRYPT_FINAL, alg) ++#define HKS_CRYPTO_ABILITY_DECRYPT_FREE_CTX(alg) HKS_CRYPTO_ABILITY(HKS_OPERATION_DECRYPT_FREE_CTX, alg) ++ ++#define HKS_CRYPTO_ABILITY_GET_MAIN_KEY HKS_CRYPTO_ABILITY(HKS_OPERATION_GET_MAIN_KEY, 0) ++ ++#define HKS_CRYPTO_ABILITY_FILL_RANDOM HKS_CRYPTO_ABILITY(HKS_OPERATION_FILL_RANDOM, 0) ++#define HKS_CRYPTO_ABILITY_BN_EXP_MOD HKS_CRYPTO_ABILITY(HKS_OPERATION_BN_EXP_MOD, 0) ++#define HKS_CRYPTO_ABILITY_FILL_PRI_RANDOM HKS_CRYPTO_ABILITY(HKS_OPERATION_FILL_PRI_RANDOM, 0) ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++int32_t RegisterAbility(uint32_t id, void *func); ++ ++void *GetAbility(uint32_t id); ++ ++int32_t HksCryptoAbilityInit(void); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_ABILITY_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_base_check.h b/huks/frameworks/huks_standard/main/common/include/hks_base_check.h +new file mode 100644 +index 0000000..3640dcb +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_base_check.h +@@ -0,0 +1,118 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_BASE_CHECK_H ++#define HKS_BASE_CHECK_H ++ ++#include "hks_param.h" ++#include "hks_type_inner.h" ++ ++enum CheckKeyType { ++ HKS_CHECK_TYPE_GEN_KEY, ++ HKS_CHECK_TYPE_USE_KEY, ++ HKS_CHECK_TYPE_GEN_MAC_KEY, ++ HKS_CHECK_TYPE_GEN_DERIVE_KEY, ++}; ++ ++struct Params { ++ bool needCheck; ++ uint32_t value; ++ bool isAbsent; ++}; ++ ++struct ParamsValues { ++ struct Params keyLen; ++ struct Params padding; ++ struct Params purpose; ++ struct Params digest; ++ struct Params mode; ++}; ++ ++struct ParamsValuesChecker { ++ enum CheckKeyType checkType; ++ struct ParamsValues paramValues; ++}; ++ ++struct ExpectParams { ++ bool needCheck; ++ const uint32_t *values; ++ uint32_t valueCnt; ++}; ++ ++struct ExpectParamsValues { ++ const struct ExpectParams keyLen; ++ const struct ExpectParams padding; ++ const struct ExpectParams purpose; ++ const struct ExpectParams digest; ++ const struct ExpectParams mode; ++}; ++#define EXPECT_PARAMS_VALUES_INIT {{0}, {0}, {0}, {0}, {0}} ++ ++struct ExpectParamsValuesChecker { ++ enum CheckKeyType checkType; ++ const struct ExpectParamsValues paramValues; ++}; ++ ++struct AuthAccessTypeChecker { ++ enum HksUserAuthType userAuthType; ++ const struct ExpectParams allowAuthAccessTypes; ++}; ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++int32_t HksCheckValue(uint32_t inputValue, const uint32_t *expectValues, uint32_t valuesCount); ++ ++int32_t HksGetKeySize(uint32_t alg, const struct HksBlob *key, uint32_t *keySize); ++ ++int32_t HksCheckGenKeyPurpose(uint32_t alg, uint32_t inputPurpose); ++ ++int32_t HksGetInputParmasByAlg(uint32_t alg, enum CheckKeyType checkType, const struct HksParamSet *paramSet, ++ struct ParamsValues *inputParams); ++ ++int32_t HksCheckFixedParams(uint32_t alg, enum CheckKeyType checkType, const struct ParamsValues *inputParams); ++ ++int32_t HksCheckGenKeyMutableParams(uint32_t alg, const struct ParamsValues *inputParams); ++ ++int32_t CheckImportMutableParams(uint32_t alg, const struct ParamsValues *params); ++ ++int32_t HksCheckSignature(uint32_t cmdId, uint32_t alg, uint32_t keySize, const struct HksBlob *signature); ++ ++int32_t HksCheckSignVerifyMutableParams(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams); ++ ++int32_t HksCheckCipherMutableParams(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams); ++ ++int32_t HksCheckCihperData(uint32_t cmdId, uint32_t alg, const struct ParamsValues *inputParams, ++ const struct HksBlob *inData, const struct HksBlob *outData); ++ ++int32_t HksCheckCipherMaterialParams(uint32_t alg, const struct ParamsValues *inputParams, ++ const struct HksParamSet *paramSet); ++ ++int32_t HksCheckUserAuthParams(uint32_t userAuthType, uint32_t authAccessType, uint32_t challengeType); ++ ++int32_t HksCheckSecureSignParams(uint32_t secureSignType); ++ ++int32_t GetInputParams(const struct HksParamSet *paramSet, struct ParamsValues *inputParams); ++ ++int32_t HksCheckOptionalParam(uint32_t tag, uint32_t alg, uint32_t purpose, bool isAbsent, struct HksParam *param); ++ ++int32_t HksCheckNeedCache(uint32_t alg, uint32_t digest); ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_BASE_CHECK_H */ ++ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_cfi.h b/huks/frameworks/huks_standard/main/common/include/hks_cfi.h +new file mode 100644 +index 0000000..855b66f +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_cfi.h +@@ -0,0 +1,30 @@ ++/* ++ * Copyright (c) 2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CFI_H ++#define HKS_CFI_H ++ ++#ifdef HKS_CONFIG_FILE ++#include HKS_CONFIG_FILE ++#else ++#include "hks_config.h" ++#endif ++ ++#ifdef HKS_SUPPORT_CFI ++#define ENABLE_CFI(function) __attribute__((no_sanitize("cfi"))) function ++#else ++#define ENABLE_CFI(function) function ++#endif ++#endif // HKS_CFI_H +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_check_paramset.h b/huks/frameworks/huks_standard/main/common/include/hks_check_paramset.h +new file mode 100644 +index 0000000..4aa31e5 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_check_paramset.h +@@ -0,0 +1,62 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CHECK_PARAMSET_H ++#define HKS_CHECK_PARAMSET_H ++ ++#include ++#include ++ ++#include "hks_type_inner.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++int32_t HksCoreCheckGenKeyParams(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, ++ const struct HksBlob *keyIn, const struct HksBlob *keyOut); ++ ++int32_t HksCoreCheckImportKeyParams(const struct HksBlob *keyAlias, const struct HksBlob *key, ++ const struct HksParamSet *paramSet, const struct HksBlob *keyOut); ++ ++int32_t HksCoreCheckImportWrappedKeyParams(const struct HksBlob *key, const struct HksBlob *wrappedKeyData, ++ const struct HksParamSet *paramSet, struct HksBlob *keyOut, uint32_t *outUnwrapSuite); ++ ++int32_t HksCoreCheckSignVerifyParams(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, ++ const struct HksBlob *srcData, const struct HksBlob *signature); ++ ++int32_t HksCoreCheckCipherParams(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, ++ const struct HksBlob *inData, const struct HksBlob *outData); ++ ++int32_t HksCoreCheckAgreeKeyParams(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, ++ const struct HksBlob *peerPublicKey, const struct HksBlob *agreedKey, bool isLocalCheck); ++ ++int32_t HksLocalCheckSignVerifyParams(uint32_t cmdId, uint32_t keySize, const struct HksParamSet *paramSet, ++ const struct HksBlob *srcData, const struct HksBlob *signature); ++ ++int32_t HksLocalCheckCipherParams(uint32_t cmdId, uint32_t keySize, const struct HksParamSet *paramSet, ++ const struct HksBlob *inData, const struct HksBlob *outData); ++ ++int32_t HksCoreCheckDeriveKeyParams(const struct HksParamSet *paramSet, const struct HksBlob *mainKey, ++ const struct HksBlob *derivedKey, bool isLocalCheck); ++ ++int32_t HksCoreCheckMacParams(const struct HksBlob *key, const struct HksParamSet *paramSet, ++ const struct HksBlob *srcData, const struct HksBlob *mac, bool isLocalCheck); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_CHECK_PARAMSET_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_cmd_id.h b/huks/frameworks/huks_standard/main/common/include/hks_cmd_id.h +new file mode 100644 +index 0000000..89606c1 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_cmd_id.h +@@ -0,0 +1,78 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CMD_ID_H ++#define HKS_CMD_ID_H ++ ++#include "hks_type_inner.h" ++ ++enum HksCmdId { ++ HKS_CMD_ID_INVALID = 0x0, ++ HKS_CMD_ID_GENERATE_KEY, ++ HKS_CMD_ID_GET_KEY_CHARACTER, ++ HKS_CMD_ID_BEGIN, ++ HKS_CMD_ID_UPDATE, ++ HKS_CMD_ID_FINISH, ++ HKS_CMD_ID_ABORT, ++ HKS_CMD_ID_SET, ++ HKS_CMD_ID_GET, ++ HKS_CMD_ID_ATTEST_KEY, ++ HKS_CMD_ID_EXPORT_KEY, ++ HKS_CMD_ID_DELETE, ++ HKS_CMD_ID_EXPORT_TRUST_CERT, ++ HKS_CMD_ID_ECDH, ++ HKS_CMD_ID_ATTEST_TA_KEY, ++ HKS_CMD_ID_SET_KEY_PROTECTION, ++ HKS_CMD_ID_CONFIGURE, ++ ++ HKS_CMD_ID_IMPORT_KEY = 0x100, ++ HKS_CMD_ID_GET_CERTCHAIN = 0x101, ++ HKS_CMD_ID_SIGN = 0x102, ++ HKS_CMD_ID_SIGN_INIT = 0x103, ++ HKS_CMD_ID_SIGN_UPDATE = 0x104, ++ HKS_CMD_ID_SIGN_FINAL = 0x105, ++ HKS_CMD_ID_VERIFY = 0x106, ++ HKS_CMD_ID_VERIFY_INIT = 0x107, ++ HKS_CMD_ID_VERIFY_UPDATE = 0x108, ++ HKS_CMD_ID_VERIFY_FINAL = 0x109, ++ HKS_CMD_ID_MAC = 0x10A, ++ HKS_CMD_ID_MAC_INIT = 0x10B, ++ HKS_CMD_ID_MAC_UPDATE = 0x10C, ++ HKS_CMD_ID_MAC_FINAL = 0x10D, ++ HKS_CMD_ID_ENCRYPT = 0x10E, ++ HKS_CMD_ID_ENCRYPT_INIT = 0x10F, ++ HKS_CMD_ID_ENCRYPT_UPDATE = 0x110, ++ HKS_CMD_ID_ENCRYPT_FINAL = 0x111, ++ HKS_CMD_ID_DECRYPT = 0x112, ++ HKS_CMD_ID_DECRYPT_INIT = 0x113, ++ HKS_CMD_ID_DECRYPT_UPDATE = 0x114, ++ HKS_CMD_ID_DECRYPT_FINAL = 0x115, ++ HKS_CMD_ID_CHECK_KEY_LEGALITY = 0x116, ++ HKS_CMD_ID_GENERATE_RANDOM = 0x117, ++ HKS_CMD_ID_AGREE_KEY = 0x118, ++ HKS_CMD_ID_DERIVE_KEY = 0x119, ++ ++ HKS_CMD_ID_WRAP = 0x1000, ++ HKS_CMD_ID_UNWRAP = 0x1001, ++ ++ HKS_CMD_ID_SIGN_WITH_DEV_KEY = 0x00010103, ++ ++ HKS_CMD_ID_GET_FP_AUTH_RESULT_QCOM = 0x00020500, ++ ++ HKS_CMD_ID_INJECT_KEY = 0x00010015, ++ HKS_CMD_ID_INJECT_KEY_VERIFY = 0x00010016, ++}; ++ ++#endif +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_common_check.h b/huks/frameworks/huks_standard/main/common/include/hks_common_check.h +new file mode 100644 +index 0000000..db6a986 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_common_check.h +@@ -0,0 +1,69 @@ ++/* ++ * Copyright (c) 2021-2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_COMMON_CHECK_H ++#define HKS_COMMON_CHECK_H ++ ++#include ++#include ++ ++#include "hks_type.h" ++ ++#define HKS_DIGEST_MD5_LEN 16 ++#define HKS_DIGEST_SHA1_LEN 20 ++#define HKS_DIGEST_SHA224_LEN 28 ++#define HKS_DIGEST_SHA256_LEN 32 ++#define HKS_DIGEST_SHA384_LEN 48 ++#define HKS_DIGEST_SHA512_LEN 64 ++#define HKS_DIGEST_SM3_LEN 32 ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++int32_t HksCheckBlob4(const struct HksBlob *data1, const struct HksBlob *data2, ++ const struct HksBlob *data3, const struct HksBlob *data4); ++ ++int32_t HksCheckBlob3(const struct HksBlob *data1, const struct HksBlob *data2, const struct HksBlob *data3); ++ ++int32_t HksCheckBlob2(const struct HksBlob *data1, const struct HksBlob *data2); ++ ++int32_t HksCheckParamSetValidity(const struct HksParamSet *paramSet); ++ ++int32_t HksCheckBlob4AndParamSet(const struct HksBlob *data1, const struct HksBlob *data2, ++ const struct HksBlob *data3, const struct HksBlob *data4, const struct HksParamSet *paramSet); ++ ++int32_t HksCheckBlob3AndParamSet(const struct HksBlob *data1, const struct HksBlob *data2, ++ const struct HksBlob *data3, const struct HksParamSet *paramSet); ++ ++int32_t HksCheckBlob2AndParamSet(const struct HksBlob *data1, const struct HksBlob *data2, ++ const struct HksParamSet *paramSet); ++ ++int32_t HksCheckBlobAndParamSet(const struct HksBlob *data, const struct HksParamSet *paramSet); ++ ++int32_t HksGetDigestLen(uint32_t digest, uint32_t *digestLen); ++ ++int32_t HksCheckAesAeMode(const struct HksParamSet *paramSet, bool *isAes, bool *isAeMode); ++ ++int32_t HksCheckWrappedDataFormatValidity(const struct HksBlob *wrappedData, uint32_t validTotalBlobs, ++ const uint32_t *validBlobLengths); ++ ++int32_t HksGetBlobFromWrappedData(const struct HksBlob *wrappedData, uint32_t blobIndex, uint32_t totalBlobs, ++ struct HksBlob *blob); ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_COMMON_CHECK_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_config.h b/huks/frameworks/huks_standard/main/common/include/hks_config.h +new file mode 100644 +index 0000000..188b48f +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_config.h +@@ -0,0 +1,228 @@ ++/* ++ * Copyright (c) 2021-2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CONFIG_H ++#define HKS_CONFIG_H ++ ++#define HKS_SUPPORT_POSIX ++ ++#define HKS_SUPPORT_THREAD ++ ++#define HKS_LOG_ENGINE_LOG_CORE ++#define HKS_ENABLE_LOG_PUBLIC ++ ++#define HKS_SUPPORT_API_ATTEST_KEY ++ ++// #define HKS_SUPPORT_ACCESS_TOKEN ++ ++/* AES */ ++#define HKS_SUPPORT_AES_C ++#define HKS_SUPPORT_AES_GENERATE_KEY ++#define HKS_SUPPORT_AES_CBC_NOPADDING ++#define HKS_SUPPORT_AES_CBC_PKCS7 ++#define HKS_SUPPORT_AES_GCM ++#define HKS_SUPPORT_AES_CTR_NOPADDING ++#define HKS_SUPPORT_AES_ECB_NOPADDING ++#define HKS_SUPPORT_AES_ECB_PKCS7PADDING ++ ++/* BN */ ++#define HKS_SUPPORT_BN_C ++ ++/* ECC */ ++#define HKS_SUPPORT_ECC_C ++#define HKS_SUPPORT_ECC_GENERATE_KEY ++#define HKS_SUPPORT_ECC_GET_PUBLIC_KEY ++ ++#define HKS_SUPPORT_ECDH_C ++#define HKS_SUPPORT_ECDH_AGREE_KEY ++ ++#define HKS_SUPPORT_ECDSA_C ++#define HKS_SUPPORT_ECDSA_SIGN_VERIFY ++ ++/* ED25519 */ ++#define HKS_SUPPORT_ED25519_C ++#define HKS_SUPPORT_ED25519_GENERATE_KEY ++#define HKS_SUPPORT_ED25519_SIGN_VERIFY ++#define HKS_SUPPORT_ED2519_GET_PUBLIC_KEY ++ ++/* HASH */ ++#define HKS_SUPPORT_HASH_C ++#define HKS_SUPPORT_HASH_SHA1 ++#define HKS_SUPPORT_HASH_SHA224 ++#define HKS_SUPPORT_HASH_SHA256 ++#define HKS_SUPPORT_HASH_SHA384 ++#define HKS_SUPPORT_HASH_SHA512 ++#define HKS_SUPPORT_HASH_MD5 ++ ++/* HMAC */ ++#define HKS_SUPPORT_HMAC_C ++#define HKS_SUPPORT_HMAC_GENERATE_KEY ++#define HKS_SUPPORT_HMAC_SHA1 ++#define HKS_SUPPORT_HMAC_SHA224 ++#define HKS_SUPPORT_HMAC_SHA256 ++#define HKS_SUPPORT_HMAC_SHA384 ++#define HKS_SUPPORT_HMAC_SHA512 ++ ++/* KDF */ ++#define HKS_SUPPORT_KDF_C ++#define HKS_SUPPORT_KDF_PBKDF2 ++#define HKS_SUPPORT_KDF_HKDF ++ ++/* RSA */ ++#define HKS_SUPPORT_RSA_C ++#define HKS_SUPPORT_RSA_GENERATE_KEY ++#define HKS_SUPPORT_RSA_CRYPT ++#define HKS_SUPPORT_RSA_SIGN_VERIFY ++#define HKS_SUPPORT_RSA_GET_PUBLIC_KEY ++#define HKS_SUPPORT_RSA_ECB_NOPADDING ++#define HKS_SUPPORT_RSA_ECB_PKCS1PADDING ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA1MGF1 ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA224MGF1 ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA256MGF1 ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA384MGF1 ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA512MGF1 ++#define HKS_SUPPORT_RSA_ECB_OEAPPADDING ++#define HKS_SUPPORT_RSA_PSS ++ ++/* DH */ ++#define HKS_SUPPORT_DH_C ++#define HKS_SUPPORT_DH_GENERATE_KEY ++#define HKS_SUPPORT_DH_AGREE_KEY ++#define HKS_SUPPORT_DH_GET_PUBLIC_KEY ++ ++/* DSA */ ++#define HKS_SUPPORT_DSA_C ++#define HKS_SUPPORT_DSA_GENERATE_KEY ++#define HKS_SUPPORT_DSA_SIGN_VERIFY ++#define HKS_SUPPORT_DSA_GET_PUBLIC_KEY ++ ++/* X25519 */ ++#define HKS_SUPPORT_X25519_C ++#define HKS_SUPPORT_X25519_GENERATE_KEY ++#define HKS_SUPPORT_X25519_AGREE_KEY ++#define HKS_SUPPORT_X25519_GET_PUBLIC_KEY ++ ++#define HKS_SUPPORT_ED25519_TO_X25519 ++ ++/* SM2 */ ++#ifdef HKS_SUPPORT_ECC_C ++#define HKS_SUPPORT_SM2_C ++#define HKS_SUPPORT_SM2_SIGN_VERIFY ++#ifdef HKS_SUPPORT_ECC_GENERATE_KEY ++#define HKS_SUPPORT_SM2_GENERATE_KEY ++#endif ++#ifdef HKS_SUPPORT_ECC_GET_PUBLIC_KEY ++#define HKS_SUPPORT_SM2_GET_PUBLIC_KEY ++#endif ++#endif ++ ++/* SM3 */ ++#define HKS_SUPPORT_SM3_C ++#define HKS_SUPPORT_SM3_GENERATE_KEY ++#if defined(HKS_SUPPORT_SM3_C) && defined(HKS_SUPPORT_HMAC_C) ++#define HKS_SUPPORT_HMAC_SM3 ++#endif ++#if defined(HKS_SUPPORT_SM3_C) && defined(HKS_SUPPORT_HASH_C) ++#define HKS_SUPPORT_HASH_SM3 ++#endif ++ ++/* SM4 */ ++#define HKS_SUPPORT_SM4_C ++#define HKS_SUPPORT_SM4_GENERATE_KEY ++#define HKS_SUPPORT_SM4_CBC_NOPADDING ++#define HKS_SUPPORT_SM4_CBC_PKCS7 ++#define HKS_SUPPORT_SM4_CTR_NOPADDING ++#define HKS_SUPPORT_SM4_ECB_NOPADDING ++#define HKS_SUPPORT_SM4_ECB_PKCS7 ++ ++/* enable cfi */ ++#define HKS_SUPPORT_CFI ++ ++#if defined(_SUPPORT_HKS_TEE_) && defined(HKS_SUPPORT_HMAC_GENERATE_KEY) ++#define HKS_SUPPORT_GET_AT_KEY ++#endif ++ ++#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_DH_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_DSA_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_HMAC_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_RSA_GENERATE_KEY) || defined(HKS_SUPPORT_X25519_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_SM2_GENERATE_KEY) || defined(HKS_SUPPORT_SM3_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_SM4_GENERATE_KEY) ++#define HKS_SUPPORT_API_GENERATE_KEY ++#define HKS_SUPPORT_API_DELETE_KEY ++#define HKS_SUPPORT_API_GET_KEY_PARAM_SET ++#define HKS_SUPPORT_API_KEY_EXIST ++#endif ++ ++#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ ++ defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ ++ defined(HKS_SUPPORT_DH_C) || defined(HKS_SUPPORT_SM2_C) ++#define HKS_SUPPORT_API_IMPORT ++#endif ++ ++#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ ++ defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ ++ defined(HKS_SUPPORT_DH_C) || defined(HKS_SUPPORT_SM2_C) ++#define HKS_SUPPORT_API_EXPORT ++#endif ++ ++#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ ++ defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ ++ defined(HKS_SUPPORT_DH_C) || defined(HKS_SUPPORT_SM2_C) ++#define HKS_SUPPORT_API_IMPORT_WRAPPED_KEY ++#endif ++ ++#define HKS_SUPPORT_API_GENERATE_RANDOM ++ ++#if defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ ++ defined(HKS_SUPPORT_RSA_SIGN_VERIFY) || defined(HKS_SUPPORT_DSA_SIGN_VERIFY) ++#define HKS_SUPPORT_API_SIGN_VERIFY ++#endif ++ ++#if defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_RSA_CRYPT) ++#define HKS_SUPPORT_API_CIPHER ++#endif ++ ++#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_AGREE_KEY) || defined(HKS_SUPPORT_DH_AGREE_KEY) ++#define HKS_SUPPORT_API_AGREE_KEY ++#endif ++ ++#ifdef HKS_SUPPORT_KDF_C ++#define HKS_SUPPORT_API_DERIVE_KEY ++#endif ++ ++#ifdef HKS_SUPPORT_HMAC_C ++#define HKS_SUPPORT_API_MAC ++#endif ++ ++#ifdef HKS_SUPPORT_HASH_C ++#define HKS_SUPPORT_API_HASH ++#endif ++ ++#ifdef HKS_SUPPORT_BN_C ++#define HKS_SUPPORT_API_BN_EXP_MOD ++#endif ++ ++#ifndef HKS_SUPPORT_LITE_HEAP ++#define HKS_SUPPORT_API_GET_KEY_INFO_LIST ++#endif ++ ++/* Key user auth access control */ ++// #if defined(HKS_SUPPORT_HMAC_C) && defined(HKS_SUPPORT_API_GENERATE_KEY) && (defined(HKS_SUPPORT_API_IMPORT) || \ ++// defined(HKS_SUPPORT_API_GENERATE_KEY) || defined(HKS_SUPPORT_API_IMPORT_WRAPPED_KEY)) ++// #define HKS_SUPPORT_USER_AUTH_ACCESS_CONTROL ++// #endif ++ ++#endif /* HKS_CONFIG_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_config_base.h b/huks/frameworks/huks_standard/main/common/include/hks_config_base.h +new file mode 100644 +index 0000000..f1c9fb1 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_config_base.h +@@ -0,0 +1,177 @@ ++/* ++ * Copyright (c) 2021-2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CONFIG_H ++#define HKS_CONFIG_H ++ ++#define HKS_SUPPORT_LITE_HEAP ++#define HKS_SUPPORT_UPGRADE_STORAGE_DATA ++#define HKS_SUPPORT_POSIX ++ ++#define HKS_SUPPORT_SEC_LEVEL ++ ++/* AES */ ++#define HKS_SUPPORT_AES_C ++#define HKS_SUPPORT_AES_GENERATE_KEY ++#define HKS_SUPPORT_AES_CBC_NOPADDING ++#define HKS_SUPPORT_AES_CBC_PKCS7 ++#define HKS_SUPPORT_AES_GCM ++#define HKS_SUPPORT_AES_CCM ++#define HKS_SUPPORT_AES_CTR_NOPADDING ++#define HKS_SUPPORT_AES_ECB_NOPADDING ++#define HKS_SUPPORT_AES_ECB_PKCS7PADDING ++ ++/* BN */ ++#define HKS_SUPPORT_BN_C ++ ++/* ECC */ ++#define HKS_SUPPORT_ECC_C ++#define HKS_SUPPORT_ECC_GENERATE_KEY ++#define HKS_SUPPORT_ECC_GET_PUBLIC_KEY ++ ++#define HKS_SUPPORT_ECDH_C ++#define HKS_SUPPORT_ECDH_AGREE_KEY ++ ++#define HKS_SUPPORT_ECDSA_C ++#define HKS_SUPPORT_ECDSA_SIGN_VERIFY ++ ++/* ED25519 */ ++#define HKS_SUPPORT_ED25519_C ++#define HKS_SUPPORT_ED25519_GENERATE_KEY ++#define HKS_SUPPORT_ED25519_SIGN_VERIFY ++#define HKS_SUPPORT_ED2519_GET_PUBLIC_KEY ++ ++/* HASH */ ++#define HKS_SUPPORT_HASH_C ++#define HKS_SUPPORT_HASH_SHA1 ++#define HKS_SUPPORT_HASH_SHA224 ++#define HKS_SUPPORT_HASH_SHA256 ++#define HKS_SUPPORT_HASH_SHA384 ++#define HKS_SUPPORT_HASH_SHA512 ++#define HKS_SUPPORT_HASH_MD5 ++ ++/* HMAC */ ++#define HKS_SUPPORT_HMAC_C ++#define HKS_SUPPORT_HMAC_GENERATE_KEY ++#define HKS_SUPPORT_HMAC_SHA1 ++#define HKS_SUPPORT_HMAC_SHA224 ++#define HKS_SUPPORT_HMAC_SHA256 ++#define HKS_SUPPORT_HMAC_SHA384 ++#define HKS_SUPPORT_HMAC_SHA512 ++ ++/* KDF */ ++#define HKS_SUPPORT_KDF_C ++#define HKS_SUPPORT_KDF_PBKDF2 ++#define HKS_SUPPORT_KDF_HKDF ++ ++/* RSA */ ++#define HKS_SUPPORT_RSA_C ++#define HKS_SUPPORT_RSA_GENERATE_KEY ++#define HKS_SUPPORT_RSA_CRYPT ++#define HKS_SUPPORT_RSA_SIGN_VERIFY ++#define HKS_SUPPORT_RSA_GET_PUBLIC_KEY ++#define HKS_SUPPORT_RSA_ECB_NOPADDING ++#define HKS_SUPPORT_RSA_ECB_PKCS1PADDING ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA1MGF1 ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA224MGF1 ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA256MGF1 ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA384MGF1 ++#define HKS_SUPPORT_RSA_ECB_OAEPPADDING_SHA512MGF1 ++#define HKS_SUPPORT_RSA_ECB_OEAPPADDING ++#define HKS_SUPPORT_RSA_PSS ++ ++/* DH */ ++#define HKS_SUPPORT_DH_C ++#define HKS_SUPPORT_DH_GENERATE_KEY ++#define HKS_SUPPORT_DH_AGREE_KEY ++#define HKS_SUPPORT_DH_GET_PUBLIC_KEY ++ ++/* DSA */ ++#define HKS_SUPPORT_DSA_C ++#define HKS_SUPPORT_DSA_GENERATE_KEY ++#define HKS_SUPPORT_DSA_SIGN_VERIFY ++#define HKS_SUPPORT_DSA_GET_PUBLIC_KEY ++ ++/* X25519 */ ++#define HKS_SUPPORT_X25519_C ++#define HKS_SUPPORT_X25519_GENERATE_KEY ++#define HKS_SUPPORT_X25519_AGREE_KEY ++#define HKS_SUPPORT_X25519_GET_PUBLIC_KEY ++ ++#define HKS_SUPPORT_ED25519_TO_X25519 ++ ++#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_DH_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_DSA_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_HMAC_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_RSA_GENERATE_KEY) || defined(HKS_SUPPORT_X25519_GENERATE_KEY) ++#define HKS_SUPPORT_API_GENERATE_KEY ++#define HKS_SUPPORT_API_DELETE_KEY ++#define HKS_SUPPORT_API_GET_KEY_PARAM_SET ++#define HKS_SUPPORT_API_KEY_EXIST ++#endif ++ ++#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ ++ defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ ++ defined(HKS_SUPPORT_DH_C) ++#define HKS_SUPPORT_API_IMPORT ++#endif ++ ++#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || defined(HKS_SUPPORT_ED25519_C) || \ ++ defined(HKS_SUPPORT_X25519_C) || defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_DSA_C) || \ ++ defined(HKS_SUPPORT_DH_C) ++#define HKS_SUPPORT_API_EXPORT ++#endif ++ ++#define HKS_SUPPORT_API_GENERATE_RANDOM ++ ++#if defined(HKS_SUPPORT_ECDSA_SIGN_VERIFY) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ ++ defined(HKS_SUPPORT_RSA_SIGN_VERIFY) || defined(HKS_SUPPORT_DSA_SIGN_VERIFY) ++#define HKS_SUPPORT_API_SIGN_VERIFY ++#endif ++ ++#if defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_RSA_CRYPT) ++#define HKS_SUPPORT_API_CIPHER ++#endif ++ ++#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_AGREE_KEY) || defined(HKS_SUPPORT_DH_AGREE_KEY) ++#define HKS_SUPPORT_API_AGREE_KEY ++#endif ++ ++#ifdef HKS_SUPPORT_KDF_C ++#define HKS_SUPPORT_API_DERIVE_KEY ++#endif ++ ++#ifdef HKS_SUPPORT_HMAC_C ++#define HKS_SUPPORT_API_MAC ++#endif ++ ++#ifdef HKS_SUPPORT_HASH_C ++#define HKS_SUPPORT_API_HASH ++#endif ++ ++#ifdef HKS_SUPPORT_BN_C ++#define HKS_SUPPORT_API_BN_EXP_MOD ++#endif ++ ++#ifndef HKS_SUPPORT_LITE_HEAP ++#define HKS_SUPPORT_API_GET_KEY_INFO_LIST ++#endif ++ ++#define HKS_SUPPORT_API_ATTEST_KEY ++#define HKS_SUPPORT_API_GET_CERTIFICATE_CHAIN ++#define HKS_SUPPORT_API_WRAP_KEY ++#define HKS_SUPPORT_API_UNWRAP_KEY ++ ++#endif /* HKS_CONFIG_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_config_lite.h b/huks/frameworks/huks_standard/main/common/include/hks_config_lite.h +new file mode 100644 +index 0000000..61ff132 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_config_lite.h +@@ -0,0 +1,111 @@ ++/* ++ * Copyright (c) 2021-2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CONFIG_H ++#define HKS_CONFIG_H ++ ++#define HKS_SUPPORT_POSIX ++ ++#define HKS_LOG_ENGINE_HILOG_MODULE_SCY ++ ++/* AES */ ++#define HKS_SUPPORT_AES_C ++#define HKS_SUPPORT_AES_GENERATE_KEY ++#define HKS_SUPPORT_AES_CBC_NOPADDING ++#define HKS_SUPPORT_AES_CBC_PKCS7 ++#define HKS_SUPPORT_AES_GCM ++ ++/* BN */ ++#define HKS_SUPPORT_BN_C ++ ++/* HASH */ ++#define HKS_SUPPORT_HASH_C ++#define HKS_SUPPORT_HASH_SHA256 ++#define HKS_SUPPORT_HASH_SHA384 ++#define HKS_SUPPORT_HASH_SHA512 ++ ++/* HMAC */ ++#define HKS_SUPPORT_HMAC_C ++#define HKS_SUPPORT_HMAC_SHA256 ++#define HKS_SUPPORT_HMAC_SHA384 ++#define HKS_SUPPORT_HMAC_SHA512 ++ ++/* KDF */ ++#define HKS_SUPPORT_KDF_C ++#define HKS_SUPPORT_KDF_PBKDF2 ++#define HKS_SUPPORT_KDF_HKDF ++ ++/* X25519 */ ++#define HKS_SUPPORT_X25519_C ++#define HKS_SUPPORT_X25519_GENERATE_KEY ++#define HKS_SUPPORT_X25519_AGREE_KEY ++#define HKS_SUPPORT_X25519_GET_PUBLIC_KEY ++ ++#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_RSA_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_X25519_GENERATE_KEY) ++#define HKS_SUPPORT_API_GENERATE_KEY ++#define HKS_SUPPORT_API_DELETE_KEY ++#define HKS_SUPPORT_API_GET_KEY_PARAM_SET ++#define HKS_SUPPORT_API_KEY_EXIST ++#endif ++ ++#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ ++ defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) || \ ++ defined(HKS_SUPPORT_AES_C) ++#define HKS_SUPPORT_API_IMPORT ++#endif ++ ++#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ ++ defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) ++#define HKS_SUPPORT_API_EXPORT ++#endif ++ ++#define HKS_SUPPORT_API_GENERATE_RANDOM ++ ++#if defined(HKS_SUPPORT_ECDSA_C) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ ++ defined(HKS_SUPPORT_RSA_SIGN_VERIFY) ++#define HKS_SUPPORT_API_SIGN_VERIFY ++#endif ++ ++#if defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_RSA_CRYPT) ++#define HKS_SUPPORT_API_CIPHER ++#endif ++ ++#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_C) ++#define HKS_SUPPORT_API_AGREE_KEY ++#endif ++ ++#ifdef HKS_SUPPORT_KDF_C ++#define HKS_SUPPORT_API_DERIVE_KEY ++#endif ++ ++#ifdef HKS_SUPPORT_HMAC_C ++#define HKS_SUPPORT_API_MAC ++#endif ++ ++#ifdef HKS_SUPPORT_HASH_C ++#define HKS_SUPPORT_API_HASH ++#endif ++ ++#ifdef HKS_SUPPORT_BN_C ++#define HKS_SUPPORT_API_BN_EXP_MOD ++#endif ++ ++#ifndef HKS_SUPPORT_LITE_HEAP ++#define HKS_SUPPORT_API_GET_KEY_INFO_LIST ++#endif ++ ++#endif /* HKS_CONFIG_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_config_small.h b/huks/frameworks/huks_standard/main/common/include/hks_config_small.h +new file mode 100644 +index 0000000..d8692e7 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_config_small.h +@@ -0,0 +1,136 @@ ++/* ++ * Copyright (c) 2021-2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CONFIG_H ++#define HKS_CONFIG_H ++ ++#define HKS_SUPPORT_POSIX ++ ++#ifndef __LINUX__ ++#define HKS_ENABLE_LOG_PUBLIC ++#endif ++#define HKS_LOG_ENGINE_HILOG_MODULE_SCY ++ ++/* AES */ ++#define HKS_SUPPORT_AES_C ++#define HKS_SUPPORT_AES_GENERATE_KEY ++#define HKS_SUPPORT_AES_CBC_NOPADDING ++#define HKS_SUPPORT_AES_CBC_PKCS7 ++#define HKS_SUPPORT_AES_GCM ++ ++/* BN */ ++#define HKS_SUPPORT_BN_C ++ ++/* ECC */ ++#define HKS_SUPPORT_ECC_C ++#define HKS_SUPPORT_ECC_GENERATE_KEY ++#define HKS_SUPPORT_ECC_GET_PUBLIC_KEY ++#define HKS_SUPPORT_ECDH_C ++#define HKS_SUPPORT_ECDSA_C ++ ++/* ED25519 */ ++#define HKS_SUPPORT_ED25519_C ++#define HKS_SUPPORT_ED25519_GENERATE_KEY ++#define HKS_SUPPORT_ED25519_SIGN_VERIFY ++#define HKS_SUPPORT_ED2519_GET_PUBLIC_KEY ++ ++/* HASH */ ++#define HKS_SUPPORT_HASH_C ++#define HKS_SUPPORT_HASH_SHA256 ++#define HKS_SUPPORT_HASH_SHA384 ++#define HKS_SUPPORT_HASH_SHA512 ++ ++/* HMAC */ ++#define HKS_SUPPORT_HMAC_C ++#define HKS_SUPPORT_HMAC_SHA256 ++#define HKS_SUPPORT_HMAC_SHA384 ++#define HKS_SUPPORT_HMAC_SHA512 ++ ++/* KDF */ ++#define HKS_SUPPORT_KDF_C ++#define HKS_SUPPORT_KDF_PBKDF2 ++#define HKS_SUPPORT_KDF_HKDF ++ ++/* RSA */ ++#define HKS_SUPPORT_RSA_C ++#define HKS_SUPPORT_RSA_GENERATE_KEY ++#define HKS_SUPPORT_RSA_CRYPT ++#define HKS_SUPPORT_RSA_SIGN_VERIFY ++#define HKS_SUPPORT_RSA_GET_PUBLIC_KEY ++ ++/* X25519 */ ++#define HKS_SUPPORT_X25519_C ++#define HKS_SUPPORT_X25519_GENERATE_KEY ++#define HKS_SUPPORT_X25519_AGREE_KEY ++#define HKS_SUPPORT_X25519_GET_PUBLIC_KEY ++ ++#define HKS_SUPPORT_ED25519_TO_X25519 ++ ++#if defined(HKS_SUPPORT_AES_GENERATE_KEY) || defined(HKS_SUPPORT_ECC_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_ED25519_GENERATE_KEY) || defined(HKS_SUPPORT_RSA_GENERATE_KEY) || \ ++ defined(HKS_SUPPORT_X25519_GENERATE_KEY) ++#define HKS_SUPPORT_API_GENERATE_KEY ++#define HKS_SUPPORT_API_DELETE_KEY ++#define HKS_SUPPORT_API_GET_KEY_PARAM_SET ++#define HKS_SUPPORT_API_KEY_EXIST ++#endif ++ ++#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ ++ defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) || \ ++ defined(HKS_SUPPORT_AES_C) ++#define HKS_SUPPORT_API_IMPORT ++#endif ++ ++#if defined(HKS_SUPPORT_ECC_C) || defined(HKS_SUPPORT_RSA_C) || \ ++ defined(HKS_SUPPORT_ED25519_C) || defined(HKS_SUPPORT_X25519_C) ++#define HKS_SUPPORT_API_EXPORT ++#endif ++ ++#define HKS_SUPPORT_API_GENERATE_RANDOM ++ ++#if defined(HKS_SUPPORT_ECDSA_C) || defined(HKS_SUPPORT_ED25519_SIGN_VERIFY) || \ ++ defined(HKS_SUPPORT_RSA_SIGN_VERIFY) ++#define HKS_SUPPORT_API_SIGN_VERIFY ++#endif ++ ++#if defined(HKS_SUPPORT_AES_C) || defined(HKS_SUPPORT_RSA_CRYPT) ++#define HKS_SUPPORT_API_CIPHER ++#endif ++ ++#if defined(HKS_SUPPORT_X25519_AGREE_KEY) || defined(HKS_SUPPORT_ECDH_C) ++#define HKS_SUPPORT_API_AGREE_KEY ++#endif ++ ++#ifdef HKS_SUPPORT_KDF_C ++#define HKS_SUPPORT_API_DERIVE_KEY ++#endif ++ ++#ifdef HKS_SUPPORT_HMAC_C ++#define HKS_SUPPORT_API_MAC ++#endif ++ ++#ifdef HKS_SUPPORT_HASH_C ++#define HKS_SUPPORT_API_HASH ++#endif ++ ++#ifdef HKS_SUPPORT_BN_C ++#define HKS_SUPPORT_API_BN_EXP_MOD ++#endif ++ ++#ifndef HKS_SUPPORT_LITE_HEAP ++#define HKS_SUPPORT_API_GET_KEY_INFO_LIST ++#endif ++ ++#endif /* HKS_CONFIG_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_crypto_adapter.h b/huks/frameworks/huks_standard/main/common/include/hks_crypto_adapter.h +new file mode 100644 +index 0000000..a4d6a9c +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_crypto_adapter.h +@@ -0,0 +1,58 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CRYPTO_ADAPTER_H ++#define HKS_CRYPTO_ADAPTER_H ++ ++#include ++#include ++ ++#include "hks_crypto_hal.h" ++#include "hks_type.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++void HksFillKeySpec(const struct HksParamSet *paramSet, struct HksKeySpec *spec); ++ ++void HksFillUsageSpec(const struct HksParamSet *paramSet, struct HksUsageSpec *usageSpec); ++ ++void HksFreeUsageSpec(struct HksUsageSpec **usageSpec); ++ ++void HksFillKeyDerivationParam(const struct HksParamSet *paramSet, struct HksKeyDerivationParam *param); ++ ++int32_t HksFillAeadParam(const struct HksParamSet *paramSet, struct HksBlob *inputText, struct HksUsageSpec *usageSpec, ++ bool isEncrypt); ++ ++int32_t HksFillIvParam(const struct HksParamSet *paramSet, struct HksUsageSpec *usageSpec); ++ ++int32_t HksBuildCipherUsageSpec(const struct HksParamSet *paramSet, bool isEncrypt, struct HksBlob *inputText, ++ struct HksUsageSpec **outUsageSpec); ++ ++int32_t HksGetEncryptAeTag(const struct HksParamSet *paramSet, const struct HksBlob *inData, struct HksBlob *outData, ++ struct HksBlob *tagAead); ++ ++int32_t HksSetKeyToMaterial(uint32_t alg, bool isPubKey, const struct HksBlob *key, struct HksBlob *keyMaterial); ++ ++int32_t HksGetKeyFromMaterial(uint32_t alg, bool isPubKey, const struct HksBlob *keyMaterial, struct HksBlob *key); ++ ++int32_t HksFormatKeyFromMaterial(uint32_t alg, const struct HksBlob *keyMaterial, struct HksParamSet *paramSetOut); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +\ No newline at end of file +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_crypto_hal.h b/huks/frameworks/huks_standard/main/common/include/hks_crypto_hal.h +new file mode 100644 +index 0000000..1543691 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_crypto_hal.h +@@ -0,0 +1,255 @@ ++/* ++ * Copyright (c) 2021-2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CRYPTO_HAL_H ++#define HKS_CRYPTO_HAL_H ++ ++#include "hks_type.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++enum HksKeyAlgMode { ++ HKS_ALGORITHM_RSA_MODE_CRT = 1, ++ HKS_ALGORITHM_RSA_MODE_NO_CRT = 2, ++ HKS_ALGORITHM_EC_MODE_ECDH = 3, ++ HKS_ALGORITHM_ED_MODE_SIG_VERIFY = 4, ++ HKS_ALGORITHM_ED_MODE_VERIFY = 5, ++ HKS_ALGORITHM_X25519_MODE = 6, ++}; ++ ++struct HksKeySpec { ++ uint32_t algType; ++ uint32_t keyLen; ++ void *algParam; /* for example : struct HksKeyDerivationParam */ ++}; ++ ++struct HksKeyDerivationParam { ++ struct HksBlob salt; ++ struct HksBlob info; ++ uint32_t iterations; ++ uint32_t digestAlg; ++}; ++ ++struct HksAeadParam { ++ struct HksBlob nonce; ++ struct HksBlob aad; ++ union { ++ struct HksBlob tagDec; ++ uint32_t tagLenEnc; ++ }; ++ uint32_t payloadLen; ++}; ++ ++struct HksCipherParam { ++ struct HksBlob iv; ++}; ++ ++struct HksUsageSpec { ++ uint32_t algType; ++ uint32_t mode; ++ uint32_t padding; ++ uint32_t digest; ++ uint32_t purpose; ++ /* ++ * Different algorithms correspond to different structures,for example: ++ * struct HksAeadParam for aead; ++ * struct HksCipherParam for cipher; ++ */ ++ void *algParam; ++}; ++ ++struct KeyMaterialRsa { ++ enum HksKeyAlg keyAlg; ++ uint32_t keySize; ++ uint32_t nSize; ++ uint32_t eSize; ++ uint32_t dSize; ++}; ++ ++struct KeyMaterialEcc { ++ enum HksKeyAlg keyAlg; ++ uint32_t keySize; ++ uint32_t xSize; ++ uint32_t ySize; ++ uint32_t zSize; ++}; ++ ++struct KeyMaterialDsa { ++ enum HksKeyAlg keyAlg; ++ uint32_t keySize; ++ uint32_t xSize; ++ uint32_t ySize; ++ uint32_t pSize; ++ uint32_t qSize; ++ uint32_t gSize; ++}; ++ ++struct KeyMaterialDh { ++ enum HksKeyAlg keyAlg; ++ uint32_t keySize; ++ uint32_t pubKeySize; ++ uint32_t priKeySize; ++ uint32_t reserved; ++}; ++ ++struct KeyMaterial25519 { ++ enum HksKeyAlg keyAlg; ++ uint32_t keySize; ++ uint32_t pubKeySize; ++ uint32_t priKeySize; ++ uint32_t reserved; ++}; ++ ++typedef int32_t (*GetMainKey)(const struct HksBlob *, struct HksBlob *); ++ ++typedef int32_t (*GenerateKey)(const struct HksKeySpec *, struct HksBlob *); ++ ++typedef int32_t (*PubKey)(const struct HksBlob *, struct HksBlob *); ++ ++typedef int32_t (*DeriveKey)(const struct HksBlob *, const struct HksKeySpec *, struct HksBlob *); ++ ++typedef int32_t (*FillRandom)(struct HksBlob *); ++ ++typedef int32_t (*AgreeKey)(const struct HksBlob *, const struct HksBlob *, const struct HksKeySpec *, ++ struct HksBlob *); ++ ++typedef int32_t (*Sign)(const struct HksBlob *, const struct HksUsageSpec *, const struct HksBlob *, ++ struct HksBlob *); ++ ++typedef int32_t (*Verify)(const struct HksBlob *, const struct HksUsageSpec *, const struct HksBlob *, ++ const struct HksBlob *); ++ ++typedef int32_t (*Hmac)(const struct HksBlob *, uint32_t, const struct HksBlob *, struct HksBlob *); ++ ++typedef int32_t (*HmacInit)(void **, const struct HksBlob *, uint32_t); ++ ++typedef int32_t (*HmacUpdate)(void *, const struct HksBlob *); ++ ++typedef int32_t (*HmacFinal)(void **, const struct HksBlob *, struct HksBlob *); ++ ++typedef int32_t (*Hash)(uint32_t, const struct HksBlob *, struct HksBlob *); ++ ++typedef int32_t (*HashInit)(void **, uint32_t); ++ ++typedef int32_t (*HashUpdate)(void *, const struct HksBlob *); ++ ++typedef int32_t (*HashFinal)(void **, const struct HksBlob *, struct HksBlob *); ++ ++typedef int32_t (*Encrypt)(const struct HksBlob *, const struct HksUsageSpec *, ++ const struct HksBlob *, struct HksBlob *, struct HksBlob *); ++ ++typedef int32_t (*EncryptInit)(void **, const struct HksBlob *, const struct HksUsageSpec *, const bool); ++ ++typedef int32_t (*EncryptUpdate)(void *, const struct HksBlob *, struct HksBlob *, const bool); ++ ++typedef int32_t (*EncryptFinal)(void **, const struct HksBlob *, struct HksBlob *, struct HksBlob *, const bool); ++ ++typedef int32_t (*Decrypt)(const struct HksBlob *, const struct HksUsageSpec *, ++ const struct HksBlob *, struct HksBlob *); ++ ++typedef int32_t (*DecryptInit)(void **, const struct HksBlob *, const struct HksUsageSpec *, const bool); ++ ++typedef int32_t (*DecryptUpdate)(void *, const struct HksBlob *, struct HksBlob *, const bool); ++ ++typedef int32_t (*DecryptFinal)(void **, const struct HksBlob *, struct HksBlob *, struct HksBlob *, const bool); ++ ++typedef int32_t (*BnExpMod)(struct HksBlob *, const struct HksBlob *, ++ const struct HksBlob *, const struct HksBlob *); ++ ++typedef void (*FreeCtx)(void **); ++ ++int32_t HksCryptoHalGetMainKey(const struct HksBlob *message, struct HksBlob *mainKey); ++ ++int32_t HksCryptoHalGenerateKey(const struct HksKeySpec *spec, struct HksBlob *key); ++ ++int32_t HksCryptoHalGetPubKey(const struct HksBlob *keyIn, struct HksBlob *keyOut); ++ ++int32_t HksCryptoHalDeriveKey(const struct HksBlob *mainKey, const struct HksKeySpec *derivationSpec, ++ struct HksBlob *derivedKey); ++ ++int32_t HksCryptoHalFillRandom(struct HksBlob *randomData); ++ ++int32_t HksCryptoHalFillPrivRandom(struct HksBlob *randomData); ++ ++int32_t HksCryptoHalAddEntropy(const struct HksBlob *entropy); ++ ++int32_t HksCryptoHalAgreeKey(const struct HksBlob *nativeKey, const struct HksBlob *pubKey, ++ const struct HksKeySpec *spec, struct HksBlob *sharedKey); ++ ++int32_t HksCryptoHalSign(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, ++ const struct HksBlob *message, struct HksBlob *signature); ++ ++int32_t HksCryptoHalVerify(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, ++ const struct HksBlob *message, const struct HksBlob *signature); ++ ++int32_t HksCryptoHalHmacInit(const struct HksBlob *key, uint32_t digestAlg, void **ctx); ++ ++int32_t HksCryptoHalHmacUpdate(const struct HksBlob *chunk, void *ctx); ++ ++int32_t HksCryptoHalHmacFinal(const struct HksBlob *msg, void **ctx, struct HksBlob *mac); ++ ++void HksCryptoHalHmacFreeCtx(void **ctx); ++ ++int32_t HksCryptoHalHmac(const struct HksBlob *key, uint32_t digestAlg, const struct HksBlob *msg, ++ struct HksBlob *mac); ++ ++int32_t HksCryptoHalHashInit(uint32_t alg, void **ctx); ++ ++int32_t HksCryptoHalHashUpdate(const struct HksBlob *msg, void *ctx); ++ ++int32_t HksCryptoHalHashFinal(const struct HksBlob *msg, void **ctx, struct HksBlob *hash); ++ ++void HksCryptoHalHashFreeCtx(void **ctx); ++ ++int32_t HksCryptoHalHash(uint32_t alg, const struct HksBlob *msg, struct HksBlob *hash); ++ ++int32_t HksCryptoHalEncryptInit(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, void **ctx); ++ ++int32_t HksCryptoHalEncryptUpdate(const struct HksBlob *message, void *ctx, struct HksBlob *out, ++ const uint32_t algtype); ++ ++int32_t HksCryptoHalEncryptFinal(const struct HksBlob *message, void **ctx, struct HksBlob *cipherText, ++ struct HksBlob *tagAead, const uint32_t algtype); ++ ++void HksCryptoHalEncryptFreeCtx(void **ctx, const uint32_t algtype); ++ ++int32_t HksCryptoHalEncrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, ++ const struct HksBlob *message, struct HksBlob *cipherText, struct HksBlob *tagAead); ++ ++int32_t HksCryptoHalDecryptInit(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, void **ctx); ++ ++int32_t HksCryptoHalDecryptUpdate(const struct HksBlob *message, void *ctx, struct HksBlob *out, ++ const uint32_t algtype); ++ ++int32_t HksCryptoHalDecryptFinal(const struct HksBlob *message, void **ctx, struct HksBlob *cipherText, ++ struct HksBlob *tagAead, const uint32_t algtype); ++ ++void HksCryptoHalDecryptFreeCtx(void **ctx, const uint32_t algtype); ++ ++int32_t HksCryptoHalDecrypt(const struct HksBlob *key, const struct HksUsageSpec *usageSpec, ++ const struct HksBlob *message, struct HksBlob *cipherText); ++ ++int32_t HksCryptoHalBnExpMod(struct HksBlob *x, const struct HksBlob *a, ++ const struct HksBlob *e, const struct HksBlob *n); ++ ++int32_t HksCryptoHalInit(void); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_CRYPTO_HAL_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_errcode_adapter.h b/huks/frameworks/huks_standard/main/common/include/hks_errcode_adapter.h +new file mode 100644 +index 0000000..c3f025f +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_errcode_adapter.h +@@ -0,0 +1,51 @@ ++/* ++ * Copyright (c) 2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++#ifndef HKS_ERRCODE_ADAPTER_H ++#define HKS_ERRCODE_ADAPTER_H ++ ++#ifdef __cplusplus ++#include ++#include ++#include ++#else ++#include ++#include ++#include ++#endif ++ ++#include "hks_type.h" ++ ++struct HksResult { ++ int32_t errorCode; ++ const char *errorMsg; ++ uint8_t *data; ++}; ++ ++struct HksError { ++ int32_t innerErrCode; ++ struct HksResult hksResult; ++}; ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++struct HksResult HksConvertErrCode(int32_t result); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_ERRCODE_ADAPTER_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_log.h b/huks/frameworks/huks_standard/main/common/include/hks_log.h +new file mode 100644 +index 0000000..5815e0c +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_log.h +@@ -0,0 +1,64 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_LOG_H ++#define HKS_LOG_H ++ ++#include "hks_type.h" ++ ++#ifdef HKS_CONFIG_FILE ++#include HKS_CONFIG_FILE ++#else ++#include "hks_config.h" ++#endif ++ ++#ifdef _HUKS_LOG_ENABLE_ ++#ifdef HKS_ENABLE_LOG_PUBLIC ++#define LOG_PUBLIC "{public}" ++#else ++#define LOG_PUBLIC ++#endif ++ ++#undef LOG_TAG ++#define LOG_TAG "HUKS" ++#undef LOG_DOMAIN ++#define LOG_DOMAIN 0xD002F00 /* Security subsystem's domain id */ ++ ++#ifdef HKS_LOG_ENGINE_LOG_CORE ++#include "hilog/log.h" ++#define LOG_ENGINE LOG_CORE ++#else ++#ifdef HKS_LOG_ENGINE_HILOG_MODULE_SCY ++#include "log.h" ++#define LOG_ENGINE HILOG_MODULE_SCY ++#endif ++#endif ++ ++#define HKS_LOG_I(fmt, arg...) HILOG_INFO(LOG_ENGINE, "%" LOG_PUBLIC "s[%" LOG_PUBLIC "u]: " fmt "\n", \ ++ __func__, __LINE__, ##arg) ++#define HKS_LOG_W(fmt, arg...) HILOG_WARN(LOG_ENGINE, "%" LOG_PUBLIC "s[%" LOG_PUBLIC "u]: " fmt "\n", \ ++ __func__, __LINE__, ##arg) ++#define HKS_LOG_E(fmt, arg...) HILOG_ERROR(LOG_ENGINE, "%" LOG_PUBLIC "s[%" LOG_PUBLIC "u]: " fmt "\n", \ ++ __func__, __LINE__, ##arg) ++#define HKS_LOG_D(fmt, arg...) HILOG_DEBUG(LOG_ENGINE, "%" LOG_PUBLIC "s[%" LOG_PUBLIC "u]: " fmt "\n", \ ++ __func__, __LINE__, ##arg) ++#else ++#define HKS_LOG_I(...) ++#define HKS_LOG_W(...) ++#define HKS_LOG_E(...) ++#define HKS_LOG_D(...) ++#endif ++ ++#endif /* HKS_LOG_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_mem.h b/huks/frameworks/huks_standard/main/common/include/hks_mem.h +new file mode 100644 +index 0000000..af6a0ef +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_mem.h +@@ -0,0 +1,62 @@ ++/* ++ * Copyright (c) 2021-2023 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_MEM_H ++#define HKS_MEM_H ++ ++#ifdef __cplusplus ++#include ++#include ++ ++#define HKS_NULL_POINTER nullptr ++#else ++#include ++#include ++ ++#define HKS_NULL_POINTER NULL ++#endif ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++void *HksMalloc(size_t size); ++int32_t HksMemCmp(const void *ptr1, const void *ptr2, uint32_t size); ++ ++#define SELF_FREE_PTR(PTR, FREE_FUNC) \ ++{ \ ++ if ((PTR) != HKS_NULL_POINTER) { \ ++ FREE_FUNC(PTR); \ ++ (PTR) = HKS_NULL_POINTER; \ ++ } \ ++} ++ ++#define HKS_FREE_PTR(p) SELF_FREE_PTR(p, free) ++ ++#define HksFree(p) SELF_FREE_PTR(p, free) ++ ++#define HKS_FREE_BLOB(blob) do { \ ++ if ((blob).data != HKS_NULL_POINTER) { \ ++ free((blob).data); \ ++ (blob).data = HKS_NULL_POINTER; \ ++ } \ ++ (blob).size = 0; \ ++} while (0) ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_MEM_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_template.h b/huks/frameworks/huks_standard/main/common/include/hks_template.h +new file mode 100644 +index 0000000..f9c9dcb +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_template.h +@@ -0,0 +1,75 @@ ++/* ++ * Copyright (c) 2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_TEMPLATE_H ++#define HKS_TEMPLATE_H ++ ++#undef HKS_NULL_POINTER ++ ++#ifdef __cplusplus ++#define HKS_NULL_POINTER nullptr ++#else ++#define HKS_NULL_POINTER NULL ++#endif ++ ++#define HKS_IF_NOT_SUCC_LOGE_RETURN(RESULT, ERROR_CODE, LOG_MESSAGE, ...) \ ++if ((RESULT) != HKS_SUCCESS) { \ ++ HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ ++ return (ERROR_CODE); \ ++} ++ ++#define HKS_IF_NOT_SUCC_LOGE_BREAK(RESULT, LOG_MESSAGE, ...) \ ++if ((RESULT) != HKS_SUCCESS) { \ ++ HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ ++ break; \ ++} ++ ++#define HKS_IF_NOT_SUCC_BREAK(RESULT, ...) \ ++if ((RESULT) != HKS_SUCCESS) { \ ++ break; \ ++} ++ ++#define HKS_IF_NOT_SUCC_LOGE(RESULT, LOG_MESSAGE, ...) \ ++if ((RESULT) != HKS_SUCCESS) { \ ++ HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ ++} ++ ++#define HKS_IF_NOT_SUCC_RETURN(RESULT, ERROR_CODE) \ ++if ((RESULT) != HKS_SUCCESS) { \ ++ return (ERROR_CODE); \ ++} ++ ++#define HKS_IF_NULL_LOGE_RETURN(OBJECT, ERROR_CODE, LOG_MESSAGE, ...) \ ++if ((OBJECT) == HKS_NULL_POINTER) { \ ++ HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ ++ return (ERROR_CODE); \ ++} ++ ++#define HKS_IF_NULL_LOGE_BREAK(OBJECT, LOG_MESSAGE, ...) \ ++if ((OBJECT) == HKS_NULL_POINTER) { \ ++ HKS_LOG_E(LOG_MESSAGE, ##__VA_ARGS__); \ ++ break; \ ++} ++ ++#define HKS_IF_NULL_RETURN(OBJECT, ERROR_CODE) \ ++if ((OBJECT) == HKS_NULL_POINTER) { \ ++ return (ERROR_CODE); \ ++} ++ ++#define HKS_IF_NULL_BREAK(OBJECT) \ ++if ((OBJECT) == HKS_NULL_POINTER) { \ ++ break; \ ++} ++#endif /* HKS_TEMPLATE_H */ +diff --git a/huks/frameworks/huks_standard/main/common/include/hks_type_inner.h b/huks/frameworks/huks_standard/main/common/include/hks_type_inner.h +new file mode 100644 +index 0000000..d32663d +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/common/include/hks_type_inner.h +@@ -0,0 +1,94 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_TYPE_INNER_H ++#define HKS_TYPE_INNER_H ++ ++#include "hks_type.h" ++#include "securec.h" ++ ++#define HANDLE_SIZE 8 ++#define DEFAULT_AUTH_TIMEOUT 5 ++ ++/* EnrolledIdInfo stored format: |-enrolledId len-|-enrolledId1 type-|-enrolledId1 value-|...| */ ++#define ENROLLED_ID_INFO_MIN_LEN (sizeof(uint32_t) + (sizeof(uint32_t) + sizeof(uint64_t))) ++ ++enum HksUserAuthResult { ++ HKS_AUTH_RESULT_NONE = -2, // not support user auth ++ HKS_AUTH_RESULT_INIT = -1, ++ HKS_AUTH_RESULT_SUCCESS = 0, ++ HKS_AUTH_RESULT_FAILED = 1, ++}; ++ ++enum HksStageType { ++ HKS_STAGE_THREE = 0, ++ HKS_STAGE_ONE = 1, ++}; ++ ++enum HksInnerTag { ++ HKS_TAG_APPENDED_DATA_PREFIX = HKS_TAG_TYPE_BYTES | 10020, ++ HKS_TAG_APPENDED_DATA_SUFFIX = HKS_TAG_TYPE_BYTES | 10021, ++ ++ /* Inner-use TAGS used for ipc serialization */ ++ HKS_TAG_PARAM0_BUFFER = HKS_TAG_TYPE_BYTES | 30001, ++ HKS_TAG_PARAM1_BUFFER = HKS_TAG_TYPE_BYTES | 30002, ++ HKS_TAG_PARAM2_BUFFER = HKS_TAG_TYPE_BYTES | 30003, ++ HKS_TAG_PARAM3_BUFFER = HKS_TAG_TYPE_BYTES | 30004, ++ HKS_TAG_PARAM4_BUFFER = HKS_TAG_TYPE_BYTES | 30005, ++ HKS_TAG_PARAM0_UINT32 = HKS_TAG_TYPE_UINT | 30006, ++ HKS_TAG_PARAM1_UINT32 = HKS_TAG_TYPE_UINT | 30007, ++ HKS_TAG_PARAM2_UINT32 = HKS_TAG_TYPE_UINT | 30008, ++ HKS_TAG_PARAM3_UINT32 = HKS_TAG_TYPE_UINT | 30009, ++ HKS_TAG_PARAM4_UINT32 = HKS_TAG_TYPE_UINT | 30010, ++ HKS_TAG_PARAM0_BOOL = HKS_TAG_TYPE_BOOL | 30011, ++ HKS_TAG_PARAM1_BOOL = HKS_TAG_TYPE_BOOL | 30012, ++ HKS_TAG_PARAM2_BOOL = HKS_TAG_TYPE_BOOL | 30013, ++ HKS_TAG_PARAM3_BOOL = HKS_TAG_TYPE_BOOL | 30014, ++ HKS_TAG_PARAM4_BOOL = HKS_TAG_TYPE_BOOL | 30015, ++ HKS_TAG_PARAM0_NULL = HKS_TAG_TYPE_BYTES | 30016, ++ HKS_TAG_PARAM1_NULL = HKS_TAG_TYPE_BYTES | 30017, ++ HKS_TAG_PARAM2_NULL = HKS_TAG_TYPE_BYTES | 30018, ++ HKS_TAG_PARAM3_NULL = HKS_TAG_TYPE_BYTES | 30019, ++ HKS_TAG_PARAM4_NULL = HKS_TAG_TYPE_BYTES | 30020, ++ ++ HKS_TAG_ACCESS_TOKEN_ID = HKS_TAG_TYPE_UINT | 30021, ++}; ++ ++#define HKS_PARAM_BUFFER_NULL_INTERVAL ((HKS_TAG_PARAM0_NULL) - (HKS_TAG_PARAM0_BUFFER)) ++ ++struct HksProcessInfo { ++ struct HksBlob userId; ++ struct HksBlob processName; ++ int32_t userIdInt; ++ uint64_t accessTokenId; ++}; ++ ++struct HksParamOut { ++ uint32_t tag; ++ union { ++ bool *boolParam; ++ int32_t *int32Param; ++ uint32_t *uint32Param; ++ uint64_t *uint64Param; ++ struct HksBlob *blob; ++ }; ++}; ++ ++struct HksKeyMaterialHeader { ++ enum HksKeyAlg keyAlg; ++ uint32_t keySize; ++}; ++ ++#endif /* HKS_TYPE_INNER_H */ +diff --git a/huks/frameworks/huks_standard/main/os_dependency/BUILD.gn b/huks/frameworks/huks_standard/main/os_dependency/BUILD.gn +new file mode 100644 +index 0000000..3cc5c64 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/os_dependency/BUILD.gn +@@ -0,0 +1,10 @@ ++import("//build/ohos.gni") ++ ++config("huks_config") { ++ include_dirs = ["//base/security/huks/frameworks/huks_standard/main/os_dependency/ipc/include"] ++ libs = ["huks_os_dependency_standard_static"] ++} ++ ++group("libhuks_os_dependency_standard_static") { ++ public_configs = [":huks_config"] ++} +diff --git a/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_client_ipc.h b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_client_ipc.h +new file mode 100644 +index 0000000..206dfd4 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_client_ipc.h +@@ -0,0 +1,90 @@ ++/* ++ * Copyright (c) 2021-2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CLIENT_IPC_H ++#define HKS_CLIENT_IPC_H ++ ++#include "hks_type_inner.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++int32_t HksClientInitialize(void); ++ ++int32_t HksClientRefreshKeyInfo(void); ++ ++int32_t HksClientGenerateKey(const struct HksBlob *keyAlias, const struct HksParamSet *paramSetIn, ++ struct HksParamSet *paramSetOut); ++ ++int32_t HksClientImportKey(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, ++ const struct HksBlob *key); ++ ++int32_t HksClientExportPublicKey(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, ++ struct HksBlob *key); ++ ++int32_t HksClientImportWrappedKey(const struct HksBlob *keyAlias, const struct HksBlob *wrappingKeyAlias, ++ const struct HksParamSet *paramSet, const struct HksBlob *wrappedKeyData); ++ ++int32_t HksClientDeleteKey(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet); ++ ++int32_t HksClientGetKeyParamSet(const struct HksBlob *keyAlias, struct HksParamSet *paramSet); ++ ++int32_t HksClientKeyExist(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet); ++ ++int32_t HksClientGenerateRandom(struct HksBlob *random, const struct HksParamSet *paramSet); ++ ++int32_t HksClientSign(const struct HksBlob *key, const struct HksParamSet *paramSet, ++ const struct HksBlob *srcData, struct HksBlob *signature); ++ ++int32_t HksClientVerify(const struct HksBlob *key, const struct HksParamSet *paramSet, ++ const struct HksBlob *srcData, const struct HksBlob *signature); ++ ++int32_t HksClientEncrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, ++ const struct HksBlob *plainText, struct HksBlob *cipherText); ++ ++int32_t HksClientDecrypt(const struct HksBlob *key, const struct HksParamSet *paramSet, ++ const struct HksBlob *cipherText, struct HksBlob *plainText); ++ ++int32_t HksClientAgreeKey(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, ++ const struct HksBlob *peerPublicKey, struct HksBlob *agreedKey); ++ ++int32_t HksClientDeriveKey(const struct HksParamSet *paramSet, const struct HksBlob *mainKey, ++ struct HksBlob *derivedKey); ++ ++int32_t HksClientMac(const struct HksBlob *key, const struct HksParamSet *paramSet, const struct HksBlob *srcData, ++ struct HksBlob *mac); ++ ++int32_t HksClientGetKeyInfoList(struct HksKeyInfo *keyInfoList, uint32_t *listCount); ++ ++int32_t HksClientAttestKey(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, ++ struct HksCertChain *certChain); ++ ++int32_t HksClientInit(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, struct HksBlob *handle, ++ struct HksBlob *token); ++ ++int32_t HksClientUpdate(const struct HksBlob *handle, const struct HksParamSet *paramSet, const struct HksBlob *inData, ++ struct HksBlob *outData); ++ ++int32_t HksClientFinish(const struct HksBlob *handle, const struct HksParamSet *paramSet, const struct HksBlob *inData, ++ struct HksBlob *outData); ++ ++int32_t HksClientAbort(const struct HksBlob *handle, const struct HksParamSet *paramSet); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_CLIENT_IPC_H */ +diff --git a/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_check.h b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_check.h +new file mode 100644 +index 0000000..761247c +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_check.h +@@ -0,0 +1,55 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_CRYPTO_CHECK_H ++#define HKS_CRYPTO_CHECK_H ++ ++#include ++#include ++ ++#include "hks_type.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++int32_t HksCheckIpcGenerateKey(const struct HksBlob *keyAlias, const struct HksParamSet *paramSetIn); ++ ++int32_t HksCheckIpcImportKey(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, ++ const struct HksBlob *key); ++ ++int32_t HksCheckIpcImportWrappedKey(const struct HksBlob *keyAlias, const struct HksBlob *wrappingKeyAlias, ++ const struct HksParamSet *paramSet, const struct HksBlob *wrappedKeyData); ++ ++int32_t HksCheckIpcExportPublicKey(const struct HksBlob *keyAlias, const struct HksBlob *key); ++ ++int32_t HksCheckIpcGetKeyParamSet(const struct HksBlob *keyAlias, struct HksParamSet *paramSet); ++ ++int32_t HksCheckIpcAgreeKey(const struct HksParamSet *paramSet, const struct HksBlob *privateKey, ++ const struct HksBlob *peerPublicKey, const struct HksBlob *agreedKey); ++ ++int32_t HksCheckIpcDeriveKey(const struct HksParamSet *paramSet, const struct HksBlob *mainKey, ++ const struct HksBlob *derivedKey); ++ ++int32_t HksCheckIpcGetKeyInfoList(const struct HksKeyInfo *keyInfoList, uint32_t listCount); ++ ++int32_t HksCheckIpcCertificateChain(const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, ++ const struct HksCertChain *certChain); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +\ No newline at end of file +diff --git a/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_serialization.h b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_serialization.h +new file mode 100644 +index 0000000..59cf16e +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_serialization.h +@@ -0,0 +1,76 @@ ++/* ++ * Copyright (c) 2021-2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_IPC_SERIALIZATION_H ++#define HKS_IPC_SERIALIZATION_H ++ ++#include ++#include ++ ++#include "hks_type_inner.h" ++ ++#define MAX_IPC_BUF_SIZE 0x10000 /* Maximun IPC message buffer size. */ ++#define MAX_IPC_RSV_SIZE 0x400 /* Reserve IPC message buffer size */ ++#define MAX_PROCESS_SIZE (MAX_IPC_BUF_SIZE - MAX_IPC_RSV_SIZE) ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++int32_t CopyUint32ToBuffer(uint32_t value, const struct HksBlob *destBlob, uint32_t *destOffset); ++ ++int32_t HksGenerateKeyPack(struct HksBlob *destData, const struct HksBlob *keyAlias, ++ const struct HksParamSet *paramSetIn, const struct HksBlob *keyOut); ++ ++int32_t HksImportKeyPack(struct HksBlob *destData, const struct HksBlob *keyAlias, const struct HksParamSet *paramSet, ++ const struct HksBlob *key); ++ ++int32_t HksImportWrappedKeyPack(struct HksBlob *destData, const struct HksBlob *keyAlias, ++ const struct HksBlob *wrappingKeyAlias, const struct HksParamSet *paramSet, const struct HksBlob *wrappedKeyData); ++ ++int32_t HksExportPublicKeyPack(struct HksBlob *destData, const struct HksBlob *keyAlias, const struct HksBlob *key); ++ ++int32_t HksGetKeyParamSetPack(struct HksBlob *destData, const struct HksBlob *keyAlias, const struct HksBlob *keyOut); ++ ++int32_t HksOnceParamPack(struct HksBlob *destData, const struct HksBlob *key, const struct HksParamSet *paramSet, ++ uint32_t *offset); ++ ++int32_t HksOnceDataPack(struct HksBlob *destData, const struct HksBlob *inputData, const struct HksBlob *rsvData, ++ const struct HksBlob *outputData, uint32_t *offset); ++ ++int32_t HksAgreeKeyPack(struct HksBlob *destData, const struct HksParamSet *paramSet, const struct HksBlob *privateKey, ++ const struct HksBlob *peerPublicKey, const struct HksBlob *agreedKey); ++ ++int32_t HksDeriveKeyPack(struct HksBlob *destData, const struct HksParamSet *paramSet, const struct HksBlob *kdfKey, ++ const struct HksBlob *derivedKey); ++ ++int32_t HksGetKeyInfoListPack(struct HksBlob *destData, uint32_t listCount, const struct HksKeyInfo *keyInfoList); ++ ++int32_t HksGetKeyInfoListUnpackFromService(const struct HksBlob *srcData, uint32_t *listCount, ++ struct HksKeyInfo *keyInfoList); ++ ++int32_t HksCertificateChainPack(struct HksBlob *destData, const struct HksBlob *keyAlias, ++ const struct HksParamSet *paramSet, const struct HksBlob *certChainBlob); ++ ++int32_t HksCertificateChainUnpackFromService(const struct HksBlob *srcData, bool needEncode, ++ struct HksCertChain *certChain); ++ ++int32_t HksParamsToParamSet(struct HksParam *params, uint32_t cnt, struct HksParamSet **outParamSet); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_IPC_SERIALIZATION_H */ +\ No newline at end of file +diff --git a/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_slice.h b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_slice.h +new file mode 100644 +index 0000000..a712cc1 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_ipc_slice.h +@@ -0,0 +1,34 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_IPC_SLICE_H ++#define HKS_IPC_SLICE_H ++ ++#include ++ ++#include "hks_type.h" ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++int32_t HksSliceDataEntry(uint32_t cmdId, const struct HksBlob *key, const struct HksParamSet *paramSet, ++ struct HksBlob *inData, struct HksBlob *outData); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_SLICE_H */ +\ No newline at end of file +diff --git a/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_request.h b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_request.h +new file mode 100644 +index 0000000..332fb99 +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_request.h +@@ -0,0 +1,69 @@ ++/* ++ * Copyright (c) 2021-2022 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_REQUEST_H ++#define HKS_REQUEST_H ++ ++#include "hks_type_inner.h" ++ ++enum HksMessage { ++#ifndef _HKS_L1_TEE_ ++ HKS_MSG_BASE = 0x3a400, /* range of message value defined by router. globally unique */ ++#else ++ HKS_MSG_BASE = 1000, /* range of message value defined by SmartLock. Max 65535 */ ++#endif ++ HKS_MSG_GEN_KEY = HKS_MSG_BASE, ++ HKS_MSG_IMPORT_KEY, ++ HKS_MSG_EXPORT_PUBLIC_KEY, ++ HKS_MSG_IMPORT_WRAPPED_KEY, ++ HKS_MSG_DELETE_KEY, ++ HKS_MSG_GET_KEY_PARAMSET, ++ HKS_MSG_KEY_EXIST, ++ HKS_MSG_GENERATE_RANDOM, ++ HKS_MSG_SIGN, ++ HKS_MSG_VERIFY, ++ HKS_MSG_ENCRYPT, ++ HKS_MSG_DECRYPT, ++ HKS_MSG_AGREE_KEY, ++ HKS_MSG_DERIVE_KEY, ++ HKS_MSG_MAC, ++ HKS_MSG_GET_KEY_INFO_LIST, ++ HKS_MSG_ATTEST_KEY, ++ HKS_MSG_GET_CERTIFICATE_CHAIN, ++ HKS_MSG_INIT, ++ HKS_MSG_UPDATE, ++ HKS_MSG_FINISH, ++ HKS_MSG_ABORT, ++ HKS_MSG_MAX, /* new cmd type must be added before HKS_MSG_MAX */ ++}; ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++/* ++ * SendRequest - Send the request message to target module by function call or ipc or other ways. ++ * @type: the request message type. ++ * @inBlob: the input serialized data blob. ++ * @outBlob: the output serialized data blob, can be null. ++ */ ++int32_t HksSendRequest(enum HksMessage type, const struct HksBlob *inBlob, struct HksBlob *outBlob, ++ const struct HksParamSet *paramSet); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif /* HKS_REQUEST_H */ +diff --git a/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_samgr_client.h b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_samgr_client.h +new file mode 100644 +index 0000000..b20f73b +--- /dev/null ++++ b/huks/frameworks/huks_standard/main/os_dependency/ipc/include/hks_samgr_client.h +@@ -0,0 +1,32 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef HKS_SAMGR_CLIENT_H ++#define HKS_SAMGR_CLIENT_H ++ ++#include "hks_samgr_server.h" ++#include "iproxy_client.h" ++ ++typedef struct { ++ INHERIT_CLIENT_IPROXY; ++ int32_t (*IpcAsyncCallBack)(IUnknown *iUnknown, enum HksMessageType type, const struct HksBlob *inBlob, ++ struct HksBlob *outBlob); ++} HksMgrClientApi; ++ ++typedef struct { ++ INHERIT_IUNKNOWNENTRY(HksMgrClientApi); ++} HksMgrClientEntry; ++ ++#endif +\ No newline at end of file +diff --git a/huks/interfaces/innerkits/huks_standard/main/BUILD.gn b/huks/interfaces/innerkits/huks_standard/main/BUILD.gn +new file mode 100644 +index 0000000..a539688 +--- /dev/null ++++ b/huks/interfaces/innerkits/huks_standard/main/BUILD.gn +@@ -0,0 +1,23 @@ ++# Copyright (C) 2021-2022 Huawei Device Co., Ltd. ++# Licensed under the Apache License, Version 2.0 (the "License"); ++# you may not use this file except in compliance with the License. ++# You may obtain a copy of the License at ++# ++# http://www.apache.org/licenses/LICENSE-2.0 ++# ++# Unless required by applicable law or agreed to in writing, software ++# distributed under the License is distributed on an "AS IS" BASIS, ++# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++# See the License for the specific language governing permissions and ++# limitations under the License. ++ ++import("//build/ohos.gni") ++ ++config("huks_config") { ++ include_dirs = [ "//base/security/huks/interfaces/innerkits/huks_standard/main/include" ] ++ libs = [ "hukssdk.z" ] ++} ++ ++group("libhukssdk") { ++ public_configs = [ ":huks_config" ] ++} +diff --git a/huks/interfaces/innerkits/huks_standard/main/include b/huks/interfaces/innerkits/huks_standard/main/include +new file mode 120000 +index 0000000..98a2378 +--- /dev/null ++++ b/huks/interfaces/innerkits/huks_standard/main/include +@@ -0,0 +1 @@ ++/usr/include/huks +\ No newline at end of file +-- +2.27.0 + From 80e62dada26bdd54c9978996e9f297bcc4a80fd7 Mon Sep 17 00:00:00 2001 From: heppen Date: Mon, 28 Aug 2023 16:37:35 +0800 Subject: [PATCH 3/5] add third party component --- 0003-add-third-part-component.patch | 13334 ++++++++++++++++++++++++++ 1 file changed, 13334 insertions(+) create mode 100644 0003-add-third-part-component.patch diff --git a/0003-add-third-part-component.patch b/0003-add-third-part-component.patch new file mode 100644 index 0000000..6e0fec8 --- /dev/null +++ b/0003-add-third-part-component.patch @@ -0,0 +1,13334 @@ +From 7ad0f78ee368cd1d330c685cbe30f154d91e9146 Mon Sep 17 00:00:00 2001 +From: wang--ge +Date: Tue, 18 Jul 2023 15:12:58 +0800 +Subject: [PATCH] add third part component + +--- + icu/icu4c/BUILD.gn | 19 + + sqlite/BUILD.gn | 13 + + sqlite/include/sqlite3.h | 12530 ++++++++++++++++++++++++++++++++++ + sqlite/include/sqlite3ext.h | 679 ++ + sqlite/include/sqlite3sym.h | 42 + + 5 files changed, 13283 insertions(+) + create mode 100644 icu/icu4c/BUILD.gn + create mode 100644 sqlite/BUILD.gn + create mode 100644 sqlite/include/sqlite3.h + create mode 100644 sqlite/include/sqlite3ext.h + create mode 100644 sqlite/include/sqlite3sym.h + +diff --git a/icu/icu4c/BUILD.gn b/icu/icu4c/BUILD.gn +new file mode 100644 +index 0000000..ac57abf +--- /dev/null ++++ b/icu/icu4c/BUILD.gn +@@ -0,0 +1,19 @@ ++import("//build/ohos.gni") ++ ++config("icuuc_config"){ ++ include_dirs = [ "/usr/include/unicode" ] ++ libs = [ "icuuc" ] ++} ++ ++group("shared_icuuc") { ++ public_configs = [ ":icuuc_config" ] ++} ++ ++config("icui18n_config"){ ++ include_dirs = [ "/usr/include/unicode" ] ++ libs = [ "icui18n" ] ++} ++ ++ohos_shared_library("shared_icui18n") { ++ public_configs = [ ":icui18n_config" ] ++} +diff --git a/sqlite/BUILD.gn b/sqlite/BUILD.gn +new file mode 100644 +index 0000000..3560b86 +--- /dev/null ++++ b/sqlite/BUILD.gn +@@ -0,0 +1,13 @@ ++import("//build/ohos.gni") ++ ++config("sqlite_config") { ++ include_dirs = [ ++ "include", ++ "//commonlibrary/c_utils/base/include", ++ ] ++ libs = ["sqlite.z"] ++} ++ ++group("sqlite") { ++ public_configs = [":sqlite_config"] ++} +diff --git a/sqlite/include/sqlite3.h b/sqlite/include/sqlite3.h +new file mode 100644 +index 0000000..a6afc6e +--- /dev/null ++++ b/sqlite/include/sqlite3.h +@@ -0,0 +1,12530 @@ ++/* ++** 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 header file defines the interface that the SQLite library ++** presents to client programs. If a C-function, structure, datatype, ++** or constant definition does not appear in this file, then it is ++** not a published API of SQLite, is subject to change without ++** notice, and should not be referenced by programs that use SQLite. ++** ++** Some of the definitions that are in this file are marked as ++** "experimental". Experimental interfaces are normally new ++** features recently added to SQLite. We do not anticipate changes ++** to experimental interfaces but reserve the right to make minor changes ++** if experience from use "in the wild" suggest such changes are prudent. ++** ++** The official C-language API documentation for SQLite is derived ++** from comments in this file. This file is the authoritative source ++** on how SQLite interfaces are supposed to operate. ++** ++** The name of this file under configuration management is "sqlite.h.in". ++** The makefile makes some minor changes to this file (such as inserting ++** the version number) and changes its name to "sqlite3.h" as ++** part of the build process. ++*/ ++#ifndef SQLITE3_H ++#define SQLITE3_H ++#include /* Needed for the definition of va_list */ ++ ++/* ++** Make sure we can call this stuff from C++. ++*/ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++ ++/* ++** Facilitate override of interface linkage and calling conventions. ++** Be aware that these macros may not be used within this particular ++** translation of the amalgamation and its associated header file. ++** ++** The SQLITE_EXTERN and SQLITE_API macros are used to instruct the ++** compiler that the target identifier should have external linkage. ++** ++** The SQLITE_CDECL macro is used to set the calling convention for ++** public functions that accept a variable number of arguments. ++** ++** The SQLITE_APICALL macro is used to set the calling convention for ++** public functions that accept a fixed number of arguments. ++** ++** The SQLITE_STDCALL macro is no longer used and is now deprecated. ++** ++** The SQLITE_CALLBACK macro is used to set the calling convention for ++** function pointers. ++** ++** The SQLITE_SYSAPI macro is used to set the calling convention for ++** functions provided by the operating system. ++** ++** Currently, the SQLITE_CDECL, SQLITE_APICALL, SQLITE_CALLBACK, and ++** SQLITE_SYSAPI macros are used only when building for environments ++** that require non-default calling conventions. ++*/ ++#ifndef SQLITE_EXTERN ++# define SQLITE_EXTERN extern ++#endif ++#ifndef SQLITE_API ++# define SQLITE_API ++#endif ++#ifndef SQLITE_CDECL ++# define SQLITE_CDECL ++#endif ++#ifndef SQLITE_APICALL ++# define SQLITE_APICALL ++#endif ++#ifndef SQLITE_STDCALL ++# define SQLITE_STDCALL SQLITE_APICALL ++#endif ++#ifndef SQLITE_CALLBACK ++# define SQLITE_CALLBACK ++#endif ++#ifndef SQLITE_SYSAPI ++# define SQLITE_SYSAPI ++#endif ++ ++/* ++** These no-op macros are used in front of interfaces to mark those ++** interfaces as either deprecated or experimental. New applications ++** should not use deprecated interfaces - they are supported for backwards ++** compatibility only. Application writers should be aware that ++** experimental interfaces are subject to change in point releases. ++** ++** These macros used to resolve to various kinds of compiler magic that ++** would generate warning messages when they were used. But that ++** compiler magic ended up generating such a flurry of bug reports ++** that we have taken it all out and gone back to using simple ++** noop macros. ++*/ ++#define SQLITE_DEPRECATED ++#define SQLITE_EXPERIMENTAL ++ ++/* ++** Ensure these symbols were not defined by some previous header file. ++*/ ++#ifdef SQLITE_VERSION ++# undef SQLITE_VERSION ++#endif ++#ifdef SQLITE_VERSION_NUMBER ++# undef SQLITE_VERSION_NUMBER ++#endif ++ ++/* ++** CAPI3REF: Compile-Time Library Version Numbers ++** ++** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header ++** evaluates to a string literal that is the SQLite version in the ++** format "X.Y.Z" where X is the major version number (always 3 for ++** SQLite3) and Y is the minor version number and Z is the release number.)^ ++** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer ++** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same ++** numbers used in [SQLITE_VERSION].)^ ++** The SQLITE_VERSION_NUMBER for any given release of SQLite will also ++** be larger than the release from which it is derived. Either Y will ++** be held constant and Z will be incremented or else Y will be incremented ++** and Z will be reset to zero. ++** ++** Since [version 3.6.18] ([dateof:3.6.18]), ++** SQLite source code has been stored in the ++** Fossil configuration management ++** system. ^The SQLITE_SOURCE_ID macro evaluates to ++** a string which identifies a particular check-in of SQLite ++** within its configuration management system. ^The SQLITE_SOURCE_ID ++** string contains the date and time of the check-in (UTC) and a SHA1 ++** or SHA3-256 hash of the entire source tree. If the source code has ++** been edited in any way since it was last checked in, then the last ++** four hexadecimal digits of the hash may be modified. ++** ++** See also: [sqlite3_libversion()], ++** [sqlite3_libversion_number()], [sqlite3_sourceid()], ++** [sqlite_version()] and [sqlite_source_id()]. ++*/ ++#define SQLITE_VERSION "3.37.2" ++#define SQLITE_VERSION_NUMBER 3037002 ++#define SQLITE_SOURCE_ID "2022-01-06 13:25:41 872ba256cbf61d9290b571c0e6d82a20c224ca3ad82971edc46b29818d5d17a0" ++ ++/* ++** CAPI3REF: Run-Time Library Version Numbers ++** KEYWORDS: sqlite3_version sqlite3_sourceid ++** ++** These interfaces provide the same information as the [SQLITE_VERSION], ++** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros ++** but are associated with the library instead of the header file. ^(Cautious ++** programmers might include assert() statements in their application to ++** verify that values returned by these interfaces match the macros in ++** the header, and thus ensure that the application is ++** compiled with matching library and header files. ++** ++** 
++** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
++** assert( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,80)==0 );
++** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
++**
)^ ++** ++** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION] ++** macro. ^The sqlite3_libversion() function returns a pointer to the ++** to the sqlite3_version[] string constant. The sqlite3_libversion() ++** function is provided for use in DLLs since DLL users usually do not have ++** direct access to string constants within the DLL. ^The ++** sqlite3_libversion_number() function returns an integer equal to ++** [SQLITE_VERSION_NUMBER]. ^(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].)^ ++** ++** See also: [sqlite_version()] and [sqlite_source_id()]. ++*/ ++SQLITE_API SQLITE_EXTERN const char sqlite3_version[]; ++SQLITE_API const char *sqlite3_libversion(void); ++SQLITE_API const char *sqlite3_sourceid(void); ++SQLITE_API int sqlite3_libversion_number(void); ++ ++/* ++** CAPI3REF: Run-Time Library Compilation Options Diagnostics ++** ++** ^The sqlite3_compileoption_used() function returns 0 or 1 ++** indicating whether the specified option was defined at ++** compile time. ^The SQLITE_ prefix may be omitted from the ++** option name passed to sqlite3_compileoption_used(). ++** ++** ^The sqlite3_compileoption_get() function allows iterating ++** over the list of options that were defined at compile time by ++** returning the N-th compile time option string. ^If N is out of range, ++** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_ ++** prefix is omitted from any strings returned by ++** sqlite3_compileoption_get(). ++** ++** ^Support for the diagnostic functions sqlite3_compileoption_used() ++** and sqlite3_compileoption_get() may be omitted by specifying the ++** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time. ++** ++** See also: SQL functions [sqlite_compileoption_used()] and ++** [sqlite_compileoption_get()] and the [compile_options pragma]. ++*/ ++#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS ++SQLITE_API int sqlite3_compileoption_used(const char *zOptName); ++SQLITE_API const char *sqlite3_compileoption_get(int N); ++#else ++# define sqlite3_compileoption_used(X) 0 ++# define sqlite3_compileoption_get(X) ((void*)0) ++#endif ++ ++/* ++** CAPI3REF: Test To See If The Library Is Threadsafe ++** ++** ^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 can be compiled with or without mutexes. When ++** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes ++** are enabled and SQLite is threadsafe. When the ++** [SQLITE_THREADSAFE] macro is 0, ++** the mutexes are omitted. Without the mutexes, it is not safe ++** to use SQLite concurrently from more than one thread. ++** ++** Enabling mutexes incurs a measurable performance penalty. ++** So if speed is of utmost importance, it makes sense to disable ++** the mutexes. But for maximum safety, mutexes should be enabled. ++** ^The default behavior is for mutexes to be enabled. ++** ++** This interface can be used by an application to make sure that the ++** version of SQLite that it is linking against was compiled with ++** the desired setting of the [SQLITE_THREADSAFE] macro. ++** ++** This interface only reports on the compile-time mutex setting ++** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with ++** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but ++** can be fully or partially disabled using a call to [sqlite3_config()] ++** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD], ++** or [SQLITE_CONFIG_SERIALIZED]. ^(The return value of the ++** sqlite3_threadsafe() function shows only the compile-time setting of ++** thread safety, not any run-time changes to that setting made by ++** sqlite3_config(). In other words, the return value from sqlite3_threadsafe() ++** is unchanged by calls to sqlite3_config().)^ ++** ++** See the [threading mode] documentation for additional information. ++*/ ++SQLITE_API int sqlite3_threadsafe(void); ++ ++/* ++** CAPI3REF: Database Connection Handle ++** KEYWORDS: {database connection} {database connections} ++** ++** Each open SQLite database is represented by a pointer to an instance of ++** the opaque structure named "sqlite3". It is useful to think of an sqlite3 ++** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and ++** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()] ++** and [sqlite3_close_v2()] are its destructors. There are many other ++** interfaces (such as ++** [sqlite3_prepare_v2()], [sqlite3_create_function()], and ++** [sqlite3_busy_timeout()] to name but three) that are methods on an ++** sqlite3 object. ++*/ ++typedef struct sqlite3 sqlite3; ++ ++/* ++** CAPI3REF: 64-Bit Integer Types ++** KEYWORDS: sqlite_int64 sqlite_uint64 ++** ++** Because there is no cross-platform way to specify 64-bit integer types ++** SQLite includes typedefs for 64-bit signed and unsigned integers. ++** ++** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. ++** The sqlite_int64 and sqlite_uint64 types are supported for backwards ++** compatibility only. ++** ++** ^The sqlite3_int64 and sqlite_int64 types can store integer values ++** between -9223372036854775808 and +9223372036854775807 inclusive. ^The ++** sqlite3_uint64 and sqlite_uint64 types can store integer values ++** between 0 and +18446744073709551615 inclusive. ++*/ ++#ifdef SQLITE_INT64_TYPE ++ typedef SQLITE_INT64_TYPE sqlite_int64; ++# ifdef SQLITE_UINT64_TYPE ++ typedef SQLITE_UINT64_TYPE sqlite_uint64; ++# else ++ typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; ++# endif ++#elif defined(_MSC_VER) || defined(__BORLANDC__) ++ typedef __int64 sqlite_int64; ++ typedef unsigned __int64 sqlite_uint64; ++#else ++ typedef long long int sqlite_int64; ++ typedef unsigned long long int sqlite_uint64; ++#endif ++typedef sqlite_int64 sqlite3_int64; ++typedef sqlite_uint64 sqlite3_uint64; ++ ++/* ++** If compiling for a processor that lacks floating point support, ++** substitute integer for floating-point. ++*/ ++#ifdef SQLITE_OMIT_FLOATING_POINT ++# define double sqlite3_int64 ++#endif ++ ++/* ++** CAPI3REF: Closing A Database Connection ++** DESTRUCTOR: sqlite3 ++** ++** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors ++** for the [sqlite3] object. ++** ^Calls to sqlite3_close() and sqlite3_close_v2() return [SQLITE_OK] if ++** the [sqlite3] object is successfully destroyed and all associated ++** resources are deallocated. ++** ++** Ideally, applications should [sqlite3_finalize | finalize] all ++** [prepared statements], [sqlite3_blob_close | close] all [BLOB handles], and ++** [sqlite3_backup_finish | finish] all [sqlite3_backup] objects associated ++** with the [sqlite3] object prior to attempting to close the object. ++** ^If the database connection is associated with unfinalized prepared ++** statements, BLOB handlers, and/or unfinished sqlite3_backup objects then ++** sqlite3_close() will leave the database connection open and return ++** [SQLITE_BUSY]. ^If sqlite3_close_v2() is called with unfinalized prepared ++** statements, unclosed BLOB handlers, and/or unfinished sqlite3_backups, ++** it returns [SQLITE_OK] regardless, but instead of deallocating the database ++** connection immediately, it marks the database connection as an unusable ++** "zombie" and makes arrangements to automatically deallocate the database ++** connection after all prepared statements are finalized, all BLOB handles ++** are closed, and all backups have finished. The sqlite3_close_v2() interface ++** is intended for use with host languages that are garbage collected, and ++** where the order in which destructors are called is arbitrary. ++** ++** ^If an [sqlite3] object is destroyed while a transaction is open, ++** the transaction is automatically rolled back. ++** ++** The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(C)] ++** must be either a NULL ++** pointer or an [sqlite3] object pointer obtained ++** from [sqlite3_open()], [sqlite3_open16()], or ++** [sqlite3_open_v2()], and not previously closed. ++** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer ++** argument is a harmless no-op. ++*/ ++SQLITE_API int sqlite3_close(sqlite3*); ++SQLITE_API int sqlite3_close_v2(sqlite3*); ++ ++/* ++** The type for a callback function. ++** This is legacy and deprecated. It is included for historical ++** compatibility and is not documented. ++*/ ++typedef int (*sqlite3_callback)(void*,int,char**, char**); ++ ++/* ++** CAPI3REF: One-Step Query Execution Interface ++** METHOD: sqlite3 ++** ++** The sqlite3_exec() interface is a convenience wrapper around ++** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()], ++** that allows an application to run multiple statements of SQL ++** without having to use a lot of C code. ++** ++** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded, ++** semicolon-separate SQL statements passed into its 2nd argument, ++** in the context of the [database connection] passed in as its 1st ++** argument. ^If the callback function of the 3rd argument to ++** sqlite3_exec() is not NULL, then it is invoked for each result row ++** coming out of the evaluated SQL statements. ^The 4th argument to ++** sqlite3_exec() is relayed through to the 1st argument of each ++** callback invocation. ^If the callback pointer to sqlite3_exec() ++** is NULL, then no callback is ever invoked and result rows are ++** ignored. ++** ++** ^If an error occurs while evaluating the SQL statements passed into ++** sqlite3_exec(), then execution of the current statement stops and ++** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec() ++** is not NULL then any error message is written into memory obtained ++** from [sqlite3_malloc()] and passed back through the 5th parameter. ++** To avoid memory leaks, the application should invoke [sqlite3_free()] ++** on error message strings returned through the 5th parameter of ++** sqlite3_exec() after the error message string is no longer needed. ++** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors ++** occur, then sqlite3_exec() sets the pointer in its 5th parameter to ++** NULL before returning. ++** ++** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec() ++** routine returns SQLITE_ABORT without invoking the callback again and ++** without running any subsequent SQL statements. ++** ++** ^The 2nd argument to the sqlite3_exec() callback function is the ++** number of columns in the result. ^The 3rd argument to the sqlite3_exec() ++** callback is an array of pointers to strings obtained as if from ++** [sqlite3_column_text()], one for each column. ^If an element of a ++** result row is NULL then the corresponding string pointer for the ++** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the ++** sqlite3_exec() callback is an array of pointers to strings where each ++** entry represents the name of corresponding result column as obtained ++** from [sqlite3_column_name()]. ++** ++** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer ++** to an empty string, or a pointer that contains only whitespace and/or ++** SQL comments, then no SQL statements are evaluated and the database ++** is not changed. ++** ++** Restrictions: ++** ++**
    ++**
  • The application must ensure that the 1st parameter to sqlite3_exec() ++** is a valid and open [database connection]. ++**
  • The application must not close the [database connection] specified by ++** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running. ++**
  • The application must not modify the SQL statement text passed into ++** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running. ++**
++*/ ++SQLITE_API int sqlite3_exec( ++ sqlite3*, /* An open database */ ++ const char *sql, /* SQL to be evaluated */ ++ int (*callback)(void*,int,char**,char**), /* Callback function */ ++ void *, /* 1st argument to callback */ ++ char **errmsg /* Error msg written here */ ++); ++ ++/* ++** CAPI3REF: Result Codes ++** KEYWORDS: {result code definitions} ++** ++** Many SQLite functions return an integer result code from the set shown ++** here in order to indicate success or failure. ++** ++** New error codes may be added in future versions of SQLite. ++** ++** See also: [extended result code definitions] ++*/ ++#define SQLITE_OK 0 /* Successful result */ ++/* beginning-of-error-codes */ ++#define SQLITE_ERROR 1 /* Generic error */ ++#define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */ ++#define SQLITE_PERM 3 /* Access permission denied */ ++#define SQLITE_ABORT 4 /* Callback routine requested an abort */ ++#define SQLITE_BUSY 5 /* The database file is locked */ ++#define SQLITE_LOCKED 6 /* A table in the database is locked */ ++#define SQLITE_NOMEM 7 /* A malloc() failed */ ++#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ ++#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ ++#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ ++#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ ++#define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */ ++#define SQLITE_FULL 13 /* Insertion failed because database is full */ ++#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ ++#define SQLITE_PROTOCOL 15 /* Database lock protocol error */ ++#define SQLITE_EMPTY 16 /* Internal use only */ ++#define SQLITE_SCHEMA 17 /* The database schema changed */ ++#define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */ ++#define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */ ++#define SQLITE_MISMATCH 20 /* Data type mismatch */ ++#define SQLITE_MISUSE 21 /* Library used incorrectly */ ++#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ ++#define SQLITE_AUTH 23 /* Authorization denied */ ++#define SQLITE_FORMAT 24 /* Not used */ ++#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ ++#define SQLITE_NOTADB 26 /* File opened that is not a database file */ ++#define SQLITE_NOTICE 27 /* Notifications from sqlite3_log() */ ++#define SQLITE_WARNING 28 /* Warnings from sqlite3_log() */ ++#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ ++#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ ++/* end-of-error-codes */ ++ ++/* ++** CAPI3REF: Extended Result Codes ++** KEYWORDS: {extended result code definitions} ++** ++** In its default configuration, SQLite API routines return one of 30 integer ++** [result codes]. However, experience has shown that many of ++** these result codes are too coarse-grained. They do not provide as ++** much information about problems as programmers might like. In an effort to ++** address this, newer versions of SQLite (version 3.3.8 [dateof:3.3.8] ++** and later) include ++** support for additional result codes that provide more detailed information ++** about errors. These [extended result codes] are enabled or disabled ++** on a per database connection basis using the ++** [sqlite3_extended_result_codes()] API. Or, the extended code for ++** the most recent error can be obtained using ++** [sqlite3_extended_errcode()]. ++*/ ++#define SQLITE_ERROR_MISSING_COLLSEQ (SQLITE_ERROR | (1<<8)) ++#define SQLITE_ERROR_RETRY (SQLITE_ERROR | (2<<8)) ++#define SQLITE_ERROR_SNAPSHOT (SQLITE_ERROR | (3<<8)) ++#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) ++#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) ++#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) ++#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) ++#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) ++#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) ++#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) ++#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) ++#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) ++#define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) ++#define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) ++#define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) ++#define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) ++#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) ++#define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) ++#define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) ++#define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) ++#define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8)) ++#define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8)) ++#define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8)) ++#define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8)) ++#define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8)) ++#define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8)) ++#define SQLITE_IOERR_MMAP (SQLITE_IOERR | (24<<8)) ++#define SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR | (25<<8)) ++#define SQLITE_IOERR_CONVPATH (SQLITE_IOERR | (26<<8)) ++#define SQLITE_IOERR_VNODE (SQLITE_IOERR | (27<<8)) ++#define SQLITE_IOERR_AUTH (SQLITE_IOERR | (28<<8)) ++#define SQLITE_IOERR_BEGIN_ATOMIC (SQLITE_IOERR | (29<<8)) ++#define SQLITE_IOERR_COMMIT_ATOMIC (SQLITE_IOERR | (30<<8)) ++#define SQLITE_IOERR_ROLLBACK_ATOMIC (SQLITE_IOERR | (31<<8)) ++#define SQLITE_IOERR_DATA (SQLITE_IOERR | (32<<8)) ++#define SQLITE_IOERR_CORRUPTFS (SQLITE_IOERR | (33<<8)) ++#define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) ++#define SQLITE_LOCKED_VTAB (SQLITE_LOCKED | (2<<8)) ++#define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) ++#define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8)) ++#define SQLITE_BUSY_TIMEOUT (SQLITE_BUSY | (3<<8)) ++#define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8)) ++#define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) ++#define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) ++#define SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8)) ++#define SQLITE_CANTOPEN_DIRTYWAL (SQLITE_CANTOPEN | (5<<8)) /* Not Used */ ++#define SQLITE_CANTOPEN_SYMLINK (SQLITE_CANTOPEN | (6<<8)) ++#define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) ++#define SQLITE_CORRUPT_SEQUENCE (SQLITE_CORRUPT | (2<<8)) ++#define SQLITE_CORRUPT_INDEX (SQLITE_CORRUPT | (3<<8)) ++#define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) ++#define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) ++#define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8)) ++#define SQLITE_READONLY_DBMOVED (SQLITE_READONLY | (4<<8)) ++#define SQLITE_READONLY_CANTINIT (SQLITE_READONLY | (5<<8)) ++#define SQLITE_READONLY_DIRECTORY (SQLITE_READONLY | (6<<8)) ++#define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) ++#define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8)) ++#define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8)) ++#define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8)) ++#define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8)) ++#define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8)) ++#define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8)) ++#define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8)) ++#define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8)) ++#define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) ++#define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8)) ++#define SQLITE_CONSTRAINT_PINNED (SQLITE_CONSTRAINT |(11<<8)) ++#define SQLITE_CONSTRAINT_DATATYPE (SQLITE_CONSTRAINT |(12<<8)) ++#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8)) ++#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8)) ++#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8)) ++#define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8)) ++#define SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK | (1<<8)) ++#define SQLITE_OK_SYMLINK (SQLITE_OK | (2<<8)) ++ ++/* ++** CAPI3REF: Flags For File Open Operations ++** ++** These bit values are intended for use in the ++** 3rd parameter to the [sqlite3_open_v2()] interface and ++** in the 4th parameter to the [sqlite3_vfs.xOpen] method. ++** ++** Only those flags marked as "Ok for sqlite3_open_v2()" may be ++** used as the third argument to the [sqlite3_open_v2()] interface. ++** The other flags have historically been ignored by sqlite3_open_v2(), ++** though future versions of SQLite might change so that an error is ++** raised if any of the disallowed bits are passed into sqlite3_open_v2(). ++** Applications should not depend on the historical behavior. ++** ++** Note in particular that passing the SQLITE_OPEN_EXCLUSIVE flag into ++** [sqlite3_open_v2()] does *not* cause the underlying database file ++** to be opened using O_EXCL. Passing SQLITE_OPEN_EXCLUSIVE into ++** [sqlite3_open_v2()] has historically be a no-op and might become an ++** error in future versions of SQLite. ++*/ ++#define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */ ++#define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */ ++#define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */ ++#define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_MEMORY 0x00000080 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */ ++#define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */ ++#define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */ ++#define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */ ++#define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */ ++#define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */ ++#define SQLITE_OPEN_SUPER_JOURNAL 0x00004000 /* VFS only */ ++#define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_WAL 0x00080000 /* VFS only */ ++#define SQLITE_OPEN_NOFOLLOW 0x01000000 /* Ok for sqlite3_open_v2() */ ++#define SQLITE_OPEN_EXRESCODE 0x02000000 /* Extended result codes */ ++ ++/* Reserved: 0x00F00000 */ ++/* Legacy compatibility: */ ++#define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */ ++ ++ ++/* ++** CAPI3REF: Device Characteristics ++** ++** The xDeviceCharacteristics method of the [sqlite3_io_methods] ++** object returns an integer which is a vector of these ++** bit values expressing I/O characteristics of the mass storage ++** device that holds the file that the [sqlite3_io_methods] ++** refers to. ++** ++** The SQLITE_IOCAP_ATOMIC property means that all writes of ++** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values ++** mean that writes of blocks that are nnn bytes in size and ++** are aligned to an address which is an integer multiple of ++** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means ++** that when data is appended to a file, the data is appended ++** first then the size of the file is extended, never the other ++** way around. The SQLITE_IOCAP_SEQUENTIAL property means that ++** information is written to disk in the same order as calls ++** to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that ++** after reboot following a crash or power loss, the only bytes in a ++** file that were written at the application level might have changed ++** and that adjacent bytes, even bytes within the same sector are ++** guaranteed to be unchanged. The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN ++** flag indicates that a file cannot be deleted when open. The ++** SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on ++** read-only media and cannot be changed even by processes with ++** elevated privileges. ++** ++** The SQLITE_IOCAP_BATCH_ATOMIC property means that the underlying ++** filesystem supports doing multiple write operations atomically when those ++** write operations are bracketed by [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] and ++** [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]. ++*/ ++#define SQLITE_IOCAP_ATOMIC 0x00000001 ++#define SQLITE_IOCAP_ATOMIC512 0x00000002 ++#define SQLITE_IOCAP_ATOMIC1K 0x00000004 ++#define SQLITE_IOCAP_ATOMIC2K 0x00000008 ++#define SQLITE_IOCAP_ATOMIC4K 0x00000010 ++#define SQLITE_IOCAP_ATOMIC8K 0x00000020 ++#define SQLITE_IOCAP_ATOMIC16K 0x00000040 ++#define SQLITE_IOCAP_ATOMIC32K 0x00000080 ++#define SQLITE_IOCAP_ATOMIC64K 0x00000100 ++#define SQLITE_IOCAP_SAFE_APPEND 0x00000200 ++#define SQLITE_IOCAP_SEQUENTIAL 0x00000400 ++#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800 ++#define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000 ++#define SQLITE_IOCAP_IMMUTABLE 0x00002000 ++#define SQLITE_IOCAP_BATCH_ATOMIC 0x00004000 ++ ++/* ++** CAPI3REF: File Locking Levels ++** ++** SQLite uses one of these integer values as the second ++** argument to calls it makes to the xLock() and xUnlock() methods ++** of an [sqlite3_io_methods] object. ++*/ ++#define SQLITE_LOCK_NONE 0 ++#define SQLITE_LOCK_SHARED 1 ++#define SQLITE_LOCK_RESERVED 2 ++#define SQLITE_LOCK_PENDING 3 ++#define SQLITE_LOCK_EXCLUSIVE 4 ++ ++/* ++** CAPI3REF: Synchronization Type Flags ++** ++** When SQLite invokes the xSync() method of an ++** [sqlite3_io_methods] object it uses a combination of ++** these integer values as the second argument. ++** ++** When the SQLITE_SYNC_DATAONLY flag is used, it means that the ++** sync operation only needs to flush data to mass storage. Inode ++** information need not be flushed. If the lower four bits of the flag ++** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. ++** If the lower four bits equal SQLITE_SYNC_FULL, that means ++** to use Mac OS X style fullsync instead of fsync(). ++** ++** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags ++** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL ++** settings. The [synchronous pragma] determines when calls to the ++** xSync VFS method occur and applies uniformly across all platforms. ++** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how ++** energetic or rigorous or forceful the sync operations are and ++** only make a difference on Mac OSX for the default SQLite code. ++** (Third-party VFS implementations might also make the distinction ++** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the ++** operating systems natively supported by SQLite, only Mac OSX ++** cares about the difference.) ++*/ ++#define SQLITE_SYNC_NORMAL 0x00002 ++#define SQLITE_SYNC_FULL 0x00003 ++#define SQLITE_SYNC_DATAONLY 0x00010 ++ ++/* ++** CAPI3REF: OS Interface Open File Handle ++** ++** An [sqlite3_file] object represents an open file in the ++** [sqlite3_vfs | OS interface layer]. Individual OS interface ++** implementations will ++** want to subclass this object by appending additional fields ++** for their own use. The pMethods entry is a pointer to an ++** [sqlite3_io_methods] object that defines methods for performing ++** I/O operations on the open file. ++*/ ++typedef struct sqlite3_file sqlite3_file; ++struct sqlite3_file { ++ const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ ++}; ++ ++/* ++** CAPI3REF: OS Interface File Virtual Methods Object ++** ++** Every file opened by the [sqlite3_vfs.xOpen] method populates an ++** [sqlite3_file] object (or, more commonly, a subclass of the ++** [sqlite3_file] object) with a pointer to an instance of this object. ++** This object defines the methods used to perform various operations ++** against the open file represented by the [sqlite3_file] object. ++** ++** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element ++** to a non-NULL pointer, then the sqlite3_io_methods.xClose method ++** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The ++** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen] ++** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element ++** to NULL. ++** ++** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or ++** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). ++** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] ++** flag may be ORed in to indicate that only the data of the file ++** and not its inode needs to be synced. ++** ++** The integer values to xLock() and xUnlock() are one of ++**
    ++**
  • [SQLITE_LOCK_NONE], ++**
  • [SQLITE_LOCK_SHARED], ++**
  • [SQLITE_LOCK_RESERVED], ++**
  • [SQLITE_LOCK_PENDING], or ++**
  • [SQLITE_LOCK_EXCLUSIVE]. ++**
++** xLock() increases the lock. xUnlock() decreases the lock. ++** The xCheckReservedLock() method checks whether any database connection, ++** either in this process or in some other process, is holding a RESERVED, ++** PENDING, or EXCLUSIVE lock on the file. It returns true ++** if such a lock exists and false otherwise. ++** ++** The xFileControl() method is a generic interface that allows custom ++** VFS implementations to directly control an open file using the ++** [sqlite3_file_control()] interface. The second "op" argument is an ++** integer opcode. The third argument is a generic pointer intended to ++** point to a structure that may contain arguments or space in which to ++** write return values. Potential uses for xFileControl() might be ++** functions to enable blocking locks with timeouts, to change the ++** locking strategy (for example to use dot-file locks), to inquire ++** about the status of a lock, or to break stale locks. The SQLite ++** core reserves all opcodes less than 100 for its own use. ++** A [file control opcodes | list of opcodes] less than 100 is available. ++** Applications that define a custom xFileControl method should use opcodes ++** greater than 100 to avoid conflicts. VFS implementations should ++** return [SQLITE_NOTFOUND] for file control opcodes that they do not ++** recognize. ++** ++** The xSectorSize() method returns the sector size of the ++** device that underlies the file. The sector size is the ++** minimum write that can be performed without disturbing ++** other bytes in the file. The xDeviceCharacteristics() ++** method returns a bit vector describing behaviors of the ++** underlying device: ++** ++**
    ++**
  • [SQLITE_IOCAP_ATOMIC] ++**
  • [SQLITE_IOCAP_ATOMIC512] ++**
  • [SQLITE_IOCAP_ATOMIC1K] ++**
  • [SQLITE_IOCAP_ATOMIC2K] ++**
  • [SQLITE_IOCAP_ATOMIC4K] ++**
  • [SQLITE_IOCAP_ATOMIC8K] ++**
  • [SQLITE_IOCAP_ATOMIC16K] ++**
  • [SQLITE_IOCAP_ATOMIC32K] ++**
  • [SQLITE_IOCAP_ATOMIC64K] ++**
  • [SQLITE_IOCAP_SAFE_APPEND] ++**
  • [SQLITE_IOCAP_SEQUENTIAL] ++**
  • [SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN] ++**
  • [SQLITE_IOCAP_POWERSAFE_OVERWRITE] ++**
  • [SQLITE_IOCAP_IMMUTABLE] ++**
  • [SQLITE_IOCAP_BATCH_ATOMIC] ++**
++** ++** The SQLITE_IOCAP_ATOMIC property means that all writes of ++** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values ++** mean that writes of blocks that are nnn bytes in size and ++** are aligned to an address which is an integer multiple of ++** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means ++** that when data is appended to a file, the data is appended ++** first then the size of the file is extended, never the other ++** way around. The SQLITE_IOCAP_SEQUENTIAL property means that ++** information is written to disk in the same order as calls ++** to xWrite(). ++** ++** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill ++** in the unread portions of the buffer with zeros. A VFS that ++** fails to zero-fill short reads might seem to work. However, ++** failure to zero-fill short reads will eventually lead to ++** database corruption. ++*/ ++typedef struct sqlite3_io_methods sqlite3_io_methods; ++struct sqlite3_io_methods { ++ int iVersion; ++ int (*xClose)(sqlite3_file*); ++ int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); ++ int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); ++ int (*xTruncate)(sqlite3_file*, sqlite3_int64 size); ++ int (*xSync)(sqlite3_file*, int flags); ++ int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize); ++ int (*xLock)(sqlite3_file*, int); ++ int (*xUnlock)(sqlite3_file*, int); ++ int (*xCheckReservedLock)(sqlite3_file*, int *pResOut); ++ int (*xFileControl)(sqlite3_file*, int op, void *pArg); ++ int (*xSectorSize)(sqlite3_file*); ++ int (*xDeviceCharacteristics)(sqlite3_file*); ++ /* Methods above are valid for version 1 */ ++ int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**); ++ int (*xShmLock)(sqlite3_file*, int offset, int n, int flags); ++ void (*xShmBarrier)(sqlite3_file*); ++ int (*xShmUnmap)(sqlite3_file*, int deleteFlag); ++ /* Methods above are valid for version 2 */ ++ int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); ++ int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p); ++ /* Methods above are valid for version 3 */ ++ /* Additional methods may be added in future releases */ ++}; ++ ++/* ++** CAPI3REF: Standard File Control Opcodes ++** KEYWORDS: {file control opcodes} {file control opcode} ++** ++** These integer constants are opcodes for the xFileControl method ++** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()] ++** interface. ++** ++**
    ++**
  • [[SQLITE_FCNTL_LOCKSTATE]] ++** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This ++** opcode causes the xFileControl method to write the current state of ++** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], ++** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) ++** into an integer that the pArg argument points to. This capability ++** is used during testing and is only available when the SQLITE_TEST ++** compile-time option is used. ++** ++**
  • [[SQLITE_FCNTL_SIZE_HINT]] ++** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS ++** layer a hint of how large the database file will grow to be during the ++** current transaction. This hint is not guaranteed to be accurate but it ++** is often close. The underlying VFS might choose to preallocate database ++** file space based on this hint in order to help writes to the database ++** file run faster. ++** ++**
  • [[SQLITE_FCNTL_SIZE_LIMIT]] ++** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that ++** implements [sqlite3_deserialize()] to set an upper bound on the size ++** of the in-memory database. The argument is a pointer to a [sqlite3_int64]. ++** If the integer pointed to is negative, then it is filled in with the ++** current limit. Otherwise the limit is set to the larger of the value ++** of the integer pointed to and the current database size. The integer ++** pointed to is set to the new limit. ++** ++**
  • [[SQLITE_FCNTL_CHUNK_SIZE]] ++** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS ++** extends and truncates the database file in chunks of a size specified ++** by the user. The fourth argument to [sqlite3_file_control()] should ++** point to an integer (type int) containing the new chunk-size to use ++** for the nominated database. Allocating database file space in large ++** chunks (say 1MB at a time), may reduce file-system fragmentation and ++** improve performance on some systems. ++** ++**
  • [[SQLITE_FCNTL_FILE_POINTER]] ++** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer ++** to the [sqlite3_file] object associated with a particular database ++** connection. See also [SQLITE_FCNTL_JOURNAL_POINTER]. ++** ++**
  • [[SQLITE_FCNTL_JOURNAL_POINTER]] ++** The [SQLITE_FCNTL_JOURNAL_POINTER] opcode is used to obtain a pointer ++** to the [sqlite3_file] object associated with the journal file (either ++** the [rollback journal] or the [write-ahead log]) for a particular database ++** connection. See also [SQLITE_FCNTL_FILE_POINTER]. ++** ++**
  • [[SQLITE_FCNTL_SYNC_OMITTED]] ++** No longer in use. ++** ++**
  • [[SQLITE_FCNTL_SYNC]] ++** The [SQLITE_FCNTL_SYNC] opcode is generated internally by SQLite and ++** sent to the VFS immediately before the xSync method is invoked on a ++** database file descriptor. Or, if the xSync method is not invoked ++** because the user has configured SQLite with ++** [PRAGMA synchronous | PRAGMA synchronous=OFF] it is invoked in place ++** of the xSync method. In most cases, the pointer argument passed with ++** this file-control is NULL. However, if the database file is being synced ++** as part of a multi-database commit, the argument points to a nul-terminated ++** string containing the transactions super-journal file name. VFSes that ++** do not need this signal should silently ignore this opcode. Applications ++** should not call [sqlite3_file_control()] with this opcode as doing so may ++** disrupt the operation of the specialized VFSes that do require it. ++** ++**
  • [[SQLITE_FCNTL_COMMIT_PHASETWO]] ++** The [SQLITE_FCNTL_COMMIT_PHASETWO] opcode is generated internally by SQLite ++** and sent to the VFS after a transaction has been committed immediately ++** but before the database is unlocked. VFSes that do not need this signal ++** should silently ignore this opcode. Applications should not call ++** [sqlite3_file_control()] with this opcode as doing so may disrupt the ++** operation of the specialized VFSes that do require it. ++** ++**
  • [[SQLITE_FCNTL_WIN32_AV_RETRY]] ++** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic ++** retry counts and intervals for certain disk I/O operations for the ++** windows [VFS] in order to provide robustness in the presence of ++** anti-virus programs. By default, the windows VFS will retry file read, ++** file write, and file delete operations up to 10 times, with a delay ++** of 25 milliseconds before the first retry and with the delay increasing ++** by an additional 25 milliseconds with each subsequent retry. This ++** opcode allows these two values (10 retries and 25 milliseconds of delay) ++** to be adjusted. The values are changed for all database connections ++** within the same process. The argument is a pointer to an array of two ++** integers where the first integer is the new retry count and the second ++** integer is the delay. If either integer is negative, then the setting ++** is not changed but instead the prior value of that setting is written ++** into the array entry, allowing the current retry settings to be ++** interrogated. The zDbName parameter is ignored. ++** ++**
  • [[SQLITE_FCNTL_PERSIST_WAL]] ++** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the ++** persistent [WAL | Write Ahead Log] setting. By default, the auxiliary ++** write ahead log ([WAL file]) and shared memory ++** files used for transaction control ++** are automatically deleted when the latest connection to the database ++** closes. Setting persistent WAL mode causes those files to persist after ++** close. Persisting the files is useful when other processes that do not ++** have write permission on the directory containing the database file want ++** to read the database file, as the WAL and shared memory files must exist ++** in order for the database to be readable. The fourth parameter to ++** [sqlite3_file_control()] for this opcode should be a pointer to an integer. ++** That integer is 0 to disable persistent WAL mode or 1 to enable persistent ++** WAL mode. If the integer is -1, then it is overwritten with the current ++** WAL persistence setting. ++** ++**
  • [[SQLITE_FCNTL_POWERSAFE_OVERWRITE]] ++** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the ++** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting ++** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the ++** xDeviceCharacteristics methods. The fourth parameter to ++** [sqlite3_file_control()] for this opcode should be a pointer to an integer. ++** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage ++** mode. If the integer is -1, then it is overwritten with the current ++** zero-damage mode setting. ++** ++**
  • [[SQLITE_FCNTL_OVERWRITE]] ++** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening ++** a write transaction to indicate that, unless it is rolled back for some ++** reason, the entire database file will be overwritten by the current ++** transaction. This is used by VACUUM operations. ++** ++**
  • [[SQLITE_FCNTL_VFSNAME]] ++** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of ++** all [VFSes] in the VFS stack. The names are of all VFS shims and the ++** final bottom-level VFS are written into memory obtained from ++** [sqlite3_malloc()] and the result is stored in the char* variable ++** that the fourth parameter of [sqlite3_file_control()] points to. ++** The caller is responsible for freeing the memory when done. As with ++** all file-control actions, there is no guarantee that this will actually ++** do anything. Callers should initialize the char* variable to a NULL ++** pointer in case this file-control is not implemented. This file-control ++** is intended for diagnostic use only. ++** ++**
  • [[SQLITE_FCNTL_VFS_POINTER]] ++** ^The [SQLITE_FCNTL_VFS_POINTER] opcode finds a pointer to the top-level ++** [VFSes] currently in use. ^(The argument X in ++** sqlite3_file_control(db,SQLITE_FCNTL_VFS_POINTER,X) must be ++** of type "[sqlite3_vfs] **". This opcodes will set *X ++** to a pointer to the top-level VFS.)^ ++** ^When there are multiple VFS shims in the stack, this opcode finds the ++** upper-most shim only. ++** ++**
  • [[SQLITE_FCNTL_PRAGMA]] ++** ^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. ^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. ^The handler for an ++** [SQLITE_FCNTL_PRAGMA] file control can optionally make the first element ++** of the char** argument point to a string obtained from [sqlite3_mprintf()] ++** or the equivalent and that string will become the result of the pragma or ++** the error message if the pragma fails. ^If the ++** [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal ++** [PRAGMA] processing continues. ^If the [SQLITE_FCNTL_PRAGMA] ++** file control returns [SQLITE_OK], then the parser assumes that the ++** VFS has handled the PRAGMA itself and the parser generates a no-op ++** prepared statement if result string is NULL, or that returns a copy ++** of the result string if the string is non-NULL. ++** ^If the [SQLITE_FCNTL_PRAGMA] file control returns ++** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means ++** that the VFS encountered an error while handling the [PRAGMA] and the ++** compilation of the PRAGMA fails with an error. ^The [SQLITE_FCNTL_PRAGMA] ++** file control occurs at the beginning of pragma statement analysis and so ++** it is able to override built-in [PRAGMA] statements. ++** ++**
  • [[SQLITE_FCNTL_BUSYHANDLER]] ++** ^The [SQLITE_FCNTL_BUSYHANDLER] ++** file-control may be invoked by SQLite on the database file handle ++** shortly after it is opened in order to provide a custom VFS with access ++** to the connection's busy-handler callback. The argument is of type (void**) ++** - an array of two (void *) values. The first (void *) actually points ++** to a function of type (int (*)(void *)). In order to invoke the connection's ++** busy-handler, this function should be invoked with the second (void *) in ++** the array as the only argument. If it returns non-zero, then the operation ++** should be retried. If it returns zero, the custom VFS should abandon the ++** current operation. ++** ++**
  • [[SQLITE_FCNTL_TEMPFILENAME]] ++** ^Applications can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control ++** to have SQLite generate a ++** temporary filename using the same algorithm that is followed to generate ++** temporary filenames for TEMP tables and other internal uses. The ++** argument should be a char** which will be filled with the filename ++** written into memory obtained from [sqlite3_malloc()]. The caller should ++** invoke [sqlite3_free()] on the result to avoid a memory leak. ++** ++**
  • [[SQLITE_FCNTL_MMAP_SIZE]] ++** The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the ++** maximum number of bytes that will be used for memory-mapped I/O. ++** The argument is a pointer to a value of type sqlite3_int64 that ++** is an advisory maximum number of bytes in the file to memory map. The ++** pointer is overwritten with the old value. The limit is not changed if ++** the value originally pointed to is negative, and so the current limit ++** can be queried by passing in a pointer to a negative number. This ++** file-control is used internally to implement [PRAGMA mmap_size]. ++** ++**
  • [[SQLITE_FCNTL_TRACE]] ++** The [SQLITE_FCNTL_TRACE] file control provides advisory information ++** to the VFS about what the higher layers of the SQLite stack are doing. ++** This file control is used by some VFS activity tracing [shims]. ++** The argument is a zero-terminated string. Higher layers in the ++** SQLite stack may generate instances of this file control if ++** the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled. ++** ++**
  • [[SQLITE_FCNTL_HAS_MOVED]] ++** The [SQLITE_FCNTL_HAS_MOVED] file control interprets its argument as a ++** pointer to an integer and it writes a boolean into that integer depending ++** on whether or not the file has been renamed, moved, or deleted since it ++** was first opened. ++** ++**
  • [[SQLITE_FCNTL_WIN32_GET_HANDLE]] ++** The [SQLITE_FCNTL_WIN32_GET_HANDLE] opcode can be used to obtain the ++** underlying native file handle associated with a file handle. This file ++** control interprets its argument as a pointer to a native file handle and ++** writes the resulting value there. ++** ++**
  • [[SQLITE_FCNTL_WIN32_SET_HANDLE]] ++** The [SQLITE_FCNTL_WIN32_SET_HANDLE] opcode is used for debugging. This ++** opcode causes the xFileControl method to swap the file handle with the one ++** pointed to by the pArg argument. This capability is used during testing ++** and only needs to be supported when SQLITE_TEST is defined. ++** ++**
  • [[SQLITE_FCNTL_WAL_BLOCK]] ++** The [SQLITE_FCNTL_WAL_BLOCK] is a signal to the VFS layer that it might ++** be advantageous to block on the next WAL lock if the lock is not immediately ++** available. The WAL subsystem issues this signal during rare ++** circumstances in order to fix a problem with priority inversion. ++** Applications should not use this file-control. ++** ++**
  • [[SQLITE_FCNTL_ZIPVFS]] ++** The [SQLITE_FCNTL_ZIPVFS] opcode is implemented by zipvfs only. All other ++** VFS should return SQLITE_NOTFOUND for this opcode. ++** ++**
  • [[SQLITE_FCNTL_RBU]] ++** The [SQLITE_FCNTL_RBU] opcode is implemented by the special VFS used by ++** the RBU extension only. All other VFS should return SQLITE_NOTFOUND for ++** this opcode. ++** ++**
  • [[SQLITE_FCNTL_BEGIN_ATOMIC_WRITE]] ++** If the [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] opcode returns SQLITE_OK, then ++** the file descriptor is placed in "batch write mode", which ++** means all subsequent write operations will be deferred and done ++** atomically at the next [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]. Systems ++** that do not support batch atomic writes will return SQLITE_NOTFOUND. ++** ^Following a successful SQLITE_FCNTL_BEGIN_ATOMIC_WRITE and prior to ++** the closing [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE] or ++** [SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE], SQLite will make ++** no VFS interface calls on the same [sqlite3_file] file descriptor ++** except for calls to the xWrite method and the xFileControl method ++** with [SQLITE_FCNTL_SIZE_HINT]. ++** ++**
  • [[SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]] ++** The [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE] opcode causes all write ++** operations since the previous successful call to ++** [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] to be performed atomically. ++** This file control returns [SQLITE_OK] if and only if the writes were ++** all performed successfully and have been committed to persistent storage. ++** ^Regardless of whether or not it is successful, this file control takes ++** the file descriptor out of batch write mode so that all subsequent ++** write operations are independent. ++** ^SQLite will never invoke SQLITE_FCNTL_COMMIT_ATOMIC_WRITE without ++** a prior successful call to [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE]. ++** ++**
  • [[SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE]] ++** The [SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE] opcode causes all write ++** operations since the previous successful call to ++** [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] to be rolled back. ++** ^This file control takes the file descriptor out of batch write mode ++** so that all subsequent write operations are independent. ++** ^SQLite will never invoke SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE without ++** a prior successful call to [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE]. ++** ++**
  • [[SQLITE_FCNTL_LOCK_TIMEOUT]] ++** The [SQLITE_FCNTL_LOCK_TIMEOUT] opcode is used to configure a VFS ++** to block for up to M milliseconds before failing when attempting to ++** obtain a file lock using the xLock or xShmLock methods of the VFS. ++** The parameter is a pointer to a 32-bit signed integer that contains ++** the value that M is to be set to. Before returning, the 32-bit signed ++** integer is overwritten with the previous value of M. ++** ++**
  • [[SQLITE_FCNTL_DATA_VERSION]] ++** The [SQLITE_FCNTL_DATA_VERSION] opcode is used to detect changes to ++** a database file. The argument is a pointer to a 32-bit unsigned integer. ++** The "data version" for the pager is written into the pointer. The ++** "data version" changes whenever any change occurs to the corresponding ++** database file, either through SQL statements on the same database ++** connection or through transactions committed by separate database ++** connections possibly in other processes. The [sqlite3_total_changes()] ++** interface can be used to find if any database on the connection has changed, ++** but that interface responds to changes on TEMP as well as MAIN and does ++** not provide a mechanism to detect changes to MAIN only. Also, the ++** [sqlite3_total_changes()] interface responds to internal changes only and ++** omits changes made by other database connections. The ++** [PRAGMA data_version] command provides a mechanism to detect changes to ++** a single attached database that occur due to other database connections, ++** but omits changes implemented by the database connection on which it is ++** called. This file control is the only mechanism to detect changes that ++** happen either internally or externally and that are associated with ++** a particular attached database. ++** ++**
  • [[SQLITE_FCNTL_CKPT_START]] ++** The [SQLITE_FCNTL_CKPT_START] opcode is invoked from within a checkpoint ++** in wal mode before the client starts to copy pages from the wal ++** file to the database file. ++** ++**
  • [[SQLITE_FCNTL_CKPT_DONE]] ++** The [SQLITE_FCNTL_CKPT_DONE] opcode is invoked from within a checkpoint ++** in wal mode after the client has finished copying pages from the wal ++** file to the database file, but before the *-shm file is updated to ++** record the fact that the pages have been checkpointed. ++**
++** ++**
  • [[SQLITE_FCNTL_EXTERNAL_READER]] ++** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect ++** whether or not there is a database client in another process with a wal-mode ++** transaction open on the database or not. It is only available on unix.The ++** (void*) argument passed with this file-control should be a pointer to a ++** value of type (int). The integer value is set to 1 if the database is a wal ++** mode database and there exists at least one client in another process that ++** currently has an SQL transaction open on the database. It is set to 0 if ++** the database is not a wal-mode db, or if there is no such connection in any ++** other process. This opcode cannot be used to detect transactions opened ++** by clients within the current process, only within other processes. ++** ++** ++**
  • [[SQLITE_FCNTL_CKSM_FILE]] ++** Used by the cksmvfs VFS module only. ++** ++*/ ++#define SQLITE_FCNTL_LOCKSTATE 1 ++#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2 ++#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3 ++#define SQLITE_FCNTL_LAST_ERRNO 4 ++#define SQLITE_FCNTL_SIZE_HINT 5 ++#define SQLITE_FCNTL_CHUNK_SIZE 6 ++#define SQLITE_FCNTL_FILE_POINTER 7 ++#define SQLITE_FCNTL_SYNC_OMITTED 8 ++#define SQLITE_FCNTL_WIN32_AV_RETRY 9 ++#define SQLITE_FCNTL_PERSIST_WAL 10 ++#define SQLITE_FCNTL_OVERWRITE 11 ++#define SQLITE_FCNTL_VFSNAME 12 ++#define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13 ++#define SQLITE_FCNTL_PRAGMA 14 ++#define SQLITE_FCNTL_BUSYHANDLER 15 ++#define SQLITE_FCNTL_TEMPFILENAME 16 ++#define SQLITE_FCNTL_MMAP_SIZE 18 ++#define SQLITE_FCNTL_TRACE 19 ++#define SQLITE_FCNTL_HAS_MOVED 20 ++#define SQLITE_FCNTL_SYNC 21 ++#define SQLITE_FCNTL_COMMIT_PHASETWO 22 ++#define SQLITE_FCNTL_WIN32_SET_HANDLE 23 ++#define SQLITE_FCNTL_WAL_BLOCK 24 ++#define SQLITE_FCNTL_ZIPVFS 25 ++#define SQLITE_FCNTL_RBU 26 ++#define SQLITE_FCNTL_VFS_POINTER 27 ++#define SQLITE_FCNTL_JOURNAL_POINTER 28 ++#define SQLITE_FCNTL_WIN32_GET_HANDLE 29 ++#define SQLITE_FCNTL_PDB 30 ++#define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 31 ++#define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 32 ++#define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 33 ++#define SQLITE_FCNTL_LOCK_TIMEOUT 34 ++#define SQLITE_FCNTL_DATA_VERSION 35 ++#define SQLITE_FCNTL_SIZE_LIMIT 36 ++#define SQLITE_FCNTL_CKPT_DONE 37 ++#define SQLITE_FCNTL_RESERVE_BYTES 38 ++#define SQLITE_FCNTL_CKPT_START 39 ++#define SQLITE_FCNTL_EXTERNAL_READER 40 ++#define SQLITE_FCNTL_CKSM_FILE 41 ++ ++/* deprecated names */ ++#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE ++#define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE ++#define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO ++ ++ ++/* ++** CAPI3REF: Mutex Handle ++** ++** The mutex module within SQLite defines [sqlite3_mutex] to be an ++** abstract type for a mutex object. The SQLite core never looks ++** at the internal representation of an [sqlite3_mutex]. It only ++** deals with pointers to the [sqlite3_mutex] object. ++** ++** Mutexes are created using [sqlite3_mutex_alloc()]. ++*/ ++typedef struct sqlite3_mutex sqlite3_mutex; ++ ++/* ++** CAPI3REF: Loadable Extension Thunk ++** ++** A pointer to the opaque sqlite3_api_routines structure is passed as ++** the third parameter to entry points of [loadable extensions]. This ++** structure must be typedefed in order to work around compiler warnings ++** on some platforms. ++*/ ++typedef struct sqlite3_api_routines sqlite3_api_routines; ++ ++/* ++** CAPI3REF: OS Interface Object ++** ++** An instance of the sqlite3_vfs object defines the interface between ++** the SQLite core and the underlying operating system. The "vfs" ++** in the name of the object stands for "virtual file system". See ++** the [VFS | VFS documentation] for further information. ++** ++** The VFS interface is sometimes extended by adding new methods onto ++** the end. Each time such an extension occurs, the iVersion field ++** is incremented. The iVersion value started out as 1 in ++** SQLite [version 3.5.0] on [dateof:3.5.0], then increased to 2 ++** with SQLite [version 3.7.0] on [dateof:3.7.0], and then increased ++** to 3 with SQLite [version 3.7.6] on [dateof:3.7.6]. Additional fields ++** may be appended to the sqlite3_vfs object and the iVersion value ++** may increase again in future versions of SQLite. ++** Note that due to an oversight, the structure ++** of the sqlite3_vfs object changed in the transition from ++** SQLite [version 3.5.9] to [version 3.6.0] on [dateof:3.6.0] ++** and yet the iVersion field was not increased. ++** ++** The szOsFile field is the size of the subclassed [sqlite3_file] ++** structure used by this VFS. mxPathname is the maximum length of ++** a pathname in this VFS. ++** ++** Registered sqlite3_vfs objects are kept on a linked list formed by ++** the pNext pointer. The [sqlite3_vfs_register()] ++** and [sqlite3_vfs_unregister()] interfaces manage this list ++** in a thread-safe way. The [sqlite3_vfs_find()] interface ++** searches the list. Neither the application code nor the VFS ++** implementation should use the pNext pointer. ++** ++** The pNext field is the only field in the sqlite3_vfs ++** structure that SQLite will ever modify. SQLite will only access ++** or modify this field while holding a particular static mutex. ++** The application should never modify anything within the sqlite3_vfs ++** object once the object has been registered. ++** ++** The zName field holds the name of the VFS module. The name must ++** be unique across all VFS modules. ++** ++** [[sqlite3_vfs.xOpen]] ++** ^SQLite guarantees that the zFilename parameter to xOpen ++** is either a NULL pointer or string obtained ++** from xFullPathname() with an optional suffix added. ++** ^If a suffix is added to the zFilename parameter, it will ++** consist of a single "-" character followed by no more than ++** 11 alphanumeric and/or "-" characters. ++** ^SQLite further guarantees that ++** the string will be valid and unchanged until xClose() is ++** called. Because of the previous sentence, ++** the [sqlite3_file] can safely store a pointer to the ++** filename if it needs to remember the filename for some reason. ++** If the zFilename parameter to xOpen is a NULL pointer then xOpen ++** must invent its own temporary name for the file. ^Whenever the ++** xFilename parameter is NULL it will also be the case that the ++** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. ++** ++** The flags argument to xOpen() includes all bits set in ++** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] ++** or [sqlite3_open16()] is used, then flags includes at least ++** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. ++** If xOpen() opens a file read-only then it sets *pOutFlags to ++** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. ++** ++** ^(SQLite will also add one of the following flags to the xOpen() ++** call, depending on the object being opened: ++** ++**
      ++**
    • [SQLITE_OPEN_MAIN_DB] ++**
    • [SQLITE_OPEN_MAIN_JOURNAL] ++**
    • [SQLITE_OPEN_TEMP_DB] ++**
    • [SQLITE_OPEN_TEMP_JOURNAL] ++**
    • [SQLITE_OPEN_TRANSIENT_DB] ++**
    • [SQLITE_OPEN_SUBJOURNAL] ++**
    • [SQLITE_OPEN_SUPER_JOURNAL] ++**
    • [SQLITE_OPEN_WAL] ++**
    )^ ++** ++** The file I/O implementation can use the object type flags to ++** change the way it deals with files. For example, an application ++** that does not care about crash recovery or rollback might make ++** the open of a journal file a no-op. Writes to this journal would ++** also be no-ops, and any attempt to read the journal would return ++** SQLITE_IOERR. Or the implementation might recognize that a database ++** file will be doing page-aligned sector reads and writes in a random ++** order and set up its I/O subsystem accordingly. ++** ++** SQLite might also add one of the following flags to the xOpen method: ++** ++**
      ++**
    • [SQLITE_OPEN_DELETEONCLOSE] ++**
    • [SQLITE_OPEN_EXCLUSIVE] ++**
    ++** ++** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be ++** deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE] ++** will be set for TEMP databases and their journals, transient ++** databases, and subjournals. ++** ++** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction ++** with the [SQLITE_OPEN_CREATE] flag, which are both directly ++** analogous to the O_EXCL and O_CREAT flags of the POSIX open() ++** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the ++** SQLITE_OPEN_CREATE, is used to indicate that file should always ++** be created, and that it is an error if it already exists. ++** It is not used to indicate the file should be opened ++** for exclusive access. ++** ++** ^At least szOsFile bytes of memory are allocated by SQLite ++** to hold the [sqlite3_file] structure passed as the third ++** argument to xOpen. The xOpen method does not have to ++** allocate the structure; it should just fill it in. Note that ++** the xOpen method must set the sqlite3_file.pMethods to either ++** a valid [sqlite3_io_methods] object or to NULL. xOpen must do ++** this even if the open fails. SQLite expects that the sqlite3_file.pMethods ++** element will be valid after xOpen returns regardless of the success ++** or failure of the xOpen call. ++** ++** [[sqlite3_vfs.xAccess]] ++** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] ++** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to ++** test whether a file is readable and writable, or [SQLITE_ACCESS_READ] ++** to test whether a file is at least readable. The SQLITE_ACCESS_READ ++** flag is never actually used and is not implemented in the built-in ++** VFSes of SQLite. The file is named by the second argument and can be a ++** directory. The xAccess method returns [SQLITE_OK] on success or some ++** non-zero error code if there is an I/O error or if the name of ++** the file given in the second argument is illegal. If SQLITE_OK ++** is returned, then non-zero or zero is written into *pResOut to indicate ++** whether or not the file is accessible. ++** ++** ^SQLite will always allocate at least mxPathname+1 bytes for the ++** output buffer xFullPathname. The exact size of the output buffer ++** is also passed as a parameter to both methods. If the output buffer ++** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is ++** handled as a fatal error by SQLite, vfs implementations should endeavor ++** to prevent this by setting mxPathname to a sufficiently large value. ++** ++** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64() ++** interfaces are not strictly a part of the filesystem, but they are ++** included in the VFS structure for completeness. ++** The xRandomness() function attempts to return nBytes bytes ++** of good-quality randomness into zOut. The return value is ++** the actual number of bytes of randomness obtained. ++** The xSleep() method causes the calling thread to sleep for at ++** least the number of microseconds given. ^The xCurrentTime() ++** method returns a Julian Day Number for the current date and time as ++** a floating point value. ++** ^The xCurrentTimeInt64() method returns, as an integer, the Julian ++** Day Number multiplied by 86400000 (the number of milliseconds in ++** a 24-hour day). ++** ^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. ++** ++** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces ++** are not used by the SQLite core. These optional interfaces are provided ++** by some VFSes to facilitate testing of the VFS code. By overriding ++** system calls with functions under its control, a test program can ++** simulate faults and error conditions that would otherwise be difficult ++** or impossible to induce. The set of system calls that can be overridden ++** varies from one VFS to another, and from one version of the same VFS to the ++** next. Applications that use these interfaces must be prepared for any ++** or all of these interfaces to be NULL or for their behavior to change ++** from one release to the next. Applications must not attempt to access ++** any of these methods if the iVersion of the VFS is less than 3. ++*/ ++typedef struct sqlite3_vfs sqlite3_vfs; ++typedef void (*sqlite3_syscall_ptr)(void); ++struct sqlite3_vfs { ++ int iVersion; /* Structure version number (currently 3) */ ++ int szOsFile; /* Size of subclassed sqlite3_file */ ++ int mxPathname; /* Maximum file pathname length */ ++ sqlite3_vfs *pNext; /* Next registered VFS */ ++ const char *zName; /* Name of this virtual file system */ ++ void *pAppData; /* Pointer to application-specific data */ ++ int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*, ++ int flags, int *pOutFlags); ++ int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir); ++ int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut); ++ int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut); ++ void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename); ++ void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg); ++ void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void); ++ void (*xDlClose)(sqlite3_vfs*, void*); ++ int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut); ++ int (*xSleep)(sqlite3_vfs*, int microseconds); ++ int (*xCurrentTime)(sqlite3_vfs*, double*); ++ int (*xGetLastError)(sqlite3_vfs*, int, char *); ++ /* ++ ** The methods above are in version 1 of the sqlite_vfs object ++ ** definition. Those that follow are added in version 2 or later ++ */ ++ int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*); ++ /* ++ ** The methods above are in versions 1 and 2 of the sqlite_vfs object. ++ ** Those below are for version 3 and greater. ++ */ ++ int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr); ++ sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName); ++ const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName); ++ /* ++ ** The methods above are in versions 1 through 3 of the sqlite_vfs object. ++ ** New fields may be appended in future versions. The iVersion ++ ** value will increment whenever this happens. ++ */ ++}; ++ ++/* ++** CAPI3REF: Flags for the xAccess VFS method ++** ++** These integer constants can be used as the third parameter to ++** the xAccess method of an [sqlite3_vfs] object. They determine ++** what kind of permissions the xAccess method is looking for. ++** With SQLITE_ACCESS_EXISTS, the xAccess method ++** simply checks whether the file exists. ++** With SQLITE_ACCESS_READWRITE, the xAccess method ++** checks whether the named directory is both readable and writable ++** (in other words, if files can be added, removed, and renamed within ++** the directory). ++** The SQLITE_ACCESS_READWRITE constant is currently used only by the ++** [temp_store_directory pragma], though this could change in a future ++** release of SQLite. ++** With SQLITE_ACCESS_READ, the xAccess method ++** checks whether the file is readable. The SQLITE_ACCESS_READ constant is ++** currently unused, though it might be used in a future release of ++** SQLite. ++*/ ++#define SQLITE_ACCESS_EXISTS 0 ++#define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */ ++#define SQLITE_ACCESS_READ 2 /* Unused */ ++ ++/* ++** CAPI3REF: Flags for the xShmLock VFS method ++** ++** These integer constants define the various locking operations ++** allowed by the xShmLock method of [sqlite3_io_methods]. The ++** following are the only legal combinations of flags to the ++** xShmLock method: ++** ++**
      ++**
    • SQLITE_SHM_LOCK | SQLITE_SHM_SHARED ++**
    • SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE ++**
    • SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED ++**
    • SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE ++**
    ++** ++** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as ++** was given on the corresponding lock. ++** ++** The xShmLock method can transition between unlocked and SHARED or ++** between unlocked and EXCLUSIVE. It cannot transition between SHARED ++** and EXCLUSIVE. ++*/ ++#define SQLITE_SHM_UNLOCK 1 ++#define SQLITE_SHM_LOCK 2 ++#define SQLITE_SHM_SHARED 4 ++#define SQLITE_SHM_EXCLUSIVE 8 ++ ++/* ++** CAPI3REF: Maximum xShmLock index ++** ++** The xShmLock method on [sqlite3_io_methods] may use values ++** between 0 and this upper bound as its "offset" argument. ++** The SQLite core will never attempt to acquire or release a ++** lock outside of this range ++*/ ++#define SQLITE_SHM_NLOCK 8 ++ ++ ++/* ++** CAPI3REF: Initialize The SQLite Library ++** ++** ^The sqlite3_initialize() routine initializes the ++** SQLite library. ^The sqlite3_shutdown() routine ++** deallocates any resources that were allocated by sqlite3_initialize(). ++** These routines are designed to aid in process initialization and ++** shutdown on embedded systems. Workstation applications using ++** SQLite normally do not need to invoke either of these routines. ++** ++** A call to sqlite3_initialize() is an "effective" call if it is ++** the first time sqlite3_initialize() is invoked during the lifetime of ++** the process, or if it is the first time sqlite3_initialize() is invoked ++** following a call to sqlite3_shutdown(). ^(Only an effective call ++** of sqlite3_initialize() does any initialization. All other calls ++** are harmless no-ops.)^ ++** ++** A call to sqlite3_shutdown() is an "effective" call if it is the first ++** call to sqlite3_shutdown() since the last sqlite3_initialize(). ^(Only ++** an effective call to sqlite3_shutdown() does any deinitialization. ++** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^ ++** ++** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown() ++** is not. The sqlite3_shutdown() interface must only be called from a ++** single thread. All open [database connections] must be closed and all ++** other SQLite resources must be deallocated prior to invoking ++** sqlite3_shutdown(). ++** ++** Among other things, ^sqlite3_initialize() will invoke ++** sqlite3_os_init(). Similarly, ^sqlite3_shutdown() ++** will invoke sqlite3_os_end(). ++** ++** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success. ++** ^If for some reason, sqlite3_initialize() is unable to initialize ++** the library (perhaps it is unable to allocate a needed resource such ++** as a mutex) it returns an [error code] other than [SQLITE_OK]. ++** ++** ^The sqlite3_initialize() routine is called internally by many other ++** SQLite interfaces so that an application usually does not need to ++** invoke sqlite3_initialize() directly. For example, [sqlite3_open()] ++** calls sqlite3_initialize() so the SQLite library will be automatically ++** initialized when [sqlite3_open()] is called if it has not be initialized ++** already. ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT] ++** compile-time option, then the automatic calls to sqlite3_initialize() ++** are omitted and the application must call sqlite3_initialize() directly ++** prior to using any other SQLite interface. For maximum portability, ++** it is recommended that applications always invoke sqlite3_initialize() ++** directly prior to using any other SQLite interface. Future releases ++** of SQLite may require this. In other words, the behavior exhibited ++** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the ++** default behavior in some future release of SQLite. ++** ++** The sqlite3_os_init() routine does operating-system specific ++** initialization of the SQLite library. The sqlite3_os_end() ++** routine undoes the effect of sqlite3_os_init(). Typical tasks ++** performed by these routines include allocation or deallocation ++** of static resources, initialization of global variables, ++** setting up a default [sqlite3_vfs] module, or setting up ++** a default configuration using [sqlite3_config()]. ++** ++** The application should never invoke either sqlite3_os_init() ++** or sqlite3_os_end() directly. The application should only invoke ++** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init() ++** interface is called automatically by sqlite3_initialize() and ++** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate ++** implementations for sqlite3_os_init() and sqlite3_os_end() ++** are built into SQLite when it is compiled for Unix, Windows, or OS/2. ++** When [custom builds | built for other platforms] ++** (using the [SQLITE_OS_OTHER=1] compile-time ++** option) the application must supply a suitable implementation for ++** sqlite3_os_init() and sqlite3_os_end(). An application-supplied ++** implementation of sqlite3_os_init() or sqlite3_os_end() ++** must return [SQLITE_OK] on success and some other [error code] upon ++** failure. ++*/ ++SQLITE_API int sqlite3_initialize(void); ++SQLITE_API int sqlite3_shutdown(void); ++SQLITE_API int sqlite3_os_init(void); ++SQLITE_API int sqlite3_os_end(void); ++ ++/* ++** CAPI3REF: Configuring The SQLite Library ++** ++** The sqlite3_config() interface is used to make global configuration ++** changes to SQLite in order to tune SQLite to the specific needs of ++** the application. The default configuration is recommended for most ++** applications and so this routine is usually not necessary. It is ++** provided to support rare applications with unusual needs. ++** ++** The sqlite3_config() interface is not threadsafe. The application ++** must ensure that no other SQLite interfaces are invoked by other ++** threads while sqlite3_config() is running. ++** ++** The sqlite3_config() interface ++** may only be invoked prior to library initialization using ++** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()]. ++** ^If sqlite3_config() is called after [sqlite3_initialize()] and before ++** [sqlite3_shutdown()] then it will return SQLITE_MISUSE. ++** Note, however, that ^sqlite3_config() can be called as part of the ++** implementation of an application-defined [sqlite3_os_init()]. ++** ++** The first argument to sqlite3_config() is an integer ++** [configuration option] that determines ++** what property of SQLite is to be configured. Subsequent arguments ++** vary depending on the [configuration option] ++** in the first argument. ++** ++** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK]. ++** ^If the option is unknown or SQLite is unable to set the option ++** then this routine returns a non-zero [error code]. ++*/ ++SQLITE_API int sqlite3_config(int, ...); ++ ++/* ++** CAPI3REF: Configure database connections ++** METHOD: sqlite3 ++** ++** The sqlite3_db_config() interface is used to make configuration ++** changes to a [database connection]. The interface is similar to ++** [sqlite3_config()] except that the changes apply to a single ++** [database connection] (specified in the first argument). ++** ++** The second argument to sqlite3_db_config(D,V,...) is the ++** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code ++** that indicates what aspect of the [database connection] is being configured. ++** Subsequent arguments vary depending on the configuration verb. ++** ++** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if ++** the call is considered successful. ++*/ ++SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...); ++ ++/* ++** CAPI3REF: Memory Allocation Routines ++** ++** An instance of this object defines the interface between SQLite ++** and low-level memory allocation routines. ++** ++** This object is used in only one place in the SQLite interface. ++** A pointer to an instance of this object is the argument to ++** [sqlite3_config()] when the configuration option is ++** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. ++** By creating an instance of this object ++** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) ++** during configuration, an application can specify an alternative ++** memory allocation subsystem for SQLite to use for all of its ++** dynamic memory needs. ++** ++** Note that SQLite comes with several [built-in memory allocators] ++** that are perfectly adequate for the overwhelming majority of applications ++** and that this object is only useful to a tiny minority of applications ++** with specialized memory allocation requirements. This object is ++** also used during testing of SQLite in order to specify an alternative ++** memory allocator that simulates memory out-of-memory conditions in ++** order to verify that SQLite recovers gracefully from such ++** conditions. ++** ++** The xMalloc, xRealloc, and xFree methods must work like the ++** malloc(), realloc() and free() functions from the standard C library. ++** ^SQLite guarantees that the second argument to ++** xRealloc is always a value returned by a prior call to xRoundup. ++** ++** xSize should return the allocated size of a memory allocation ++** previously obtained from xMalloc or xRealloc. The allocated size ++** is always at least as big as the requested size but may be larger. ++** ++** The xRoundup method returns what would be the allocated size of ++** a memory allocation given a particular requested size. Most memory ++** allocators round up memory allocations at least to the next multiple ++** of 8. Some allocators round up to a larger multiple or to a power of 2. ++** Every memory allocation request coming in through [sqlite3_malloc()] ++** or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0, ++** that causes the corresponding memory allocation to fail. ++** ++** The xInit method initializes the memory allocator. For example, ++** it might allocate any required mutexes or initialize internal data ++** structures. The xShutdown method is invoked (indirectly) by ++** [sqlite3_shutdown()] and should deallocate any resources acquired ++** by xInit. The pAppData pointer is used as the only parameter to ++** xInit and xShutdown. ++** ++** SQLite holds the [SQLITE_MUTEX_STATIC_MAIN] mutex when it invokes ++** 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. For all other methods, SQLite ++** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the ++** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which ++** it is by default) and so the methods are automatically serialized. ++** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other ++** methods must be threadsafe or else make their own arrangements for ++** serialization. ++** ++** SQLite will never invoke xInit() more than once without an intervening ++** call to xShutdown(). ++*/ ++typedef struct sqlite3_mem_methods sqlite3_mem_methods; ++struct sqlite3_mem_methods { ++ void *(*xMalloc)(int); /* Memory allocation function */ ++ void (*xFree)(void*); /* Free a prior allocation */ ++ void *(*xRealloc)(void*,int); /* Resize an allocation */ ++ int (*xSize)(void*); /* Return the size of an allocation */ ++ int (*xRoundup)(int); /* Round up request size to allocation size */ ++ int (*xInit)(void*); /* Initialize the memory allocator */ ++ void (*xShutdown)(void*); /* Deinitialize the memory allocator */ ++ void *pAppData; /* Argument to xInit() and xShutdown() */ ++}; ++ ++/* ++** CAPI3REF: Configuration Options ++** KEYWORDS: {configuration option} ++** ++** These constants are the available integer configuration options that ++** can be passed as the first argument to the [sqlite3_config()] interface. ++** ++** New configuration options may be added in future releases of SQLite. ++** Existing configuration options might be discontinued. Applications ++** should check the return code from [sqlite3_config()] to make sure that ++** the call worked. The [sqlite3_config()] interface will return a ++** non-zero [error code] if a discontinued or unsupported configuration option ++** is invoked. ++** ++**
    ++** [[SQLITE_CONFIG_SINGLETHREAD]]
    SQLITE_CONFIG_SINGLETHREAD
    ++**
    There are no arguments to this option. ^This option sets the ++** [threading mode] to Single-thread. In other words, it disables ++** all mutexing and puts SQLite into a mode where it can only be used ++** by a single thread. ^If SQLite is compiled with ++** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then ++** it is not possible to change the [threading mode] from its default ++** value of Single-thread and so [sqlite3_config()] will return ++** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD ++** configuration option.
    ++** ++** [[SQLITE_CONFIG_MULTITHREAD]]
    SQLITE_CONFIG_MULTITHREAD
    ++**
    There are no arguments to this option. ^This option sets the ++** [threading mode] to Multi-thread. In other words, it disables ++** mutexing on [database connection] and [prepared statement] objects. ++** The application is responsible for serializing access to ++** [database connections] and [prepared statements]. But other mutexes ++** are enabled so that SQLite will be safe to use in a multi-threaded ++** environment as long as no two threads attempt to use the same ++** [database connection] at the same time. ^If SQLite is compiled with ++** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then ++** it is not possible to set the Multi-thread [threading mode] and ++** [sqlite3_config()] will return [SQLITE_ERROR] if called with the ++** SQLITE_CONFIG_MULTITHREAD configuration option.
    ++** ++** [[SQLITE_CONFIG_SERIALIZED]]
    SQLITE_CONFIG_SERIALIZED
    ++**
    There are no arguments to this option. ^This option sets the ++** [threading mode] to Serialized. In other words, this option enables ++** all mutexes including the recursive ++** mutexes on [database connection] and [prepared statement] objects. ++** In this mode (which is the default when SQLite is compiled with ++** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access ++** to [database connections] and [prepared statements] so that the ++** application is free to use the same [database connection] or the ++** same [prepared statement] in different threads at the same time. ++** ^If SQLite is compiled with ++** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then ++** it is not possible to set the Serialized [threading mode] and ++** [sqlite3_config()] will return [SQLITE_ERROR] if called with the ++** SQLITE_CONFIG_SERIALIZED configuration option.
    ++** ++** [[SQLITE_CONFIG_MALLOC]]
    SQLITE_CONFIG_MALLOC
    ++**
    ^(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.)^ ^SQLite makes ++** its own private copy of the content of the [sqlite3_mem_methods] structure ++** before the [sqlite3_config()] call returns.
    ++** ++** [[SQLITE_CONFIG_GETMALLOC]]
    SQLITE_CONFIG_GETMALLOC
    ++**
    ^(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.)^ ++** This option can be used to overload the default memory allocation ++** routines with a wrapper that simulations memory allocation failure or ++** tracks memory usage, for example.
    ++** ++** [[SQLITE_CONFIG_SMALL_MALLOC]]
    SQLITE_CONFIG_SMALL_MALLOC
    ++**
    ^The SQLITE_CONFIG_SMALL_MALLOC option takes single argument of ++** type int, interpreted as a boolean, which if true provides a hint to ++** SQLite that it should avoid large memory allocations if possible. ++** SQLite will run faster if it is free to make large memory allocations, ++** but some application might prefer to run slower in exchange for ++** guarantees about memory fragmentation that are possible if large ++** allocations are avoided. This hint is normally off. ++**
    ++** ++** [[SQLITE_CONFIG_MEMSTATUS]]
    SQLITE_CONFIG_MEMSTATUS
    ++**
    ^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. ^(When memory allocation statistics are ++** disabled, the following SQLite interfaces become non-operational: ++**
      ++**
    • [sqlite3_hard_heap_limit64()] ++**
    • [sqlite3_memory_used()] ++**
    • [sqlite3_memory_highwater()] ++**
    • [sqlite3_soft_heap_limit64()] ++**
    • [sqlite3_status64()] ++**
    )^ ++** ^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. ++**
    ++** ++** [[SQLITE_CONFIG_SCRATCH]]
    SQLITE_CONFIG_SCRATCH
    ++**
    The SQLITE_CONFIG_SCRATCH option is no longer used. ++**
    ++** ++** [[SQLITE_CONFIG_PAGECACHE]]
    SQLITE_CONFIG_PAGECACHE
    ++**
    ^The SQLITE_CONFIG_PAGECACHE option specifies a memory pool ++** that SQLite can use for the database page cache with the default page ++** cache implementation. ++** This configuration option is a no-op if an application-defined page ++** cache implementation is loaded using the [SQLITE_CONFIG_PCACHE2]. ++** ^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). ++** The sz argument should be the size of the largest database page ++** (a power of two between 512 and 65536) plus some extra bytes for each ++** page header. ^The number of extra bytes needed by the page header ++** can be determined using [SQLITE_CONFIG_PCACHE_HDRSZ]. ++** ^It is harmless, apart from the wasted memory, ++** for the sz parameter to be larger than necessary. The pMem ++** argument must be either a NULL pointer or a pointer to an 8-byte ++** aligned block of memory of at least sz*N bytes, otherwise ++** subsequent behavior is undefined. ++** ^When pMem is not NULL, SQLite will strive to use the memory provided ++** to satisfy page cache needs, falling back to [sqlite3_malloc()] if ++** a page cache line is larger than sz bytes or if all of the pMem buffer ++** is exhausted. ++** ^If pMem is NULL and N is non-zero, then each database connection ++** does an initial bulk allocation for page cache memory ++** from [sqlite3_malloc()] sufficient for N cache lines if N is positive or ++** of -1024*N bytes if N is negative, . ^If additional ++** page cache memory is needed beyond what is provided by the initial ++** allocation, then SQLite goes to [sqlite3_malloc()] separately for each ++** additional cache line.
    ++** ++** [[SQLITE_CONFIG_HEAP]]
    SQLITE_CONFIG_HEAP
    ++**
    ^The SQLITE_CONFIG_HEAP option specifies a static memory buffer ++** that SQLite will use for all of its dynamic memory allocation needs ++** beyond those provided for by [SQLITE_CONFIG_PAGECACHE]. ++** ^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. ++** ^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. ++** ^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]. ^If the ++** memory pointer is not NULL then the alternative memory ++** allocator is engaged to handle all of SQLites memory allocation needs. ++** The first pointer (the memory pointer) must be aligned to an 8-byte ++** boundary or subsequent behavior of SQLite will be undefined. ++** The minimum allocation size is capped at 2**12. Reasonable values ++** for the minimum allocation size are 2**5 through 2**8.
    ++** ++** [[SQLITE_CONFIG_MUTEX]]
    SQLITE_CONFIG_MUTEX
    ++**
    ^(The SQLITE_CONFIG_MUTEX option takes a single argument which is a ++** pointer to an instance of the [sqlite3_mutex_methods] structure. ++** The argument specifies alternative low-level mutex routines to be used ++** in place the mutex routines built into SQLite.)^ ^SQLite makes a copy of ++** the content of the [sqlite3_mutex_methods] structure before the call to ++** [sqlite3_config()] returns. ^If SQLite is compiled with ++** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then ++** the entire mutexing subsystem is omitted from the build and hence calls to ++** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will ++** return [SQLITE_ERROR].
    ++** ++** [[SQLITE_CONFIG_GETMUTEX]]
    SQLITE_CONFIG_GETMUTEX
    ++**
    ^(The SQLITE_CONFIG_GETMUTEX option takes a single argument which ++** is a pointer to an instance of the [sqlite3_mutex_methods] structure. The ++** [sqlite3_mutex_methods] ++** structure is filled with the currently defined mutex routines.)^ ++** This option can be used to overload the default mutex allocation ++** routines with a wrapper used to track mutex usage for performance ++** profiling or testing, for example. ^If SQLite is compiled with ++** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then ++** the entire mutexing subsystem is omitted from the build and hence calls to ++** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will ++** return [SQLITE_ERROR].
    ++** ++** [[SQLITE_CONFIG_LOOKASIDE]]
    SQLITE_CONFIG_LOOKASIDE
    ++**
    ^(The SQLITE_CONFIG_LOOKASIDE option takes two arguments that determine ++** the default size of lookaside memory on each [database connection]. ++** The first argument is the ++** size of each lookaside buffer slot and the second is the number of ++** slots allocated to each database connection.)^ ^(SQLITE_CONFIG_LOOKASIDE ++** sets the default lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE] ++** option to [sqlite3_db_config()] can be used to change the lookaside ++** configuration on individual connections.)^
    ++** ++** [[SQLITE_CONFIG_PCACHE2]]
    SQLITE_CONFIG_PCACHE2
    ++**
    ^(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.)^ ++** ^SQLite makes a copy of the [sqlite3_pcache_methods2] object.
    ++** ++** [[SQLITE_CONFIG_GETPCACHE2]]
    SQLITE_CONFIG_GETPCACHE2
    ++**
    ^(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.)^
    ++** ++** [[SQLITE_CONFIG_LOG]]
    SQLITE_CONFIG_LOG
    ++**
    The SQLITE_CONFIG_LOG option is used to configure the SQLite ++** global [error log]. ++** (^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a ++** function with a call signature of void(*)(void*,int,const char*), ++** and a pointer to void. ^If the function pointer is not NULL, it is ++** invoked by [sqlite3_log()] to process each logging event. ^If the ++** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op. ++** ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is ++** passed through as the first parameter to the application-defined logger ++** function whenever that function is invoked. ^The second parameter to ++** the logger function is a copy of the first parameter to the corresponding ++** [sqlite3_log()] call and is intended to be a [result code] or an ++** [extended result code]. ^The third parameter passed to the logger is ++** log message after formatting via [sqlite3_snprintf()]. ++** The SQLite logging interface is not reentrant; the logger function ++** supplied by the application must not invoke any SQLite interface. ++** In a multi-threaded application, the application-defined logger ++** function must be threadsafe.
    ++** ++** [[SQLITE_CONFIG_URI]]
    SQLITE_CONFIG_URI ++**
    ^(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.)^ ^If URI handling is globally ++** enabled, all filenames passed to [sqlite3_open()], [sqlite3_open_v2()], ++** [sqlite3_open16()] or ++** specified as part of [ATTACH] commands are interpreted as URIs, regardless ++** of whether or not the [SQLITE_OPEN_URI] flag is set when the database ++** connection is opened. ^If it is globally disabled, filenames are ++** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the ++** database connection is opened. ^(By default, URI handling is globally ++** disabled. The default value may be changed by compiling with the ++** [SQLITE_USE_URI] symbol defined.)^ ++** ++** [[SQLITE_CONFIG_COVERING_INDEX_SCAN]]
    SQLITE_CONFIG_COVERING_INDEX_SCAN ++**
    ^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. ++** ^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. ++** The ability to disable the use of covering indices for full table scans ++** is because some incorrectly coded legacy applications might malfunction ++** when the optimization is enabled. Providing the ability to ++** disable the optimization allows the older, buggy application code to work ++** without change even with newer versions of SQLite. ++** ++** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]] ++**
    SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE ++**
    These options are obsolete and should not be used by new code. ++** They are retained for backwards compatibility but are now no-ops. ++**
    ++** ++** [[SQLITE_CONFIG_SQLLOG]] ++**
    SQLITE_CONFIG_SQLLOG ++**
    This option is only available if sqlite is compiled with the ++** [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should ++** be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int). ++** The second should be of type (void*). The callback is invoked by the library ++** in three separate circumstances, identified by the value passed as the ++** fourth parameter. If the fourth parameter is 0, then the database connection ++** passed as the second argument has just been opened. The third argument ++** points to a buffer containing the name of the main database file. If the ++** fourth parameter is 1, then the SQL statement that the third parameter ++** points to has just been executed. Or, if the fourth parameter is 2, then ++** the connection being passed as the second parameter is being closed. The ++** third parameter is passed NULL In this case. An example of using this ++** configuration option can be seen in the "test_sqllog.c" source file in ++** the canonical SQLite source tree.
    ++** ++** [[SQLITE_CONFIG_MMAP_SIZE]] ++**
    SQLITE_CONFIG_MMAP_SIZE ++**
    ^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. ++** ^The default setting can be overridden by each database connection using ++** either the [PRAGMA mmap_size] command, or by using the ++** [SQLITE_FCNTL_MMAP_SIZE] file control. ^(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 either argument to this option is negative, then that argument is ++** changed to its compile-time default. ++** ++** [[SQLITE_CONFIG_WIN32_HEAPSIZE]] ++**
    SQLITE_CONFIG_WIN32_HEAPSIZE ++**
    ^The SQLITE_CONFIG_WIN32_HEAPSIZE option is only available if SQLite is ++** compiled for Windows with the [SQLITE_WIN32_MALLOC] pre-processor macro ++** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value ++** that specifies the maximum size of the created heap. ++** ++** [[SQLITE_CONFIG_PCACHE_HDRSZ]] ++**
    SQLITE_CONFIG_PCACHE_HDRSZ ++**
    ^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]. ++** The amount of extra space required can change depending on the compiler, ++** target platform, and SQLite version. ++** ++** [[SQLITE_CONFIG_PMASZ]] ++**
    SQLITE_CONFIG_PMASZ ++**
    ^The SQLITE_CONFIG_PMASZ option takes a single parameter which ++** is an unsigned integer and sets the "Minimum PMA Size" for the multithreaded ++** sorter to that integer. The default minimum PMA Size is set by the ++** [SQLITE_SORTER_PMASZ] compile-time option. New threads are launched ++** to help with sort operations when multithreaded sorting ++** is enabled (using the [PRAGMA threads] command) and the amount of content ++** to be sorted exceeds the page size times the minimum of the ++** [PRAGMA cache_size] setting and this value. ++** ++** [[SQLITE_CONFIG_STMTJRNL_SPILL]] ++**
    SQLITE_CONFIG_STMTJRNL_SPILL ++**
    ^The SQLITE_CONFIG_STMTJRNL_SPILL option takes a single parameter which ++** becomes the [statement journal] spill-to-disk threshold. ++** [Statement journals] are held in memory until their size (in bytes) ++** exceeds this threshold, at which point they are written to disk. ++** Or if the threshold is -1, statement journals are always held ++** exclusively in memory. ++** Since many statement journals never become large, setting the spill ++** threshold to a value such as 64KiB can greatly reduce the amount of ++** I/O required to support statement rollback. ++** The default value for this setting is controlled by the ++** [SQLITE_STMTJRNL_SPILL] compile-time option. ++** ++** [[SQLITE_CONFIG_SORTERREF_SIZE]] ++**
    SQLITE_CONFIG_SORTERREF_SIZE ++**
    The SQLITE_CONFIG_SORTERREF_SIZE option accepts a single parameter ++** of type (int) - the new value of the sorter-reference size threshold. ++** Usually, when SQLite uses an external sort to order records according ++** to an ORDER BY clause, all fields required by the caller are present in the ++** sorted records. However, if SQLite determines based on the declared type ++** of a table column that its values are likely to be very large - larger ++** than the configured sorter-reference size threshold - then a reference ++** is stored in each sorted record and the required column values loaded ++** from the database as records are returned in sorted order. The default ++** value for this option is to never use this optimization. Specifying a ++** negative value for this option restores the default behaviour. ++** This option is only available if SQLite is compiled with the ++** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option. ++** ++** [[SQLITE_CONFIG_MEMDB_MAXSIZE]] ++**
    SQLITE_CONFIG_MEMDB_MAXSIZE ++**
    The SQLITE_CONFIG_MEMDB_MAXSIZE option accepts a single parameter ++** [sqlite3_int64] parameter which is the default maximum size for an in-memory ++** database created using [sqlite3_deserialize()]. This default maximum ++** size can be adjusted up or down for individual databases using the ++** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control]. If this ++** configuration setting is never used, then the default maximum is determined ++** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option. If that ++** compile-time option is not set, then the default maximum is 1073741824. ++**
    ++*/ ++#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */ ++#define SQLITE_CONFIG_MULTITHREAD 2 /* nil */ ++#define SQLITE_CONFIG_SERIALIZED 3 /* nil */ ++#define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */ ++#define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */ ++#define SQLITE_CONFIG_SCRATCH 6 /* No longer used */ ++#define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */ ++#define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */ ++#define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */ ++#define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */ ++#define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */ ++/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */ ++#define SQLITE_CONFIG_LOOKASIDE 13 /* int int */ ++#define SQLITE_CONFIG_PCACHE 14 /* no-op */ ++#define SQLITE_CONFIG_GETPCACHE 15 /* no-op */ ++#define SQLITE_CONFIG_LOG 16 /* xFunc, void* */ ++#define SQLITE_CONFIG_URI 17 /* int */ ++#define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */ ++#define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */ ++#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 /* int */ ++#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */ ++#define SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */ ++#define SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */ ++#define SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int *psz */ ++#define SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */ ++#define SQLITE_CONFIG_STMTJRNL_SPILL 26 /* int nByte */ ++#define SQLITE_CONFIG_SMALL_MALLOC 27 /* boolean */ ++#define SQLITE_CONFIG_SORTERREF_SIZE 28 /* int nByte */ ++#define SQLITE_CONFIG_MEMDB_MAXSIZE 29 /* sqlite3_int64 */ ++ ++/* ++** CAPI3REF: Database Connection Configuration Options ++** ++** These constants are the available integer configuration options that ++** can be passed as the second argument to the [sqlite3_db_config()] interface. ++** ++** New configuration options may be added in future releases of SQLite. ++** Existing configuration options might be discontinued. Applications ++** should check the return code from [sqlite3_db_config()] to make sure that ++** the call worked. ^The [sqlite3_db_config()] interface will return a ++** non-zero [error code] if a discontinued or unsupported configuration option ++** is invoked. ++** ++**
    ++** [[SQLITE_DBCONFIG_LOOKASIDE]] ++**
    SQLITE_DBCONFIG_LOOKASIDE
    ++**
    ^This option takes three additional arguments that determine the ++** [lookaside memory allocator] configuration for the [database connection]. ++** ^The first argument (the third parameter to [sqlite3_db_config()] is a ++** pointer to a memory buffer to use for lookaside memory. ++** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb ++** may be NULL in which case SQLite will allocate the ++** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the ++** size of each lookaside buffer slot. ^The third argument is the number of ++** slots. The size of the buffer in the first argument must be greater than ++** or equal to the product of the second and third arguments. The buffer ++** must be aligned to an 8-byte boundary. ^If the second argument to ++** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally ++** rounded down to the next smaller multiple of 8. ^(The lookaside memory ++** configuration for a database connection can only be changed when that ++** connection is not currently using lookaside memory, or in other words ++** when the "current value" returned by ++** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero. ++** Any attempt to change the lookaside memory configuration when lookaside ++** memory is in use leaves the configuration unchanged and returns ++** [SQLITE_BUSY].)^
    ++** ++** [[SQLITE_DBCONFIG_ENABLE_FKEY]] ++**
    SQLITE_DBCONFIG_ENABLE_FKEY
    ++**
    ^This option is used to enable or disable the enforcement of ++** [foreign key constraints]. There should be two additional arguments. ++** The first argument is an integer which is 0 to disable FK enforcement, ++** positive to enable FK enforcement or negative to leave FK enforcement ++** unchanged. The second parameter is a pointer to an integer into which ++** is written 0 or 1 to indicate whether FK enforcement is off or on ++** following this call. The second parameter may be a NULL pointer, in ++** which case the FK enforcement setting is not reported back.
    ++** ++** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]] ++**
    SQLITE_DBCONFIG_ENABLE_TRIGGER
    ++**
    ^This option is used to enable or disable [CREATE TRIGGER | triggers]. ++** There should be two additional arguments. ++** The first argument is an integer which is 0 to disable triggers, ++** positive to enable triggers or negative to leave the setting unchanged. ++** The second parameter is a pointer to an integer into which ++** is written 0 or 1 to indicate whether triggers are disabled or enabled ++** following this call. The second parameter may be a NULL pointer, in ++** which case the trigger setting is not reported back. ++** ++**

    Originally this option disabled all triggers. ^(However, since ++** SQLite version 3.35.0, TEMP triggers are still allowed even if ++** this option is off. So, in other words, this option now only disables ++** triggers in the main database schema or in the schemas of ATTACH-ed ++** databases.)^

    ++** ++** [[SQLITE_DBCONFIG_ENABLE_VIEW]] ++**
    SQLITE_DBCONFIG_ENABLE_VIEW
    ++**
    ^This option is used to enable or disable [CREATE VIEW | views]. ++** There should be two additional arguments. ++** The first argument is an integer which is 0 to disable views, ++** positive to enable views or negative to leave the setting unchanged. ++** The second parameter is a pointer to an integer into which ++** is written 0 or 1 to indicate whether views are disabled or enabled ++** following this call. The second parameter may be a NULL pointer, in ++** which case the view setting is not reported back. ++** ++**

    Originally this option disabled all views. ^(However, since ++** SQLite version 3.35.0, TEMP views are still allowed even if ++** this option is off. So, in other words, this option now only disables ++** views in the main database schema or in the schemas of ATTACH-ed ++** databases.)^

    ++** ++** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]] ++**
    SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER
    ++**
    ^This option is used to enable or disable the ++** [fts3_tokenizer()] function which is part of the ++** [FTS3] full-text search engine extension. ++** There should be two additional arguments. ++** The first argument is an integer which is 0 to disable fts3_tokenizer() or ++** positive to enable fts3_tokenizer() or negative to leave the setting ++** unchanged. ++** The second parameter is a pointer to an integer into which ++** is written 0 or 1 to indicate whether fts3_tokenizer is disabled or enabled ++** following this call. The second parameter may be a NULL pointer, in ++** which case the new setting is not reported back.
    ++** ++** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]] ++**
    SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION
    ++**
    ^This option is used to enable or disable the [sqlite3_load_extension()] ++** interface independently of the [load_extension()] SQL function. ++** The [sqlite3_enable_load_extension()] API enables or disables both the ++** C-API [sqlite3_load_extension()] and the SQL function [load_extension()]. ++** There should be two additional arguments. ++** When the first argument to this interface is 1, then only the C-API is ++** enabled and the SQL function remains disabled. If the first argument to ++** this interface is 0, then both the C-API and the SQL function are disabled. ++** If the first argument is -1, then no changes are made to state of either the ++** C-API or the SQL function. ++** The second parameter is a pointer to an integer into which ++** is written 0 or 1 to indicate whether [sqlite3_load_extension()] interface ++** is disabled or enabled following this call. The second parameter may ++** be a NULL pointer, in which case the new setting is not reported back. ++**
    ++** ++** [[SQLITE_DBCONFIG_MAINDBNAME]]
    SQLITE_DBCONFIG_MAINDBNAME
    ++**
    ^This option is used to change the name of the "main" database ++** schema. ^The sole argument is a pointer to a constant UTF8 string ++** which will become the new schema name in place of "main". ^SQLite ++** does not make a copy of the new main schema name string, so the application ++** must ensure that the argument passed into this DBCONFIG option is unchanged ++** until after the database connection closes. ++**
    ++** ++** [[SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE]] ++**
    SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE
    ++**
    Usually, when a database in wal mode is closed or detached from a ++** database handle, SQLite checks if this will mean that there are now no ++** connections at all to the database. If so, it performs a checkpoint ++** operation before closing the connection. This option may be used to ++** override this behaviour. The first parameter passed to this operation ++** is an integer - positive to disable checkpoints-on-close, or zero (the ++** default) to enable them, and negative to leave the setting unchanged. ++** The second parameter is a pointer to an integer ++** into which is written 0 or 1 to indicate whether checkpoints-on-close ++** have been disabled - 0 if they are not disabled, 1 if they are. ++**
    ++** ++** [[SQLITE_DBCONFIG_ENABLE_QPSG]]
    SQLITE_DBCONFIG_ENABLE_QPSG
    ++**
    ^(The SQLITE_DBCONFIG_ENABLE_QPSG option activates or deactivates ++** the [query planner stability guarantee] (QPSG). When the QPSG is active, ++** a single SQL query statement will always use the same algorithm regardless ++** of values of [bound parameters].)^ The QPSG disables some query optimizations ++** that look at the values of bound parameters, which can make some queries ++** slower. But the QPSG has the advantage of more predictable behavior. With ++** the QPSG active, SQLite will always use the same query plan in the field as ++** was used during testing in the lab. ++** The first argument to this setting is an integer which is 0 to disable ++** the QPSG, positive to enable QPSG, or negative to leave the setting ++** unchanged. The second parameter is a pointer to an integer into which ++** is written 0 or 1 to indicate whether the QPSG is disabled or enabled ++** following this call. ++**
    ++** ++** [[SQLITE_DBCONFIG_TRIGGER_EQP]]
    SQLITE_DBCONFIG_TRIGGER_EQP
    ++**
    By default, the output of EXPLAIN QUERY PLAN commands does not ++** include output for any operations performed by trigger programs. This ++** option is used to set or clear (the default) a flag that governs this ++** behavior. The first parameter passed to this operation is an integer - ++** positive to enable output for trigger programs, or zero to disable it, ++** or negative to leave the setting unchanged. ++** The second parameter is a pointer to an integer into which is written ++** 0 or 1 to indicate whether output-for-triggers has been disabled - 0 if ++** it is not disabled, 1 if it is. ++**
    ++** ++** [[SQLITE_DBCONFIG_RESET_DATABASE]]
    SQLITE_DBCONFIG_RESET_DATABASE
    ++**
    Set the SQLITE_DBCONFIG_RESET_DATABASE flag and then run ++** [VACUUM] in order to reset a database back to an empty database ++** with no schema and no content. The following process works even for ++** a badly corrupted database file: ++**
      ++**
    1. If the database connection is newly opened, make sure it has read the ++** database schema by preparing then discarding some query against the ++** database, or calling sqlite3_table_column_metadata(), ignoring any ++** errors. This step is only necessary if the application desires to keep ++** the database in WAL mode after the reset if it was in WAL mode before ++** the reset. ++**
    2. sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0); ++**
    3. [sqlite3_exec](db, "[VACUUM]", 0, 0, 0); ++**
    4. sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0); ++**
    ++** Because resetting a database is destructive and irreversible, the ++** process requires the use of this obscure API and multiple steps to help ++** ensure that it does not happen by accident. ++** ++** [[SQLITE_DBCONFIG_DEFENSIVE]]
    SQLITE_DBCONFIG_DEFENSIVE
    ++**
    The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the ++** "defensive" flag for a database connection. When the defensive ++** flag is enabled, language features that allow ordinary SQL to ++** deliberately corrupt the database file are disabled. The disabled ++** features include but are not limited to the following: ++**
      ++**
    • The [PRAGMA writable_schema=ON] statement. ++**
    • The [PRAGMA journal_mode=OFF] statement. ++**
    • Writes to the [sqlite_dbpage] virtual table. ++**
    • Direct writes to [shadow tables]. ++**
    ++**
    ++** ++** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]]
    SQLITE_DBCONFIG_WRITABLE_SCHEMA
    ++**
    The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the ++** "writable_schema" flag. This has the same effect and is logically equivalent ++** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF]. ++** The first argument to this setting is an integer which is 0 to disable ++** the writable_schema, positive to enable writable_schema, or negative to ++** leave the setting unchanged. The second parameter is a pointer to an ++** integer into which is written 0 or 1 to indicate whether the writable_schema ++** is enabled or disabled following this call. ++**
    ++** ++** [[SQLITE_DBCONFIG_LEGACY_ALTER_TABLE]] ++**
    SQLITE_DBCONFIG_LEGACY_ALTER_TABLE
    ++**
    The SQLITE_DBCONFIG_LEGACY_ALTER_TABLE option activates or deactivates ++** the legacy behavior of the [ALTER TABLE RENAME] command such it ++** behaves as it did prior to [version 3.24.0] (2018-06-04). See the ++** "Compatibility Notice" on the [ALTER TABLE RENAME documentation] for ++** additional information. This feature can also be turned on and off ++** using the [PRAGMA legacy_alter_table] statement. ++**
    ++** ++** [[SQLITE_DBCONFIG_DQS_DML]] ++**
    SQLITE_DBCONFIG_DQS_DML ++**
    The SQLITE_DBCONFIG_DQS_DML option activates or deactivates ++** the legacy [double-quoted string literal] misfeature for DML statements ++** only, that is DELETE, INSERT, SELECT, and UPDATE statements. The ++** default value of this setting is determined by the [-DSQLITE_DQS] ++** compile-time option. ++**
    ++** ++** [[SQLITE_DBCONFIG_DQS_DDL]] ++**
    SQLITE_DBCONFIG_DQS_DDL ++**
    The SQLITE_DBCONFIG_DQS option activates or deactivates ++** the legacy [double-quoted string literal] misfeature for DDL statements, ++** such as CREATE TABLE and CREATE INDEX. The ++** default value of this setting is determined by the [-DSQLITE_DQS] ++** compile-time option. ++**
    ++** ++** [[SQLITE_DBCONFIG_TRUSTED_SCHEMA]] ++**
    SQLITE_DBCONFIG_TRUSTED_SCHEMA ++**
    The SQLITE_DBCONFIG_TRUSTED_SCHEMA option tells SQLite to ++** assume that database schemas are untainted by malicious content. ++** When the SQLITE_DBCONFIG_TRUSTED_SCHEMA option is disabled, SQLite ++** takes additional defensive steps to protect the application from harm ++** including: ++**
      ++**
    • Prohibit the use of SQL functions inside triggers, views, ++** CHECK constraints, DEFAULT clauses, expression indexes, ++** partial indexes, or generated columns ++** unless those functions are tagged with [SQLITE_INNOCUOUS]. ++**
    • Prohibit the use of virtual tables inside of triggers or views ++** unless those virtual tables are tagged with [SQLITE_VTAB_INNOCUOUS]. ++**
    ++** This setting defaults to "on" for legacy compatibility, however ++** all applications are advised to turn it off if possible. This setting ++** can also be controlled using the [PRAGMA trusted_schema] statement. ++**
    ++** ++** [[SQLITE_DBCONFIG_LEGACY_FILE_FORMAT]] ++**
    SQLITE_DBCONFIG_LEGACY_FILE_FORMAT ++**
    The SQLITE_DBCONFIG_LEGACY_FILE_FORMAT option activates or deactivates ++** the legacy file format flag. When activated, this flag causes all newly ++** created database file to have a schema format version number (the 4-byte ++** integer found at offset 44 into the database header) of 1. This in turn ++** means that the resulting database file will be readable and writable by ++** any SQLite version back to 3.0.0 ([dateof:3.0.0]). Without this setting, ++** newly created databases are generally not understandable by SQLite versions ++** prior to 3.3.0 ([dateof:3.3.0]). As these words are written, there ++** is now scarcely any need to generated database files that are compatible ++** all the way back to version 3.0.0, and so this setting is of little ++** practical use, but is provided so that SQLite can continue to claim the ++** ability to generate new database files that are compatible with version ++** 3.0.0. ++**

    Note that when the SQLITE_DBCONFIG_LEGACY_FILE_FORMAT setting is on, ++** the [VACUUM] command will fail with an obscure error when attempting to ++** process a table with generated columns and a descending index. This is ++** not considered a bug since SQLite versions 3.3.0 and earlier do not support ++** either generated columns or decending indexes. ++**

    ++**
    ++*/ ++#define SQLITE_DBCONFIG_MAINDBNAME 1000 /* const char* */ ++#define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */ ++#define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */ ++#define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */ ++#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */ ++#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */ ++#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE 1006 /* int int* */ ++#define SQLITE_DBCONFIG_ENABLE_QPSG 1007 /* int int* */ ++#define SQLITE_DBCONFIG_TRIGGER_EQP 1008 /* int int* */ ++#define SQLITE_DBCONFIG_RESET_DATABASE 1009 /* int int* */ ++#define SQLITE_DBCONFIG_DEFENSIVE 1010 /* int int* */ ++#define SQLITE_DBCONFIG_WRITABLE_SCHEMA 1011 /* int int* */ ++#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 1012 /* int int* */ ++#define SQLITE_DBCONFIG_DQS_DML 1013 /* int int* */ ++#define SQLITE_DBCONFIG_DQS_DDL 1014 /* int int* */ ++#define SQLITE_DBCONFIG_ENABLE_VIEW 1015 /* int int* */ ++#define SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 1016 /* int int* */ ++#define SQLITE_DBCONFIG_TRUSTED_SCHEMA 1017 /* int int* */ ++#define SQLITE_DBCONFIG_MAX 1017 /* Largest DBCONFIG */ ++ ++/* ++** CAPI3REF: Enable Or Disable Extended Result Codes ++** METHOD: sqlite3 ++** ++** ^The sqlite3_extended_result_codes() routine enables or disables the ++** [extended result codes] feature of SQLite. ^The extended result ++** codes are disabled by default for historical compatibility. ++*/ ++SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff); ++ ++/* ++** CAPI3REF: Last Insert Rowid ++** METHOD: sqlite3 ++** ++** ^Each entry in most SQLite tables (except for [WITHOUT ROWID] tables) ++** has a unique 64-bit signed ++** integer key called the [ROWID | "rowid"]. ^The rowid is always available ++** as an undeclared column named ROWID, OID, or _ROWID_ as long as those ++** names are not also used by explicitly declared columns. ^If ++** the table has a column of type [INTEGER PRIMARY KEY] then that column ++** is another alias for the rowid. ++** ++** ^The sqlite3_last_insert_rowid(D) interface usually returns the [rowid] of ++** the most recent successful [INSERT] into a rowid table or [virtual table] ++** on database connection D. ^Inserts into [WITHOUT ROWID] tables are not ++** recorded. ^If no successful [INSERT]s into rowid tables have ever occurred ++** on the database connection D, then sqlite3_last_insert_rowid(D) returns ++** zero. ++** ++** As well as being set automatically as rows are inserted into database ++** tables, the value returned by this function may be set explicitly by ++** [sqlite3_set_last_insert_rowid()] ++** ++** Some virtual table implementations may INSERT rows into rowid tables as ++** part of committing a transaction (e.g. to flush data accumulated in memory ++** to disk). In this case subsequent calls to this function return the rowid ++** associated with these internal INSERT operations, which leads to ++** unintuitive results. Virtual table implementations that do write to rowid ++** tables in this way can avoid this problem by restoring the original ++** rowid value using [sqlite3_set_last_insert_rowid()] before returning ++** control to the user. ++** ++** ^(If an [INSERT] occurs within a trigger then this routine will ++** return the [rowid] of the inserted row as long as the trigger is ++** running. Once the trigger program ends, the value returned ++** by this routine reverts to what it was before the trigger was fired.)^ ++** ++** ^An [INSERT] that fails due to a constraint violation is not a ++** successful [INSERT] and does not change the value returned by this ++** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, ++** and INSERT OR ABORT make no changes to the return value of this ++** routine when their insertion fails. ^(When INSERT OR REPLACE ++** encounters a constraint violation, it does not fail. The ++** INSERT continues to completion after deleting rows that caused ++** the constraint problem so INSERT OR REPLACE will always change ++** the return value of this interface.)^ ++** ++** ^For the purposes of this routine, an [INSERT] is considered to ++** be successful even if it is subsequently rolled back. ++** ++** This function is accessible to SQL statements via the ++** [last_insert_rowid() SQL function]. ++** ++** If a separate thread performs a new [INSERT] on the same ++** database connection while the [sqlite3_last_insert_rowid()] ++** function is running and thus changes the last insert [rowid], ++** then the value returned by [sqlite3_last_insert_rowid()] is ++** unpredictable and might not equal either the old or the new ++** last insert [rowid]. ++*/ ++SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); ++ ++/* ++** CAPI3REF: Set the Last Insert Rowid value. ++** METHOD: sqlite3 ++** ++** The sqlite3_set_last_insert_rowid(D, R) method allows the application to ++** set the value returned by calling sqlite3_last_insert_rowid(D) to R ++** without inserting a row into the database. ++*/ ++SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64); ++ ++/* ++** CAPI3REF: Count The Number Of Rows Modified ++** METHOD: sqlite3 ++** ++** ^These functions return the number of rows modified, inserted or ++** deleted by the most recently completed INSERT, UPDATE or DELETE ++** statement on the database connection specified by the only parameter. ++** The two functions are identical except for the type of the return value ++** and that if the number of rows modified by the most recent INSERT, UPDATE ++** or DELETE is greater than the maximum value supported by type "int", then ++** the return value of sqlite3_changes() is undefined. ^Executing any other ++** type of SQL statement does not modify the value returned by these functions. ++** ++** ^Only changes made directly by the INSERT, UPDATE or DELETE statement are ++** considered - auxiliary changes caused by [CREATE TRIGGER | triggers], ++** [foreign key actions] or [REPLACE] constraint resolution are not counted. ++** ++** Changes to a view that are intercepted by ++** [INSTEAD OF trigger | INSTEAD OF triggers] are not counted. ^The value ++** returned by sqlite3_changes() immediately after an INSERT, UPDATE or ++** DELETE statement run on a view is always zero. Only changes made to real ++** tables are counted. ++** ++** Things are more complicated if the sqlite3_changes() function is ++** executed while a trigger program is running. This may happen if the ++** program uses the [changes() SQL function], or if some other callback ++** function invokes sqlite3_changes() directly. Essentially: ++** ++**
      ++**
    • ^(Before entering a trigger program the value returned by ++** sqlite3_changes() function is saved. After the trigger program ++** has finished, the original value is restored.)^ ++** ++**
    • ^(Within a trigger program each INSERT, UPDATE and DELETE ++** statement sets the value returned by sqlite3_changes() ++** upon completion as normal. Of course, this value will not include ++** any changes performed by sub-triggers, as the sqlite3_changes() ++** value will be saved and restored after each sub-trigger has run.)^ ++**
    ++** ++** ^This means that if the changes() SQL function (or similar) is used ++** by the first INSERT, UPDATE or DELETE statement within a trigger, it ++** returns the value as set when the calling statement began executing. ++** ^If it is used by the second or subsequent such statement within a trigger ++** program, the value returned reflects the number of rows modified by the ++** previous INSERT, UPDATE or DELETE statement within the same trigger. ++** ++** If a separate thread makes changes on the same database connection ++** while [sqlite3_changes()] is running then the value returned ++** is unpredictable and not meaningful. ++** ++** See also: ++**
      ++**
    • the [sqlite3_total_changes()] interface ++**
    • the [count_changes pragma] ++**
    • the [changes() SQL function] ++**
    • the [data_version pragma] ++**
    ++*/ ++SQLITE_API int sqlite3_changes(sqlite3*); ++SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*); ++ ++/* ++** CAPI3REF: Total Number Of Rows Modified ++** METHOD: sqlite3 ++** ++** ^These functions return the total number of rows inserted, modified or ++** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed ++** since the database connection was opened, including those executed as ++** part of trigger programs. The two functions are identical except for the ++** type of the return value and that if the number of rows modified by the ++** connection exceeds the maximum value supported by type "int", then ++** the return value of sqlite3_total_changes() is undefined. ^Executing ++** any other type of SQL statement does not affect the value returned by ++** sqlite3_total_changes(). ++** ++** ^Changes made as part of [foreign key actions] are included in the ++** count, but those made as part of REPLACE constraint resolution are ++** not. ^Changes to a view that are intercepted by INSTEAD OF triggers ++** are not counted. ++** ++** The [sqlite3_total_changes(D)] interface only reports the number ++** of rows that changed due to SQL statement run against database ++** connection D. Any changes by other database connections are ignored. ++** To detect changes against a database file from other database ++** connections use the [PRAGMA data_version] command or the ++** [SQLITE_FCNTL_DATA_VERSION] [file control]. ++** ++** If a separate thread makes changes on the same database connection ++** while [sqlite3_total_changes()] is running then the value ++** returned is unpredictable and not meaningful. ++** ++** See also: ++**
      ++**
    • the [sqlite3_changes()] interface ++**
    • the [count_changes pragma] ++**
    • the [changes() SQL function] ++**
    • the [data_version pragma] ++**
    • the [SQLITE_FCNTL_DATA_VERSION] [file control] ++**
    ++*/ ++SQLITE_API int sqlite3_total_changes(sqlite3*); ++SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*); ++ ++/* ++** CAPI3REF: Interrupt A Long-Running Query ++** METHOD: sqlite3 ++** ++** ^This function causes any pending database operation to abort and ++** return at its earliest opportunity. This routine is typically ++** called in response to a user action such as pressing "Cancel" ++** or Ctrl-C where the user wants a long query operation to halt ++** immediately. ++** ++** ^It is safe to call this routine from a thread different from the ++** thread that is currently running the database operation. But it ++** is not safe to call this routine with a [database connection] that ++** is closed or might close before sqlite3_interrupt() returns. ++** ++** ^If an SQL operation is very nearly finished at the time when ++** sqlite3_interrupt() is called, then it might not have an opportunity ++** to be interrupted and might continue to completion. ++** ++** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT]. ++** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE ++** that is inside an explicit transaction, then the entire transaction ++** will be rolled back automatically. ++** ++** ^The sqlite3_interrupt(D) call is in effect until all currently running ++** SQL statements on [database connection] D complete. ^Any new SQL statements ++** that are started after the sqlite3_interrupt() call and before the ++** running statement count reaches zero are interrupted as if they had been ++** running prior to the sqlite3_interrupt() call. ^New SQL statements ++** that are started after the running statement count reaches zero are ++** not effected by the sqlite3_interrupt(). ++** ^A call to sqlite3_interrupt(D) that occurs when there are no running ++** SQL statements is a no-op and has no effect on SQL statements ++** that are started after the sqlite3_interrupt() call returns. ++*/ ++SQLITE_API void sqlite3_interrupt(sqlite3*); ++ ++/* ++** CAPI3REF: Determine If An SQL Statement Is Complete ++** ++** These routines are useful during command-line input to determine if the ++** currently entered text seems to form a complete SQL statement or ++** if additional input is needed before sending the text into ++** SQLite for parsing. ^These routines return 1 if the input string ++** appears to be a complete SQL statement. ^A statement is judged to be ++** complete if it ends with a semicolon token and is not a prefix of a ++** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within ++** string literals or quoted identifier names or comments are not ++** independent tokens (they are part of the token in which they are ++** embedded) and thus do not count as a statement terminator. ^Whitespace ++** and comments that follow the final semicolon are ignored. ++** ++** ^These routines return 0 if the statement is incomplete. ^If a ++** memory allocation fails, then SQLITE_NOMEM is returned. ++** ++** ^These routines do not parse the SQL statements thus ++** will not detect syntactically incorrect SQL. ++** ++** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior ++** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked ++** automatically by sqlite3_complete16(). If that initialization fails, ++** then the return value from sqlite3_complete16() will be non-zero ++** regardless of whether or not the input SQL is complete.)^ ++** ++** The input to [sqlite3_complete()] must be a zero-terminated ++** UTF-8 string. ++** ++** The input to [sqlite3_complete16()] must be a zero-terminated ++** UTF-16 string in native byte order. ++*/ ++SQLITE_API int sqlite3_complete(const char *sql); ++SQLITE_API int sqlite3_complete16(const void *sql); ++ ++/* ++** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors ++** KEYWORDS: {busy-handler callback} {busy handler} ++** METHOD: sqlite3 ++** ++** ^The sqlite3_busy_handler(D,X,P) routine sets a callback function X ++** that might be invoked with argument P whenever ++** an attempt is made to access a database table associated with ++** [database connection] D when another thread ++** or process has the table locked. ++** The sqlite3_busy_handler() interface is used to implement ++** [sqlite3_busy_timeout()] and [PRAGMA busy_timeout]. ++** ++** ^If the busy callback is NULL, then [SQLITE_BUSY] ++** is returned immediately upon encountering the lock. ^If the busy callback ++** is not NULL, then the callback might be invoked with two arguments. ++** ++** ^The first argument to the busy handler is a copy of the void* pointer which ++** is the third argument to sqlite3_busy_handler(). ^The second argument to ++** the busy handler callback is the number of times that the busy handler has ++** been invoked previously for the same locking event. ^If the ++** busy callback returns 0, then no additional attempts are made to ++** access the database and [SQLITE_BUSY] is returned ++** to the application. ++** ^If the callback returns non-zero, then another attempt ++** is made to access the database and the cycle repeats. ++** ++** The presence of a busy handler does not guarantee that it will be invoked ++** when there is lock contention. ^If SQLite determines that invoking the busy ++** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY] ++** to the application instead of invoking the ++** busy handler. ++** Consider a scenario where one process is holding a read lock that ++** it is trying to promote to a reserved lock and ++** a second process is holding a reserved lock that it is trying ++** to promote to an exclusive lock. The first process cannot proceed ++** because it is blocked by the second and the second process cannot ++** proceed because it is blocked by the first. If both processes ++** invoke the busy handlers, neither will make any progress. Therefore, ++** SQLite returns [SQLITE_BUSY] for the first process, hoping that this ++** will induce the first process to release its read lock and allow ++** the second process to proceed. ++** ++** ^The default busy callback is NULL. ++** ++** ^(There can only be a single busy handler defined for each ++** [database connection]. Setting a new busy handler clears any ++** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()] ++** or evaluating [PRAGMA busy_timeout=N] will change the ++** busy handler and thus clear any previously set busy handler. ++** ++** The busy callback should not take any actions which modify the ++** database connection that invoked the busy handler. In other words, ++** the busy handler is not reentrant. Any such actions ++** result in undefined behavior. ++** ++** A busy handler must not close the database connection ++** or [prepared statement] that invoked the busy handler. ++*/ ++SQLITE_API int sqlite3_busy_handler(sqlite3*,int(*)(void*,int),void*); ++ ++/* ++** CAPI3REF: Set A Busy Timeout ++** METHOD: sqlite3 ++** ++** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps ++** for a specified amount of time when a table is locked. ^The handler ++** will sleep multiple times until at least "ms" milliseconds of sleeping ++** have accumulated. ^After at least "ms" milliseconds of sleeping, ++** the handler returns 0 which causes [sqlite3_step()] to return ++** [SQLITE_BUSY]. ++** ++** ^Calling this routine with an argument less than or equal to zero ++** turns off all busy handlers. ++** ++** ^(There can only be a single busy handler for a particular ++** [database connection] at any given moment. If another busy handler ++** was defined (using [sqlite3_busy_handler()]) prior to calling ++** this routine, that other busy handler is cleared.)^ ++** ++** See also: [PRAGMA busy_timeout] ++*/ ++SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms); ++ ++/* ++** CAPI3REF: Convenience Routines For Running Queries ++** METHOD: sqlite3 ++** ++** This is a legacy interface that is preserved for backwards compatibility. ++** Use of this interface is not recommended. ++** ++** Definition: A result table is memory data structure created by the ++** [sqlite3_get_table()] interface. A result table records the ++** complete query results from one or more queries. ++** ++** The table conceptually has a number of rows and columns. But ++** these numbers are not part of the result table itself. These ++** numbers are obtained separately. Let N be the number of rows ++** and M be the number of columns. ++** ++** A result table is an array of pointers to zero-terminated UTF-8 strings. ++** There are (N+1)*M elements in the array. The first M pointers point ++** to zero-terminated strings that contain the names of the columns. ++** The remaining entries all point to query results. NULL values result ++** in NULL pointers. All other values are in their UTF-8 zero-terminated ++** string representation as returned by [sqlite3_column_text()]. ++** ++** A result table might consist of one or more memory allocations. ++** It is not safe to pass a result table directly to [sqlite3_free()]. ++** A result table should be deallocated using [sqlite3_free_table()]. ++** ++** ^(As an example of the result table format, suppose a query result ++** is as follows: ++** ++** 
    ++**        Name        | Age
++**        -----------------------
++**        Alice       | 43
++**        Bob         | 28
++**        Cindy       | 21
++**
    ++** ++** There are two columns (M==2) and three rows (N==3). Thus the ++** result table has 8 entries. Suppose the result table is stored ++** in an array named azResult. Then azResult holds this content: ++** ++** 
    ++**        azResult[0] = "Name";
++**        azResult[1] = "Age";
++**        azResult[2] = "Alice";
++**        azResult[3] = "43";
++**        azResult[4] = "Bob";
++**        azResult[5] = "28";
++**        azResult[6] = "Cindy";
++**        azResult[7] = "21";
++**
    )^ ++** ++** ^The sqlite3_get_table() function evaluates one or more ++** semicolon-separated SQL statements in the zero-terminated UTF-8 ++** string of its 2nd parameter and returns a result table to the ++** pointer given in its 3rd parameter. ++** ++** After the application has finished with the result from sqlite3_get_table(), ++** it must pass the result table pointer to sqlite3_free_table() in order to ++** release the memory that was malloced. Because of the way the ++** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling ++** function must not try to call [sqlite3_free()] directly. Only ++** [sqlite3_free_table()] is able to release the memory properly and safely. ++** ++** The sqlite3_get_table() interface is implemented as a wrapper around ++** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access ++** to any internal data structures of SQLite. It uses only the public ++** interface defined here. As a consequence, errors that occur in the ++** wrapper layer outside of the internal [sqlite3_exec()] call are not ++** reflected in subsequent calls to [sqlite3_errcode()] or ++** [sqlite3_errmsg()]. ++*/ ++SQLITE_API int sqlite3_get_table( ++ sqlite3 *db, /* An open database */ ++ const char *zSql, /* SQL to be evaluated */ ++ char ***pazResult, /* Results of the query */ ++ int *pnRow, /* Number of result rows written here */ ++ int *pnColumn, /* Number of result columns written here */ ++ char **pzErrmsg /* Error msg written here */ ++); ++SQLITE_API void sqlite3_free_table(char **result); ++ ++/* ++** CAPI3REF: Formatted String Printing Functions ++** ++** These routines are work-alikes of the "printf()" family of functions ++** from the standard C library. ++** These routines understand most of the common formatting options from ++** the standard library printf() ++** plus some additional non-standard formats ([%q], [%Q], [%w], and [%z]). ++** See the [built-in printf()] documentation for details. ++** ++** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their ++** results into memory obtained from [sqlite3_malloc64()]. ++** The strings returned by these two routines should be ++** released by [sqlite3_free()]. ^Both routines return a ++** NULL pointer if [sqlite3_malloc64()] is unable to allocate enough ++** memory to hold the resulting string. ++** ++** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from ++** the standard C library. The result is written into the ++** buffer supplied as the second parameter whose size is given by ++** the first parameter. Note that the order of the ++** first two parameters is reversed from snprintf().)^ This is an ++** historical accident that cannot be fixed without breaking ++** backwards compatibility. ^(Note also that sqlite3_snprintf() ++** returns a pointer to its buffer instead of the number of ++** characters actually written into the buffer.)^ We admit that ++** the number of characters written would be a more useful return ++** value but we cannot change the implementation of sqlite3_snprintf() ++** now without breaking compatibility. ++** ++** ^As long as the buffer size is greater than zero, sqlite3_snprintf() ++** guarantees that the buffer is always zero-terminated. ^The first ++** parameter "n" is the total size of the buffer, including space for ++** the zero terminator. So the longest string that can be completely ++** written will be n-1 characters. ++** ++** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf(). ++** ++** See also: [built-in printf()], [printf() SQL function] ++*/ ++SQLITE_API char *sqlite3_mprintf(const char*,...); ++SQLITE_API char *sqlite3_vmprintf(const char*, va_list); ++SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...); ++SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list); ++ ++/* ++** CAPI3REF: Memory Allocation Subsystem ++** ++** The SQLite core uses these three routines for all of its own ++** internal memory allocation needs. "Core" in the previous sentence ++** does not include operating-system specific [VFS] implementation. The ++** Windows VFS uses native malloc() and free() for some operations. ++** ++** ^The sqlite3_malloc() routine returns a pointer to a block ++** of memory at least N bytes in length, where N is the parameter. ++** ^If sqlite3_malloc() is unable to obtain sufficient free ++** memory, it returns a NULL pointer. ^If the parameter N to ++** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns ++** a NULL pointer. ++** ++** ^The sqlite3_malloc64(N) routine works just like ++** sqlite3_malloc(N) except that N is an unsigned 64-bit integer instead ++** of a signed 32-bit integer. ++** ++** ^Calling sqlite3_free() with a pointer previously returned ++** by sqlite3_malloc() or sqlite3_realloc() releases that memory so ++** that it might be reused. ^The sqlite3_free() routine is ++** a no-op if is called with a NULL pointer. Passing a NULL pointer ++** to sqlite3_free() is harmless. After being freed, memory ++** should neither be read nor written. Even reading previously freed ++** memory might result in a segmentation fault or other severe error. ++** Memory corruption, a segmentation fault, or other severe error ++** might result if sqlite3_free() is called with a non-NULL pointer that ++** was not obtained from sqlite3_malloc() or sqlite3_realloc(). ++** ++** ^The sqlite3_realloc(X,N) interface attempts to resize a ++** prior memory allocation X to be at least N bytes. ++** ^If the X parameter to sqlite3_realloc(X,N) ++** is a NULL pointer then its behavior is identical to calling ++** sqlite3_malloc(N). ++** ^If the N parameter to sqlite3_realloc(X,N) is zero or ++** negative then the behavior is exactly the same as calling ++** sqlite3_free(X). ++** ^sqlite3_realloc(X,N) returns a pointer to a memory allocation ++** of at least N bytes in size or NULL if insufficient memory is available. ++** ^If M is the size of the prior allocation, then min(N,M) bytes ++** of the prior allocation are copied into the beginning of buffer returned ++** by sqlite3_realloc(X,N) and the prior allocation is freed. ++** ^If sqlite3_realloc(X,N) returns NULL and N is positive, then the ++** prior allocation is not freed. ++** ++** ^The sqlite3_realloc64(X,N) interfaces works the same as ++** sqlite3_realloc(X,N) except that N is a 64-bit unsigned integer instead ++** of a 32-bit signed integer. ++** ++** ^If X is a memory allocation previously obtained from sqlite3_malloc(), ++** sqlite3_malloc64(), sqlite3_realloc(), or sqlite3_realloc64(), then ++** sqlite3_msize(X) returns the size of that memory allocation in bytes. ++** ^The value returned by sqlite3_msize(X) might be larger than the number ++** of bytes requested when X was allocated. ^If X is a NULL pointer then ++** sqlite3_msize(X) returns zero. If X points to something that is not ++** the beginning of memory allocation, or if it points to a formerly ++** valid memory allocation that has now been freed, then the behavior ++** of sqlite3_msize(X) is undefined and possibly harmful. ++** ++** ^The memory returned by sqlite3_malloc(), sqlite3_realloc(), ++** sqlite3_malloc64(), and sqlite3_realloc64() ++** is always aligned to at least an 8 byte boundary, or to a ++** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time ++** option is used. ++** ++** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()] ++** must be either NULL or else pointers obtained from a prior ++** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have ++** not yet been released. ++** ++** The application must not read or write any part of ++** a block of memory after it has been released using ++** [sqlite3_free()] or [sqlite3_realloc()]. ++*/ ++SQLITE_API void *sqlite3_malloc(int); ++SQLITE_API void *sqlite3_malloc64(sqlite3_uint64); ++SQLITE_API void *sqlite3_realloc(void*, int); ++SQLITE_API void *sqlite3_realloc64(void*, sqlite3_uint64); ++SQLITE_API void sqlite3_free(void*); ++SQLITE_API sqlite3_uint64 sqlite3_msize(void*); ++ ++/* ++** CAPI3REF: Memory Allocator Statistics ++** ++** SQLite provides these two interfaces for reporting on the status ++** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()] ++** routines, which form the built-in memory allocation subsystem. ++** ++** ^The [sqlite3_memory_used()] routine returns the number of bytes ++** of memory currently outstanding (malloced but not freed). ++** ^The [sqlite3_memory_highwater()] routine returns the maximum ++** value of [sqlite3_memory_used()] since the high-water mark ++** was last reset. ^The values returned by [sqlite3_memory_used()] and ++** [sqlite3_memory_highwater()] include any overhead ++** added by SQLite in its implementation of [sqlite3_malloc()], ++** but not overhead added by the any underlying system library ++** routines that [sqlite3_malloc()] may call. ++** ++** ^The memory high-water mark is reset to the current value of ++** [sqlite3_memory_used()] if and only if the parameter to ++** [sqlite3_memory_highwater()] is true. ^The value returned ++** by [sqlite3_memory_highwater(1)] is the high-water mark ++** prior to the reset. ++*/ ++SQLITE_API sqlite3_int64 sqlite3_memory_used(void); ++SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag); ++ ++/* ++** CAPI3REF: Pseudo-Random Number Generator ++** ++** SQLite contains a high-quality pseudo-random number generator (PRNG) used to ++** select random [ROWID | ROWIDs] when inserting new records into a table that ++** already uses the largest possible [ROWID]. The PRNG is also used for ++** the built-in random() and randomblob() SQL functions. This interface allows ++** applications to access the same PRNG for other purposes. ++** ++** ^A call to this routine stores N bytes of randomness into buffer P. ++** ^The P parameter can be a NULL pointer. ++** ++** ^If this routine has not been previously called or if the previous ++** call had N less than one or a NULL pointer for P, then the PRNG is ++** seeded using randomness obtained from the xRandomness method of ++** the default [sqlite3_vfs] object. ++** ^If the previous call to this routine had an N of 1 or more and a ++** non-NULL P then the pseudo-randomness is generated ++** internally and without recourse to the [sqlite3_vfs] xRandomness ++** method. ++*/ ++SQLITE_API void sqlite3_randomness(int N, void *P); ++ ++/* ++** CAPI3REF: Compile-Time Authorization Callbacks ++** METHOD: sqlite3 ++** KEYWORDS: {authorizer callback} ++** ++** ^This routine registers an authorizer callback with a particular ++** [database connection], supplied in the first argument. ++** ^The authorizer callback is invoked as SQL statements are being compiled ++** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], ++** [sqlite3_prepare_v3()], [sqlite3_prepare16()], [sqlite3_prepare16_v2()], ++** and [sqlite3_prepare16_v3()]. ^At various ++** points during the compilation process, as logic is being created ++** to perform various actions, the authorizer callback is invoked to ++** see if those actions are allowed. ^The authorizer callback should ++** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the ++** specific action but allow the SQL statement to continue to be ++** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be ++** rejected with an error. ^If the authorizer callback returns ++** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY] ++** then the [sqlite3_prepare_v2()] or equivalent call that triggered ++** the authorizer will fail with an error message. ++** ++** When the callback returns [SQLITE_OK], that means the operation ++** requested is ok. ^When the callback returns [SQLITE_DENY], the ++** [sqlite3_prepare_v2()] or equivalent call that triggered the ++** authorizer will fail with an error message explaining that ++** access is denied. ++** ++** ^The first parameter to the authorizer callback is a copy of the third ++** parameter to the sqlite3_set_authorizer() interface. ^The second parameter ++** to the callback is an integer [SQLITE_COPY | action code] that specifies ++** the particular action to be authorized. ^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. ++** Applications must always be prepared to encounter a NULL pointer in any ++** of the third through the sixth parameters of the authorization callback. ++** ++** ^If the action code is [SQLITE_READ] ++** and the callback returns [SQLITE_IGNORE] then the ++** [prepared statement] statement is constructed to substitute ++** a NULL value in place of the table column that would have ++** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE] ++** return can be used to deny an untrusted user access to individual ++** columns of a table. ++** ^When a table is referenced by a [SELECT] but no column values are ++** extracted from that table (for example in a query like ++** "SELECT count(*) FROM tab") then the [SQLITE_READ] authorizer callback ++** is invoked once for that table with a column name that is an empty string. ++** ^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. ++** ++** An authorizer is used when [sqlite3_prepare | preparing] ++** SQL statements from an untrusted source, to ensure that the SQL statements ++** do not try to access data they are not allowed to see, or that they do not ++** try to execute malicious statements that damage the database. For ++** example, an application may allow a user to enter arbitrary ++** SQL queries for evaluation by a database. But the application does ++** not want the user to be able to make arbitrary changes to the ++** database. An authorizer could then be put in place while the ++** user-entered SQL is being [sqlite3_prepare | prepared] that ++** disallows everything except [SELECT] statements. ++** ++** Applications that need to process SQL from untrusted sources ++** might also consider lowering resource limits using [sqlite3_limit()] ++** and limiting database size using the [max_page_count] [PRAGMA] ++** in addition to using an authorizer. ++** ++** ^(Only a single authorizer can be in place on a database connection ++** at a time. Each call to sqlite3_set_authorizer overrides the ++** previous call.)^ ^Disable the authorizer by installing a NULL callback. ++** The authorizer is disabled by default. ++** ++** The authorizer callback must not do anything that will modify ++** the database connection that invoked the authorizer callback. ++** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their ++** database connections for the meaning of "modify" in this paragraph. ++** ++** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the ++** statement might be re-prepared during [sqlite3_step()] due to a ++** schema change. Hence, the application should ensure that the ++** correct authorizer callback remains in place during the [sqlite3_step()]. ++** ++** ^Note that the authorizer callback is invoked only during ++** [sqlite3_prepare()] or its variants. Authorization is not ++** performed during statement evaluation in [sqlite3_step()], unless ++** as stated in the previous paragraph, sqlite3_step() invokes ++** sqlite3_prepare_v2() to reprepare a statement after a schema change. ++*/ ++SQLITE_API int sqlite3_set_authorizer( ++ sqlite3*, ++ int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), ++ void *pUserData ++); ++ ++/* ++** CAPI3REF: Authorizer Return Codes ++** ++** The [sqlite3_set_authorizer | authorizer callback function] must ++** return either [SQLITE_OK] or one of these two constants in order ++** to signal SQLite whether or not the action is permitted. See the ++** [sqlite3_set_authorizer | authorizer documentation] for additional ++** information. ++** ++** Note that SQLITE_IGNORE is also used as a [conflict resolution mode] ++** returned from the [sqlite3_vtab_on_conflict()] interface. ++*/ ++#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ ++#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ ++ ++/* ++** CAPI3REF: Authorizer Action Codes ++** ++** The [sqlite3_set_authorizer()] interface registers a callback function ++** that is invoked to authorize certain SQL statement actions. The ++** second parameter to the callback is an integer code that specifies ++** what action is being authorized. These are the integer action codes that ++** the authorizer callback may be passed. ++** ++** These action code values signify what kind of operation is to be ++** authorized. The 3rd and 4th parameters to the authorization ++** callback function will be parameters or NULL depending on which of these ++** codes is used as the second parameter. ^(The 5th parameter to the ++** authorizer callback is the name of the database ("main", "temp", ++** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback ++** is the name of the inner-most trigger or view that is responsible for ++** the access attempt or NULL if this access attempt is directly from ++** top-level SQL code. ++*/ ++/******************************************* 3rd ************ 4th ***********/ ++#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ ++#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ ++#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ ++#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ ++#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ ++#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ ++#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ ++#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ ++#define SQLITE_DELETE 9 /* Table Name NULL */ ++#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ ++#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ ++#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ ++#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ ++#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ ++#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ ++#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ ++#define SQLITE_DROP_VIEW 17 /* View Name NULL */ ++#define SQLITE_INSERT 18 /* Table Name NULL */ ++#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ ++#define SQLITE_READ 20 /* Table Name Column Name */ ++#define SQLITE_SELECT 21 /* NULL NULL */ ++#define SQLITE_TRANSACTION 22 /* Operation NULL */ ++#define SQLITE_UPDATE 23 /* Table Name Column Name */ ++#define SQLITE_ATTACH 24 /* Filename NULL */ ++#define SQLITE_DETACH 25 /* Database Name NULL */ ++#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ ++#define SQLITE_REINDEX 27 /* Index Name NULL */ ++#define SQLITE_ANALYZE 28 /* Table Name NULL */ ++#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ ++#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ ++#define SQLITE_FUNCTION 31 /* NULL Function Name */ ++#define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */ ++#define SQLITE_COPY 0 /* No longer used */ ++#define SQLITE_RECURSIVE 33 /* NULL NULL */ ++ ++/* ++** CAPI3REF: Tracing And Profiling Functions ++** METHOD: sqlite3 ++** ++** These routines are deprecated. Use the [sqlite3_trace_v2()] interface ++** instead of the routines described here. ++** ++** These routines register callback functions that can be used for ++** tracing and profiling the execution of SQL statements. ++** ++** ^The callback function registered by sqlite3_trace() is invoked at ++** various times when an SQL statement is being run by [sqlite3_step()]. ++** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the ++** SQL statement text as the statement first begins executing. ++** ^(Additional sqlite3_trace() callbacks might occur ++** as each triggered subprogram is entered. The callbacks for triggers ++** contain a UTF-8 SQL comment that identifies the trigger.)^ ++** ++** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit ++** the length of [bound parameter] expansion in the output of sqlite3_trace(). ++** ++** ^The callback function registered by sqlite3_profile() is invoked ++** as each SQL statement finishes. ^The profile callback contains ++** the original statement text and an estimate of wall-clock time ++** of how long that statement took to run. ^The profile callback ++** time is in units of nanoseconds, however the current implementation ++** is only capable of millisecond resolution so the six least significant ++** digits in the time are meaningless. Future versions of SQLite ++** might provide greater resolution on the profiler callback. Invoking ++** either [sqlite3_trace()] or [sqlite3_trace_v2()] will cancel the ++** profile callback. ++*/ ++SQLITE_API SQLITE_DEPRECATED void *sqlite3_trace(sqlite3*, ++ void(*xTrace)(void*,const char*), void*); ++SQLITE_API SQLITE_DEPRECATED void *sqlite3_profile(sqlite3*, ++ void(*xProfile)(void*,const char*,sqlite3_uint64), void*); ++ ++/* ++** CAPI3REF: SQL Trace Event Codes ++** KEYWORDS: SQLITE_TRACE ++** ++** These constants identify classes of events that can be monitored ++** using the [sqlite3_trace_v2()] tracing logic. The M argument ++** to [sqlite3_trace_v2(D,M,X,P)] is an OR-ed combination of one or more of ++** the following constants. ^The first argument to the trace callback ++** is one of the following constants. ++** ++** New tracing constants may be added in future releases. ++** ++** ^A trace callback has four arguments: xCallback(T,C,P,X). ++** ^The T argument is one of the integer type codes above. ++** ^The C argument is a copy of the context pointer passed in as the ++** fourth argument to [sqlite3_trace_v2()]. ++** The P and X arguments are pointers whose meanings depend on T. ++** ++**
    ++** [[SQLITE_TRACE_STMT]]
    SQLITE_TRACE_STMT
    ++**
    ^An SQLITE_TRACE_STMT callback is invoked when a prepared statement ++** first begins running and possibly at other times during the ++** execution of the prepared statement, such as at the start of each ++** trigger subprogram. ^The P argument is a pointer to the ++** [prepared statement]. ^The X argument is a pointer to a string which ++** is the unexpanded SQL text of the prepared statement or an SQL comment ++** that indicates the invocation of a trigger. ^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. ++** ++** [[SQLITE_TRACE_PROFILE]]
    SQLITE_TRACE_PROFILE
    ++**
    ^An SQLITE_TRACE_PROFILE callback provides approximately the same ++** information as is provided by the [sqlite3_profile()] callback. ++** ^The P argument is a pointer to the [prepared statement] and the ++** X argument points to a 64-bit integer which is the estimated of ++** the number of nanosecond that the prepared statement took to run. ++** ^The SQLITE_TRACE_PROFILE callback is invoked when the statement finishes. ++** ++** [[SQLITE_TRACE_ROW]]
    SQLITE_TRACE_ROW
    ++**
    ^An SQLITE_TRACE_ROW callback is invoked whenever a prepared ++** statement generates a single row of result. ++** ^The P argument is a pointer to the [prepared statement] and the ++** X argument is unused. ++** ++** [[SQLITE_TRACE_CLOSE]]
    SQLITE_TRACE_CLOSE
    ++**
    ^An SQLITE_TRACE_CLOSE callback is invoked when a database ++** connection closes. ++** ^The P argument is a pointer to the [database connection] object ++** and the X argument is unused. ++**
    ++*/ ++#define SQLITE_TRACE_STMT 0x01 ++#define SQLITE_TRACE_PROFILE 0x02 ++#define SQLITE_TRACE_ROW 0x04 ++#define SQLITE_TRACE_CLOSE 0x08 ++ ++/* ++** CAPI3REF: SQL Trace Hook ++** METHOD: sqlite3 ++** ++** ^The sqlite3_trace_v2(D,M,X,P) interface registers a trace callback ++** function X against [database connection] D, using property mask M ++** and context pointer P. ^If the X callback is ++** NULL or if the M mask is zero, then tracing is disabled. The ++** M argument should be the bitwise OR-ed combination of ++** zero or more [SQLITE_TRACE] constants. ++** ++** ^Each call to either sqlite3_trace() or sqlite3_trace_v2() overrides ++** (cancels) any prior calls to sqlite3_trace() or sqlite3_trace_v2(). ++** ++** ^The X callback is invoked whenever any of the events identified by ++** mask M occur. ^The integer return value from the callback is currently ++** ignored, though this may change in future releases. Callback ++** implementations should return zero to ensure future compatibility. ++** ++** ^A trace callback is invoked with four arguments: callback(T,C,P,X). ++** ^The T argument is one of the [SQLITE_TRACE] ++** constants to indicate why the callback was invoked. ++** ^The C argument is a copy of the context pointer. ++** The P and X arguments are pointers whose meanings depend on T. ++** ++** The sqlite3_trace_v2() interface is intended to replace the legacy ++** interfaces [sqlite3_trace()] and [sqlite3_profile()], both of which ++** are deprecated. ++*/ ++SQLITE_API int sqlite3_trace_v2( ++ sqlite3*, ++ unsigned uMask, ++ int(*xCallback)(unsigned,void*,void*,void*), ++ void *pCtx ++); ++ ++/* ++** CAPI3REF: Query Progress Callbacks ++** METHOD: sqlite3 ++** ++** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback ++** function X to be invoked periodically during long running calls to ++** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for ++** database connection D. An example use for this ++** interface is to keep a GUI updated during a large query. ++** ++** ^The parameter P is passed through as the only parameter to the ++** callback function X. ^The parameter N is the approximate number of ++** [virtual machine instructions] that are evaluated between successive ++** invocations of the callback X. ^If N is less than one then the progress ++** handler is disabled. ++** ++** ^Only a single progress handler may be defined at one time per ++** [database connection]; setting a new progress handler cancels the ++** old one. ^Setting parameter X to NULL disables the progress handler. ++** ^The progress handler is also disabled by setting N to a value less ++** than 1. ++** ++** ^If the progress callback returns non-zero, the operation is ++** interrupted. This feature can be used to implement a ++** "Cancel" button on a GUI progress dialog box. ++** ++** The progress handler callback must not do anything that will modify ++** the database connection that invoked the progress handler. ++** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their ++** database connections for the meaning of "modify" in this paragraph. ++** ++*/ ++SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); ++ ++/* ++** CAPI3REF: Opening A New Database Connection ++** CONSTRUCTOR: sqlite3 ++** ++** ^These routines open an SQLite database file as specified by the ++** filename argument. ^The filename argument is interpreted as UTF-8 for ++** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte ++** order for sqlite3_open16(). ^(A [database connection] handle is usually ++** returned in *ppDb, even if an error occurs. The only exception is that ++** if SQLite is unable to allocate memory to hold the [sqlite3] object, ++** a NULL will be written into *ppDb instead of a pointer to the [sqlite3] ++** object.)^ ^(If the database is opened (and/or created) successfully, then ++** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The ++** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain ++** an English language description of the error following a failure of any ++** of the sqlite3_open() routines. ++** ++** ^The default encoding will be UTF-8 for databases created using ++** sqlite3_open() or sqlite3_open_v2(). ^The default encoding for databases ++** created using sqlite3_open16() will be UTF-16 in the native byte order. ++** ++** Whether or not an error occurs when it is opened, resources ++** associated with the [database connection] handle should be released by ++** passing it to [sqlite3_close()] when it is no longer required. ++** ++** The sqlite3_open_v2() interface works like sqlite3_open() ++** except that it accepts two additional parameters for additional control ++** over the new database connection. ^(The flags parameter to ++** sqlite3_open_v2() must include, at a minimum, one of the following ++** three flag combinations:)^ ++** ++**
    ++** ^(
    [SQLITE_OPEN_READONLY]
    ++**
    The database is opened in read-only mode. If the database does not ++** already exist, an error is returned.
    )^ ++** ++** ^(
    [SQLITE_OPEN_READWRITE]
    ++**
    The database is opened for reading and writing if possible, or reading ++** only if the file is write protected by the operating system. In either ++** case the database must already exist, otherwise an error is returned.
    )^ ++** ++** ^(
    [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]
    ++**
    The database is opened for reading and writing, and is created if ++** it does not already exist. This is the behavior that is always used for ++** sqlite3_open() and sqlite3_open16().
    )^ ++**
    ++** ++** In addition to the required flags, the following optional flags are ++** also supported: ++** ++**
    ++** ^(
    [SQLITE_OPEN_URI]
    ++**
    The filename can be interpreted as a URI if this flag is set.
    )^ ++** ++** ^(
    [SQLITE_OPEN_MEMORY]
    ++**
    The database will be opened as an in-memory database. The database ++** is named by the "filename" argument for the purposes of cache-sharing, ++** if shared cache mode is enabled, but the "filename" is otherwise ignored. ++**
    )^ ++** ++** ^(
    [SQLITE_OPEN_NOMUTEX]
    ++**
    The new database connection will use the "multi-thread" ++** [threading mode].)^ This means that separate threads are allowed ++** to use SQLite at the same time, as long as each thread is using ++** a different [database connection]. ++** ++** ^(
    [SQLITE_OPEN_FULLMUTEX]
    ++**
    The new database connection will use the "serialized" ++** [threading mode].)^ This means the multiple threads can safely ++** attempt to use the same database connection at the same time. ++** (Mutexes will block any actual concurrency, but in this mode ++** there is no harm in trying.) ++** ++** ^(
    [SQLITE_OPEN_SHAREDCACHE]
    ++**
    The database is opened [shared cache] enabled, overriding ++** the default shared cache setting provided by ++** [sqlite3_enable_shared_cache()].)^ ++** ++** ^(
    [SQLITE_OPEN_PRIVATECACHE]
    ++**
    The database is opened [shared cache] disabled, overriding ++** the default shared cache setting provided by ++** [sqlite3_enable_shared_cache()].)^ ++** ++** [[OPEN_EXRESCODE]] ^(
    [SQLITE_OPEN_EXRESCODE]
    ++**
    The database connection comes up in "extended result code mode". ++** In other words, the database behaves has if ++** [sqlite3_extended_result_codes(db,1)] where called on the database ++** connection as soon as the connection is created. In addition to setting ++** the extended result code mode, this flag also causes [sqlite3_open_v2()] ++** to return an extended result code.
    ++** ++** [[OPEN_NOFOLLOW]] ^(
    [SQLITE_OPEN_NOFOLLOW]
    ++**
    The database filename is not allowed to be a symbolic link
    ++**
    )^ ++** ++** If the 3rd parameter to sqlite3_open_v2() is not one of the ++** required combinations shown above optionally combined with other ++** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits] ++** then the behavior is undefined. Historic versions of SQLite ++** have silently ignored surplus bits in the flags parameter to ++** sqlite3_open_v2(), however that behavior might not be carried through ++** into future versions of SQLite and so applications should not rely ++** upon it. Note in particular that the SQLITE_OPEN_EXCLUSIVE flag is a no-op ++** for sqlite3_open_v2(). The SQLITE_OPEN_EXCLUSIVE does *not* cause ++** the open to fail if the database already exists. The SQLITE_OPEN_EXCLUSIVE ++** flag is intended for use by the [sqlite3_vfs|VFS interface] only, and not ++** by sqlite3_open_v2(). ++** ++** ^The fourth parameter to sqlite3_open_v2() is the name of the ++** [sqlite3_vfs] object that defines the operating system interface that ++** the new database connection should use. ^If the fourth parameter is ++** a NULL pointer then the default [sqlite3_vfs] object is used. ++** ++** ^If the filename is ":memory:", then a private, temporary in-memory database ++** is created for the connection. ^This in-memory database will vanish when ++** the database connection is closed. Future versions of SQLite might ++** make use of additional special filenames that begin with the ":" character. ++** It is recommended that when a database filename actually does begin with ++** a ":" character you should prefix the filename with a pathname such as ++** "./" to avoid ambiguity. ++** ++** ^If the filename is an empty string, then a private, temporary ++** on-disk database will be created. ^This private database will be ++** automatically deleted as soon as the database connection is closed. ++** ++** [[URI filenames in sqlite3_open()]]

    URI Filenames

    ++** ++** ^If [URI filename] interpretation is enabled, and the filename argument ++** begins with "file:", then the filename is interpreted as a URI. ^URI ++** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is ++** set in the third argument to sqlite3_open_v2(), or if it has ++** been enabled globally using the [SQLITE_CONFIG_URI] option with the ++** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option. ++** URI filename interpretation is turned off ++** by default, but future releases of SQLite might enable URI filename ++** interpretation by default. See "[URI filenames]" for additional ++** information. ++** ++** URI filenames are parsed according to RFC 3986. ^If the URI contains an ++** authority, then it must be either an empty string or the string ++** "localhost". ^If the authority is not an empty string or "localhost", an ++** error is returned to the caller. ^The fragment component of a URI, if ++** present, is ignored. ++** ++** ^SQLite uses the path component of the URI as the name of the disk file ++** which contains the database. ^If the path begins with a '/' character, ++** then it is interpreted as an absolute path. ^If the path does not begin ++** with a '/' (meaning that the authority section is omitted from the URI) ++** then the path is interpreted as a relative path. ++** ^(On windows, the first component of an absolute path ++** is a drive specification (e.g. "C:").)^ ++** ++** [[core URI query parameters]] ++** The query component of a URI may contain parameters that are interpreted ++** either by SQLite itself, or by a [VFS | custom VFS implementation]. ++** SQLite and its built-in [VFSes] interpret the ++** following query parameters: ++** ++**
      ++**
    • vfs: ^The "vfs" parameter may be used to specify the name of ++** a VFS object that provides the operating system interface that should ++** be used to access the database file on disk. ^If this option is set to ++** an empty string the default VFS object is used. ^Specifying an unknown ++** VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is ++** present, then the VFS specified by the option takes precedence over ++** the value passed as the fourth parameter to sqlite3_open_v2(). ++** ++**
    • mode: ^(The mode parameter may be set to either "ro", "rw", ++** "rwc", or "memory". Attempting to set it to any other value is ++** an error)^. ++** ^If "ro" is specified, then the database is opened for read-only ++** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the ++** third argument to sqlite3_open_v2(). ^If the mode option is set to ++** "rw", then the database is opened for read-write (but not create) ++** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had ++** been set. ^Value "rwc" is equivalent to setting both ++** SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. ^If the mode option is ++** set to "memory" then a pure [in-memory database] that never reads ++** or writes from disk is used. ^It is an error to specify a value for ++** the mode parameter that is less restrictive than that specified by ++** the flags passed in the third parameter to sqlite3_open_v2(). ++** ++**
    • cache: ^The cache parameter may be set to either "shared" or ++** "private". ^Setting it to "shared" is equivalent to setting the ++** SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to ++** sqlite3_open_v2(). ^Setting the cache parameter to "private" is ++** equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit. ++** ^If sqlite3_open_v2() is used and the "cache" parameter is present in ++** a URI filename, its value overrides any behavior requested by setting ++** SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag. ++** ++**
    • psow: ^The psow parameter indicates whether or not the ++** [powersafe overwrite] property does or does not apply to the ++** storage media on which the database file resides. ++** ++**
    • nolock: ^The nolock parameter is a boolean query parameter ++** which if set disables file locking in rollback journal modes. This ++** is useful for accessing a database on a filesystem that does not ++** support locking. Caution: Database corruption might result if two ++** or more processes write to the same database and any one of those ++** processes uses nolock=1. ++** ++**
    • immutable: ^The immutable parameter is a boolean query ++** parameter that indicates that the database file is stored on ++** read-only media. ^When immutable is set, SQLite assumes that the ++** database file cannot be changed, even by a process with higher ++** privilege, and so the database is opened read-only and all locking ++** and change detection is disabled. Caution: Setting the immutable ++** property on a database file that does in fact change can result ++** in incorrect query results and/or [SQLITE_CORRUPT] errors. ++** See also: [SQLITE_IOCAP_IMMUTABLE]. ++** ++**
    ++** ++** ^Specifying an unknown parameter in the query component of a URI is not an ++** error. Future versions of SQLite might understand additional query ++** parameters. See "[query parameters with special meaning to SQLite]" for ++** additional information. ++** ++** [[URI filename examples]]

    URI filename examples

    ++** ++** ++**
    URI filenames Results ++**
    file:data.db ++** Open the file "data.db" in the current directory. ++**
    file:/home/fred/data.db
    ++** file:///home/fred/data.db
    ++** file://localhost/home/fred/data.db
    		++** Open the database file "/home/fred/data.db". ++**
    file://darkstar/home/fred/data.db ++** An error. "darkstar" is not a recognized authority. ++**
    ++** file:///C:/Documents%20and%20Settings/fred/Desktop/data.db ++** Windows only: Open the file "data.db" on fred's desktop on drive ++** C:. Note that the %20 escaping in this example is not strictly ++** necessary - space characters can be used literally ++** in URI filenames. ++**
    file:data.db?mode=ro&cache=private ++** Open file "data.db" in the current directory for read-only access. ++** Regardless of whether or not shared-cache mode is enabled by ++** default, use a private cache. ++**
    file:/home/fred/data.db?vfs=unix-dotfile ++** Open file "/home/fred/data.db". Use the special VFS "unix-dotfile" ++** that uses dot-files in place of posix advisory locking. ++**
    file:data.db?mode=readonly ++** An error. "readonly" is not a valid option for the "mode" parameter. ++** Use "ro" instead: "file:data.db?mode=ro". ++**
    ++** ++** ^URI hexadecimal escape sequences (%HH) are supported within the path and ++** query components of a URI. A hexadecimal escape sequence consists of a ++** percent sign - "%" - followed by exactly two hexadecimal digits ++** specifying an octet value. ^Before the path or query components of a ++** URI filename are interpreted, they are encoded using UTF-8 and all ++** hexadecimal escape sequences replaced by a single byte containing the ++** corresponding octet. If this process generates an invalid UTF-8 encoding, ++** the results are undefined. ++** ++** Note to Windows users: The encoding used for the filename argument ++** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever ++** codepage is currently defined. Filenames containing international ++** characters must be converted to UTF-8 prior to passing them into ++** sqlite3_open() or sqlite3_open_v2(). ++** ++** 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. ++** ++** See also: [sqlite3_temp_directory] ++*/ ++SQLITE_API int sqlite3_open( ++ const char *filename, /* Database filename (UTF-8) */ ++ sqlite3 **ppDb /* OUT: SQLite db handle */ ++); ++SQLITE_API int sqlite3_open16( ++ const void *filename, /* Database filename (UTF-16) */ ++ sqlite3 **ppDb /* OUT: SQLite db handle */ ++); ++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 */ ++); ++ ++/* ++** CAPI3REF: Obtain Values For URI Parameters ++** ++** These are utility routines, useful to [VFS|custom VFS implementations], ++** that check if a database file was a URI that contained a specific query ++** parameter, and if so obtains the value of that query parameter. ++** ++** The first parameter to these interfaces (hereafter referred to ++** as F) must be one of: ++**
      ++**
    • 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 freed by the application ++** by passing it to [sqlite3_free()]. ++** ++** ^The sqlite3_normalized_sql() interface is only available if ++** the [SQLITE_ENABLE_NORMALIZE] compile-time option is defined. ++*/ ++SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt); ++SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt); ++#ifdef SQLITE_ENABLE_NORMALIZE ++SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); ++#endif ++ ++/* ++** 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. ++** ++** ^This routine returns false if there is any possibility that the ++** statement might change the database file. ^A false return does ++** not guarantee that the statement will change the database file. ++** ^For example, an UPDATE statement might have a WHERE clause that ++** makes it a no-op, but the sqlite3_stmt_readonly() result would still ++** be false. ^Similarly, a CREATE TABLE IF NOT EXISTS statement is a ++** read-only no-op if the table already exists, but ++** sqlite3_stmt_readonly() still returns false for such a statement. ++*/ ++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 controls ++** or indicates the lifetime of the object referenced by the third parameter. ++** These three options exist: ++** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished ++** with it may be passed. ^It 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. ++** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that ++** the application remains responsible for disposing of the object. ^In this ++** case, the object and the provided pointer to it must remain valid until ++** either the prepared statement is finalized or the same SQL parameter is ++** bound to something else, whichever occurs sooner. ++** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the ++** object is to be copied prior to the return from sqlite3_bind_*(). ^The ++** object and pointer to it must remain valid until then. ^SQLite will then ++** manage the lifetime of its private copy. ++** ++** ^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_HAS_CODEC ++/* ++** Specify the key for an encrypted database. This routine should be ++** called right after sqlite3_open(). ++** ++** The code to implement this API is not available in the public release ++** of SQLite. ++*/ ++SQLITE_API int sqlite3_key( ++ sqlite3 *db, /* Database to be rekeyed */ ++ const void *pKey, int nKey /* The key */ ++); ++SQLITE_API int sqlite3_key_v2( ++ sqlite3 *db, /* Database to be rekeyed */ ++ const char *zDbName, /* Name of the database */ ++ const void *pKey, int nKey /* The key */ ++); ++ ++/* ++** Change the key on an open database. If the current database is not ++** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the ++** database is decrypted. ++** ++** The code to implement this API is not available in the public release ++** of SQLite. ++*/ ++SQLITE_API int sqlite3_rekey( ++ sqlite3 *db, /* Database to be rekeyed */ ++ const void *pKey, int nKey /* The new key */ ++); ++SQLITE_API int sqlite3_rekey_v2( ++ sqlite3 *db, /* Database to be rekeyed */ ++ const char *zDbName, /* Name of the database */ ++ const void *pKey, int nKey /* The new key */ ++); ++ ++#endif ++ ++#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 SQLITE_EXTERN 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 SQLITE_EXTERN 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: Autovacuum Compaction Amount Callback ++** METHOD: sqlite3 ++** ++** ^The sqlite3_autovacuum_pages(D,C,P,X) interface registers a callback ++** function C that is invoked prior to each autovacuum of the database ++** file. ^The callback is passed a copy of the generic data pointer (P), ++** the schema-name of the attached database that is being autovacuumed, ++** the the size of the database file in pages, the number of free pages, ++** and the number of bytes per page, respectively. The callback should ++** return the number of free pages that should be removed by the ++** autovacuum. ^If the callback returns zero, then no autovacuum happens. ++** ^If the value returned is greater than or equal to the number of ++** free pages, then a complete autovacuum happens. ++** ++**

    ^If there are multiple ATTACH-ed database files that are being ++** modified as part of a transaction commit, then the autovacuum pages ++** callback is invoked separately for each file. ++** ++**

    The callback is not reentrant. The callback function should ++** not attempt to invoke any other SQLite interface. If it does, bad ++** things may happen, including segmentation faults and corrupt database ++** files. The callback function should be a simple function that ++** does some arithmetic on its input parameters and returns a result. ++** ++** ^The X parameter to sqlite3_autovacuum_pages(D,C,P,X) is an optional ++** destructor for the P parameter. ^If X is not NULL, then X(P) is ++** invoked whenever the database connection closes or when the callback ++** is overwritten by another invocation of sqlite3_autovacuum_pages(). ++** ++**

    ^There is only one autovacuum pages callback per database connection. ++** ^Each call to the sqlite3_autovacuum_pages() interface overrides all ++** previous invocations for that database connection. ^If the callback ++** argument (C) to sqlite3_autovacuum_pages(D,C,P,X) is a NULL pointer, ++** then the autovacuum steps callback is cancelled. The return value ++** from sqlite3_autovacuum_pages() is normally SQLITE_OK, but might ++** be some other error code if something goes wrong. The current ++** implementation will only return SQLITE_OK or SQLITE_MISUSE, but other ++** return codes might be added in future releases. ++** ++**

    If no autovacuum pages callback is specified (the usual case) or ++** a NULL pointer is provided for the callback, ++** then the default behavior is to vacuum all free pages. So, in other ++** words, the default behavior is the same as if the callback function ++** were something like this: ++** ++** 

    ++**     unsigned int demonstration_autovac_pages_callback(
++**       void *pClientData,
++**       const char *zSchema,
++**       unsigned int nDbPage,
++**       unsigned int nFreePage,
++**       unsigned int nBytePerPage
++**     ){
++**       return nFreePage;
++**     }
++**
    ++*/ ++SQLITE_API int sqlite3_autovacuum_pages( ++ sqlite3 *db, ++ unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), ++ 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_TRACEFLAGS 31 ++#define SQLITE_TESTCTRL_TUNE 32 ++#define SQLITE_TESTCTRL_LAST 32 /* 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. ^The return value is ++** a copy of the third parameter from the previous call, if any, or 0. ++** ^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. ++** ++** When the [sqlite3_blob_write()] API is used to update a blob column, ++** the pre-update hook is invoked with SQLITE_DELETE. This is because the ++** in this case the new values are not available. In this case, when a ++** callback made with op==SQLITE_DELETE is actuall a write using the ++** sqlite3_blob_write() API, the [sqlite3_preupdate_blobwrite()] returns ++** the index of the column being written. In other cases, where the ++** pre-update hook is being invoked for some other reason, including a ++** regular DELETE, sqlite3_preupdate_blobwrite() returns -1. ++** ++** 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 **); ++SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *); ++#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 omitted if SQLite is compiled with the ++** [SQLITE_OMIT_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. ++** ++** It is not possible to deserialized into the TEMP database. If the ++** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the ++** function returns SQLITE_ERROR. ++** ++** 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 omitted if SQLite is compiled with the ++** [SQLITE_OMIT_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 ++ ++#ifdef __cplusplus ++} /* 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_ ++ ++ ++#ifdef __cplusplus ++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 */ ++ ++ ++#ifdef __cplusplus ++} /* 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++. ++*/ ++#ifdef __cplusplus ++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); ++ ++/* ++** CAPIREF: Conigure a Session Object ++** METHOD: sqlite3_session ++** ++** This method is used to configure a session object after it has been ++** created. At present the only valid value for the second parameter is ++** [SQLITE_SESSION_OBJCONFIG_SIZE]. ++** ++** Arguments for sqlite3session_object_config() ++** ++** The following values may passed as the the 4th parameter to ++** sqlite3session_object_config(). ++** ++**
    SQLITE_SESSION_OBJCONFIG_SIZE
    ++** This option is used to set, clear or query the flag that enables ++** the [sqlite3session_changeset_size()] API. Because it imposes some ++** computational overhead, this API is disabled by default. Argument ++** pArg must point to a value of type (int). If the value is initially ++** 0, then the sqlite3session_changeset_size() API is disabled. If it ++** is greater than 0, then the same API is enabled. Or, if the initial ++** value is less than zero, no change is made. In all cases the (int) ++** variable is set to 1 if the sqlite3session_changeset_size() API is ++** enabled following the current call, or 0 otherwise. ++** ++** It is an error (SQLITE_MISUSE) to attempt to modify this setting after ++** the first table has been attached to the session object. ++*/ ++SQLITE_API int sqlite3session_object_config(sqlite3_session*, int op, void *pArg); ++ ++/* ++*/ ++#define SQLITE_SESSION_OBJCONFIG_SIZE 1 ++ ++/* ++** 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: Return An Upper-limit For The Size Of The Changeset ++** METHOD: sqlite3_session ++** ++** By default, this function always returns 0. For it to return ++** a useful result, the sqlite3_session object must have been configured ++** to enable this API using sqlite3session_object_config() with the ++** SQLITE_SESSION_OBJCONFIG_SIZE verb. ++** ++** When enabled, this function returns an upper limit, in bytes, for the size ++** of the changeset that might be produced if sqlite3session_changeset() were ++** called. The final changeset size might be equal to or smaller than the ++** size in bytes returned by this function. ++*/ ++SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession); ++ ++/* ++** 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: Query for the amount of heap memory used by a session object. ++** ++** This API returns the total amount of heap memory in bytes currently ++** used by the session object passed as the only argument. ++*/ ++SQLITE_API sqlite3_int64 sqlite3session_memory_used(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]. ++** ++** Arguments pOp, pnCol and pzTab may not be NULL. Upon return, three ++** outputs are set through these pointers: ++** ++** *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; ++** ++** *pnCol is set to the number of columns in the table affected by the change; and ++** ++** *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 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. ++** ++** 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++. ++*/ ++#ifdef __cplusplus ++} ++#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 ++ ++ ++#ifdef __cplusplus ++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 ++*************************************************************************/ ++ ++#ifdef __cplusplus ++} /* end of the 'extern "C"' block */ ++#endif ++ ++#endif /* _FTS5_H */ ++ ++/******** End of fts5.h *********/ +diff --git a/sqlite/include/sqlite3ext.h b/sqlite/include/sqlite3ext.h +new file mode 100644 +index 0000000..fa13562 +--- /dev/null ++++ b/sqlite/include/sqlite3ext.h +@@ -0,0 +1,679 @@ ++/* ++** 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*); ++ /* Version 3.36.1 and later */ ++ sqlite3_int64 (*changes64)(sqlite3*); ++ sqlite3_int64 (*total_changes64)(sqlite3*); ++ /* Version 3.37.0 and later */ ++ int (*autovacuum_pages)(sqlite3*, ++ unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int), ++ void*, void(*)(void*)); ++}; ++ ++/* ++** 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) || defined(SQLITE3_EXPORT_SYMBOLS)) ++#ifdef SQLITE3_EXPORT_SYMBOLS ++extern const sqlite3_api_routines *sqlite3_export_symbols; ++#define sqlite3_api sqlite3_export_symbols ++#endif ++#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 ++/* Version 3.36.1 and later */ ++#define sqlite3_changes64 sqlite3_api->changes64 ++#define sqlite3_total_changes64 sqlite3_api->total_changes64 ++/* Version 3.37.0 and later */ ++#define sqlite3_autovacuum_pages sqlite3_api->autovacuum_pages ++#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 */ +diff --git a/sqlite/include/sqlite3sym.h b/sqlite/include/sqlite3sym.h +new file mode 100644 +index 0000000..bd459b3 +--- /dev/null ++++ b/sqlite/include/sqlite3sym.h +@@ -0,0 +1,42 @@ ++/* ++ * Copyright (c) 2021 Huawei Device Co., Ltd. ++ * Licensed under the Apache License, Version 2.0 (the "License"); ++ * you may not use this file except in compliance with the License. ++ * You may obtain a copy of the License at ++ * ++ * http://www.apache.org/licenses/LICENSE-2.0 ++ * ++ * Unless required by applicable law or agreed to in writing, software ++ * distributed under the License is distributed on an "AS IS" BASIS, ++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++ * See the License for the specific language governing permissions and ++ * limitations under the License. ++ */ ++ ++#ifndef SQLITE3SYM_H ++#define SQLITE3SYM_H ++ ++#define SQLITE3_EXPORT_SYMBOLS ++#define SQLITE_OMIT_LOAD_EXTENSION ++ ++// We extend the original purpose of the "sqlite3ext.h". ++#include "sqlite3ext.h" ++ ++struct sqlite3_api_routines_hw { ++ int (*initialize)(); ++ int (*config)(int,...); ++ int (*key)(sqlite3*,const void*,int); ++ int (*key_v2)(sqlite3*,const char*,const void*,int); ++ int (*rekey)(sqlite3*,const void*,int); ++ int (*rekey_v2)(sqlite3*,const char*,const void*,int); ++}; ++ ++extern const struct sqlite3_api_routines_hw *sqlite3_export_hw_symbols; ++#define sqlite3_initialize sqlite3_export_hw_symbols->initialize ++#define sqlite3_config sqlite3_export_hw_symbols->config ++#define sqlite3_key sqlite3_export_hw_symbols->key ++#define sqlite3_key_v2 sqlite3_export_hw_symbols->key_v2 ++#define sqlite3_rekey sqlite3_export_hw_symbols->rekey ++#define sqlite3_rekey_v2 sqlite3_export_hw_symbols->rekey_v2 ++ ++#endif +-- +2.27.0 + From e846584aa0783ee1ab6adde34d19b6d619f267aa Mon Sep 17 00:00:00 2001 From: heppen Date: Mon, 28 Aug 2023 16:38:33 +0800 Subject: [PATCH 4/5] establish relational store dependency on boundscheck --- ...onal-store-dependence-on-boundscheck.patch | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 0004-establish-relational-store-dependence-on-boundscheck.patch diff --git a/0004-establish-relational-store-dependence-on-boundscheck.patch b/0004-establish-relational-store-dependence-on-boundscheck.patch new file mode 100644 index 0000000..bfe0cd6 --- /dev/null +++ b/0004-establish-relational-store-dependence-on-boundscheck.patch @@ -0,0 +1,24 @@ +From bbc413f60a0ab0c8b3029f999be051b44101aa21 Mon Sep 17 00:00:00 2001 +From: wang--ge +Date: Tue, 18 Jul 2023 15:31:25 +0800 +Subject: [PATCH] establish relational store dependence on boundscheck + +--- + .../relational_store/interfaces/inner_api/appdatafwk/BUILD.gn | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/distributeddatamgr/relational_store/interfaces/inner_api/appdatafwk/BUILD.gn b/distributeddatamgr/relational_store/interfaces/inner_api/appdatafwk/BUILD.gn +index 688674b..86f5dd9 100644 +--- a/distributeddatamgr/relational_store/interfaces/inner_api/appdatafwk/BUILD.gn ++++ b/distributeddatamgr/relational_store/interfaces/inner_api/appdatafwk/BUILD.gn +@@ -34,6 +34,7 @@ ohos_shared_library("native_appdatafwk") { + + public_deps = [ + "//foundation/communication/ipc/interfaces/innerkits/ipc_core:ipc_core", ++ "//third_party/bounds_checking_function:libsec_shared", + ] + + external_deps = [ +-- +2.27.0 + From f0cb59c2212e29f2310ff67dad25035f9f935335 Mon Sep 17 00:00:00 2001 From: heppen Date: Tue, 29 Aug 2023 19:53:34 +0800 Subject: [PATCH 5/5] add source files and spec file --- BUILD.gn.appdatafwk | 10 ++ BUILD.gn.dataability | 10 ++ BUILD.gn.rdb | 12 ++ BUILD.gn.share.adapter | 10 ++ bundle.json | 133 ++++++++++++++++++ ...onal_store-OpenHarmony-v3.2-Release.tar.gz | Bin 0 -> 282767 bytes distributeddatamgr_relational_store.spec | 119 ++++++++++++++++ 7 files changed, 294 insertions(+) create mode 100644 BUILD.gn.appdatafwk create mode 100644 BUILD.gn.dataability create mode 100644 BUILD.gn.rdb create mode 100644 BUILD.gn.share.adapter create mode 100644 bundle.json create mode 100644 distributeddatamgr_relational_store-OpenHarmony-v3.2-Release.tar.gz create mode 100644 distributeddatamgr_relational_store.spec diff --git a/BUILD.gn.appdatafwk b/BUILD.gn.appdatafwk new file mode 100644 index 0000000..ae51fb3 --- /dev/null +++ b/BUILD.gn.appdatafwk @@ -0,0 +1,10 @@ +import("//build/ohos.gni") + +config("appdatafwk_public_config") { + include_dirs = [ "include" ] + libs = [ "native_appdatafwk.z" ] +} + +group("native_appdatafwk") { + public_configs = [ ":appdatafwk_public_config" ] +} diff --git a/BUILD.gn.dataability b/BUILD.gn.dataability new file mode 100644 index 0000000..8cdd2ae --- /dev/null +++ b/BUILD.gn.dataability @@ -0,0 +1,10 @@ +import("//build/ohos.gni") + +config("native_dataability_public_config") { + include_dirs = [ "include" ] + libs = [ "native_dataability.z" ] +} + +group("native_dataability") { + public_configs = [ ":native_dataability_public_config" ] +} diff --git a/BUILD.gn.rdb b/BUILD.gn.rdb new file mode 100644 index 0000000..8c9f1c3 --- /dev/null +++ b/BUILD.gn.rdb @@ -0,0 +1,12 @@ +import("//build/ohos.gni") + +config("native_rdb_public_config") { + include_dirs = [ + "include" + ] + libs = [ "native_rdb.z" ] +} + +group("native_rdb") { + public_configs = [ ":native_rdb_public_config" ] +} diff --git a/BUILD.gn.share.adapter b/BUILD.gn.share.adapter new file mode 100644 index 0000000..339f186 --- /dev/null +++ b/BUILD.gn.share.adapter @@ -0,0 +1,10 @@ +import("//build/ohos.gni") + +config("rdb_data_share_adapter_public_config") { + include_dirs = [ "include" ] + libs = [ "rdb_data_share_adapter.z" ] +} + +group("rdb_data_share_adapter") { + public_configs = [ ":rdb_data_share_adapter_public_config" ] +} diff --git a/bundle.json b/bundle.json new file mode 100644 index 0000000..34da81c --- /dev/null +++ b/bundle.json @@ -0,0 +1,133 @@ +{ + "name": "@ohos/distributeddatamgr_relational_store", + "version": "3.1.0", + "description": "Local Data Management", + "homePage": "https://gitee.com/openharmony", + "license": "Apache V2", + "repository": "https://gitee.com/openharmony/distributeddatamgr_relational_store", + "domain": "os", + "language": "", + "publishAs": "code-segment", + "private": false, + "scripts": {}, + "tags": [ + "foundation" + ], + "keywords": [ + "distributeddatamgr", + "relational_store" + ], + "envs": [], + "dirs": {}, + "author": { + "name": "", + "email": "", + "url": "" + }, + "contributors": [ + { + "name": "", + "email": "", + "url": "" + } + ], + "segment": { + "destPath": "foundation/distributeddatamgr/relational_store" + }, + "component": { + "name": "relational_store", + "subsystem": "distributeddatamgr", + "syscap": [ + "SystemCapability.DistributedDataManager.RelationalStore.Core" + ], + "features": ["relational_store_rdb_support_icu"], + "adapted_system_type": [ + "standard" + ], + "rom": "", + "ram": "", + "deps": { + "components": [ + "ability_base", + "ability_runtime", + "napi", + "hitrace_native", + "hilog_native", + "ipc", + "utils_base", + "common", + "icu", + "samgr" + ], + "third_party": [ + "sqlite", + "shared_icuuc", + "shared_icui18n", + "libxml2", + "libsec_shared", + "gtest_main" + ] + }, + "build": { + "sub_component": [ + "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/appdatafwk:native_appdatafwk", + "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/dataability:native_dataability", + "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb_data_share_adapter:rdb_data_share_adapter", + "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb" + ], + "inner_kits": [ + { + "name": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb:native_rdb", + "header": { + "header_files": [ + "abs_rdb_predicates.h", + "abs_result_set.h", + "abs_shared_result_set.h", + "rdb_errno.h", + "rdb_helper.h", + "rdb_open_callback.h", + "rdb_predicates.h", + "rdb_store.h", + "rdb_store_config.h", + "result_set.h", + "shared_result_set.h", + "transaction_observer.h", + "value_object.h", + "values_bucket.h" + ], + "header_base": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/rdb/include" + } + }, + { + "name": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/appdatafwk:native_appdatafwk", + "header": { + "header_files": [ + "shared_block.h" + ], + "header_base": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/appdatafwk/include" + } + }, + { + "name": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/dataability:native_dataability", + "header": { + "header_files": [ + "data_ability_predicates.h", + "predicates_utils.h" + ], + "header_base": "//foundation/distributeddatamgr/relational_store/interfaces/inner_api/dataability/include" + } + } + ], + "test": [ + "//foundation/distributeddatamgr/relational_store/test/js/dataability:unittest", + "//foundation/distributeddatamgr/relational_store/test/js/rdb:unittest", + "//foundation/distributeddatamgr/relational_store/test/js/relationalstore:unittest", + "//foundation/distributeddatamgr/relational_store/test/native/dataability:unittest", + "//foundation/distributeddatamgr/relational_store/test/native/rdb:unittest", + "//foundation/distributeddatamgr/relational_store/test/native/rdb:fuzztest", + "//foundation/distributeddatamgr/relational_store/test/native/rdb_data_share_adapter:unittest", + "//foundation/distributeddatamgr/relational_store/test/native/rdb:distributedtest" + ] + } + } +} diff --git a/distributeddatamgr_relational_store-OpenHarmony-v3.2-Release.tar.gz b/distributeddatamgr_relational_store-OpenHarmony-v3.2-Release.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..fe0e15b2b5f4251e287d8fcda2248d4a548431b0 GIT binary patch literal 282767 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
    HcL7 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

    @Kd(7uy8n&jv6bIF_%~ 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

    $wND!^&x+>z^K1I^V-I+}zwwI^4t4P1HO# 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

    REZJXpkf?l0U?pJR`##wx#l>fU> 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

    xyw9W60`j^+^`IUfWNL)LP~ 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�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 literal 0 HcmV?d00001 diff --git a/distributeddatamgr_relational_store.spec b/distributeddatamgr_relational_store.spec new file mode 100644 index 0000000..ca04b85 --- /dev/null +++ b/distributeddatamgr_relational_store.spec @@ -0,0 +1,119 @@ +%define debug_package %{nil} +%global oh_version OpenHarmony-v3.2-Release +%global relational_store_dir %{_builddir}/foundation/distributeddatamgr/ +%global build_opt /opt/distributed-middleware-build +%global bundle_dir %{build_opt}/openeuler/compiler_gn/foundation/distributeddatamgr/relational_store +%global appdatafwk_dir %{bundle_dir}/interfaces/inner_api/appdatafwk +%global dataability_dir %{bundle_dir}/interfaces/inner_api/dataability +%global share_adapter_dir %{bundle_dir}/interfaces/inner_api/rdb_data_share_adapter +%global rdb_dir %{bundle_dir}/interfaces/inner_api/rdb + +Name: distributeddatamgr_relational_store +Version: 1.0.0 +Release: 2 +Summary: Local Data Management +License: Apache-2.0 +Url: https://gitee.com/openharmony/distributeddatamgr_relational_store +Source0: https://gitee.com/openharmony/distributeddatamgr_relational_store/repository/archive/OpenHarmony-v3.2-Release.tar.gz#/distributeddatamgr_relational_store-OpenHarmony-v3.2-Release.tar.gz +Source1: bundle.json +Source2: BUILD.gn.appdatafwk +Source3: BUILD.gn.dataability +Source4: BUILD.gn.share.adapter +Source5: BUILD.gn.rdb +Patch0: 0001-remove-useless-dependencies.patch +Patch1: 0002-add-huks-component.patch +Patch2: 0003-add-third-part-component.patch +Patch3: 0004-establish-relational-store-dependence-on-boundscheck.patch + +BuildRequires: libatomic libicu-devel libxml2-devel openssl-devel +BuildRequires: distributed-build distributed-build_lite hilog distributed-utils +BuildRequires: distributeddatamgr_kv_store libicu + +Requires: hilog distributed-utils distributeddatamgr_kv_store + +%description +A relational database (RDB) is a database that manages data based on a relational model. The OpenHarmony relational database provides a complete mechanism for managing local databases based on the SQLite component. + +%prep +rm -rf %{_builddir}/* + +cd %{_builddir} +cp -rp %{build_opt} %{_builddir}/build +[ ! -L "%{_builddir}/build.sh" ] && ln -s %{_builddir}/build/build_scripts/build.sh %{_builddir}/build.sh +[ ! -L "%{_builddir}/.gn" ] && ln -s %{_builddir}/build/core/gn/dotfile.gn %{_builddir}/.gn +[ ! -L "%{_builddir}/build.py" ] && ln -s %{_builddir}/build/lite/build.py %{_builddir}/build.py +mv build/openeuler/vendor %{_builddir}/ + +%setup -q -T -a 0 -c -n %{relational_store_dir} +mv %{relational_store_dir}%{name}-%{oh_version} %{relational_store_dir}relational_store +cp -rf %{_builddir}/build/openeuler/compiler_gn/* %{_builddir}/ + +cd %{_builddir} +%patch0 -p1 -d %{relational_store_dir}relational_store +%patch1 -p1 -d %{_builddir}/base/security +%patch2 -p1 -d %{_builddir}/third_party +%patch3 -p1 -d %{_builddir}/foundation + +%build +cd %{_builddir} +rm -rf %{_builddir}/out + +%ifarch x86_64 +./build.sh --product-name openeuler --target-cpu x86_64 +%endif + +%ifarch aarch64 +./build.sh --product-name openeuler --target-cpu arm64 +%endif + +%install +install -d -m 0755 %{buildroot}%{_includedir}/relational_store +install -d -m 0755 %{buildroot}%{_libdir} +install -d -m 0755 %{buildroot}%{appdatafwk_dir} +install -d -m 0755 %{buildroot}%{dataability_dir} +install -d -m 0755 %{buildroot}%{share_adapter_dir} +install -d -m 0755 %{buildroot}%{rdb_dir} +install -d -m 0755 %{buildroot}/system/lib64 + +%ifarch aarch64 +module_out_path="out/openeuler/linux_clang_arm64/distributeddatamgr/relational_store/" +header_out_path="out/openeuler/innerkits/linux-arm64/relational_store" +%endif +%ifarch x86_64 +module_out_path="out/openeuler/linux_clang_x86_64/distributeddatamgr/relational_store/" +header_out_path="out/openeuler/innerkits/linux-x86_64/relational_store" +%endif + +install -m 0755 %{_builddir}/${module_out_path}/*.so %{buildroot}%{_libdir} +install -m 0755 %{_builddir}/${module_out_path}/*.so %{buildroot}/system/lib64/ + +find %{_builddir}/${header_out_path} -name *.h -print0 | xargs -0 -i cp -rvf {} %{buildroot}%{_includedir}/relational_store/ + +pushd %{_builddir}/foundation/distributeddatamgr/relational_store/ +for include_file in `find . \( -name js -o -name test -o -name mock \) -prune -o -name "*.h" -type f` +do + if [[ ${include_file} != *.h ]]; then + continue + fi + cp --parents ${include_file} %{buildroot}%{bundle_dir} +done +popd + +cp %{SOURCE1} %{buildroot}%{bundle_dir} +cp %{SOURCE2} %{buildroot}%{appdatafwk_dir}/BUILD.gn +cp %{SOURCE3} %{buildroot}%{dataability_dir}/BUILD.gn +cp %{SOURCE4} %{buildroot}%{share_adapter_dir}/BUILD.gn +cp %{SOURCE5} %{buildroot}%{rdb_dir}/BUILD.gn + +%files +%{_libdir}/*.so +%{_includedir}/relational_store/* +%{bundle_dir}/* +/system/* + +%changelog +* Thu Aug 03 2023 Peng He - 1.0.0-2 +- Add requires and rectify the contents of the RPM package. + +* Fri Jun 9 2023 Ge Wang - 1.0.0-1 +- init package