poppler 2.2.5-x86-mingw32 → 3.0.0-x86-mingw32
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/Rakefile +18 -4
- data/lib/2.0/poppler.so +0 -0
- data/lib/2.1/poppler.so +0 -0
- data/lib/2.2/poppler.so +0 -0
- data/vendor/local/bin/cjpeg.exe +0 -0
- data/vendor/local/bin/djpeg.exe +0 -0
- data/vendor/local/bin/jpegtran.exe +0 -0
- data/vendor/local/bin/libjpeg-9.dll +0 -0
- data/vendor/local/bin/libopenjp2.dll +0 -0
- data/vendor/local/bin/{libpoppler-48.dll → libpoppler-55.dll} +0 -0
- data/vendor/local/bin/libpoppler-cpp-0.dll +0 -0
- data/vendor/local/bin/libpoppler-glib-8.dll +0 -0
- data/vendor/local/bin/libsqlite3-0.dll +0 -0
- data/vendor/local/bin/opj_compress.exe +0 -0
- data/vendor/local/bin/opj_decompress.exe +0 -0
- data/vendor/local/bin/opj_dump.exe +0 -0
- data/vendor/local/bin/pdfdetach.exe +0 -0
- data/vendor/local/bin/pdffonts.exe +0 -0
- data/vendor/local/bin/pdfimages.exe +0 -0
- data/vendor/local/bin/pdfinfo.exe +0 -0
- data/vendor/local/bin/pdfseparate.exe +0 -0
- data/vendor/local/bin/pdftocairo.exe +0 -0
- data/vendor/local/bin/pdftohtml.exe +0 -0
- data/vendor/local/bin/pdftoppm.exe +0 -0
- data/vendor/local/bin/pdftops.exe +0 -0
- data/vendor/local/bin/pdftotext.exe +0 -0
- data/vendor/local/bin/pdfunite.exe +0 -0
- data/vendor/local/bin/rdjpgcom.exe +0 -0
- data/vendor/local/bin/sqlite3.exe +0 -0
- data/vendor/local/bin/wrjpgcom.exe +0 -0
- data/vendor/local/include/openjpeg-2.1/openjpeg.h +1559 -0
- data/vendor/local/include/openjpeg-2.1/opj_config.h +10 -0
- data/vendor/local/include/openjpeg-2.1/opj_stdint.h +52 -0
- data/vendor/local/include/poppler/cpp/poppler-global.h +5 -0
- data/vendor/local/include/poppler/cpp/poppler-version.h +2 -2
- data/vendor/local/include/poppler/glib/poppler-annot.h +2 -0
- data/vendor/local/include/poppler/glib/poppler-features.h +1 -1
- data/vendor/local/include/sqlite3.h +1023 -657
- data/vendor/local/include/sqlite3ext.h +42 -2
- data/vendor/local/lib/girepository-1.0/Poppler-0.18.typelib +0 -0
- data/vendor/local/lib/libjpeg.a +0 -0
- data/vendor/local/lib/libjpeg.dll.a +0 -0
- data/vendor/local/lib/libopenjp2.dll.a +0 -0
- data/vendor/local/lib/libpoppler-cpp.a +0 -0
- data/vendor/local/lib/libpoppler-cpp.dll.a +0 -0
- data/vendor/local/lib/libpoppler-cpp.la +2 -2
- data/vendor/local/lib/libpoppler-glib.a +0 -0
- data/vendor/local/lib/libpoppler-glib.dll.a +0 -0
- data/vendor/local/lib/libpoppler-glib.la +3 -3
- data/vendor/local/lib/libpoppler.a +0 -0
- data/vendor/local/lib/libpoppler.dll.a +0 -0
- data/vendor/local/lib/libpoppler.la +3 -3
- data/vendor/local/lib/libsqlite3.a +0 -0
- data/vendor/local/lib/libsqlite3.dll.a +0 -0
- data/vendor/local/lib/openjpeg-2.1/OpenJPEGConfig.cmake +48 -0
- data/vendor/local/lib/openjpeg-2.1/OpenJPEGTargets-noconfig.cmake +46 -0
- data/vendor/local/lib/openjpeg-2.1/OpenJPEGTargets.cmake +92 -0
- data/vendor/local/lib/pkgconfig/libopenjp2.pc +14 -0
- data/vendor/local/lib/pkgconfig/poppler-cairo.pc +2 -2
- data/vendor/local/lib/pkgconfig/poppler-cpp.pc +2 -2
- data/vendor/local/lib/pkgconfig/poppler-glib.pc +2 -2
- data/vendor/local/lib/pkgconfig/poppler-splash.pc +2 -2
- data/vendor/local/lib/pkgconfig/poppler.pc +1 -1
- data/vendor/local/lib/pkgconfig/sqlite3.pc +1 -1
- data/vendor/local/share/gir-1.0/Poppler-0.18.gir +23 -2
- data/vendor/local/share/gtk-doc/html/poppler/PopplerAnnot.html +111 -66
- data/vendor/local/share/gtk-doc/html/poppler/annotation-glossary.html +2 -2
- data/vendor/local/share/gtk-doc/html/poppler/api-index-0-22.html +2 -2
- data/vendor/local/share/gtk-doc/html/poppler/api-index-0-26.html +419 -0
- data/vendor/local/share/gtk-doc/html/poppler/api-index-0-33.html +35 -0
- data/vendor/local/share/gtk-doc/html/poppler/api-index-full.html +4 -0
- data/vendor/local/share/gtk-doc/html/poppler/index.html +3 -1
- data/vendor/local/share/gtk-doc/html/poppler/index.sgml +1 -0
- data/vendor/local/share/gtk-doc/html/poppler/poppler-Version-and-Features-Information.html +1 -1
- data/vendor/local/share/gtk-doc/html/poppler/poppler.devhelp2 +3 -0
- data/vendor/local/share/license/openjpeg/AUTHORS +15 -0
- data/vendor/local/share/man/man1/pdftops.1 +18 -1
- data/vendor/local/share/man/man1/pdftotext.1 +4 -0
- data/vendor/local/share/man/man1/sqlite3.1 +45 -38
- metadata +20 -5
@@ -0,0 +1,10 @@
|
|
1
|
+
/* create opj_config.h for CMake */
|
2
|
+
#define OPJ_HAVE_STDINT_H 1
|
3
|
+
|
4
|
+
/*--------------------------------------------------------------------------*/
|
5
|
+
/* OpenJPEG Versioning */
|
6
|
+
|
7
|
+
/* Version number. */
|
8
|
+
#define OPJ_VERSION_MAJOR 2
|
9
|
+
#define OPJ_VERSION_MINOR 1
|
10
|
+
#define OPJ_VERSION_BUILD 0
|
@@ -0,0 +1,52 @@
|
|
1
|
+
/*
|
2
|
+
* The copyright in this software is being made available under the 2-clauses
|
3
|
+
* BSD License, included below. This software may be subject to other third
|
4
|
+
* party and contributor rights, including patent rights, and no such rights
|
5
|
+
* are granted under this license.
|
6
|
+
*
|
7
|
+
* Copyright (c) 2012, Mathieu Malaterre <mathieu.malaterre@gmail.com>
|
8
|
+
* All rights reserved.
|
9
|
+
*
|
10
|
+
* Redistribution and use in source and binary forms, with or without
|
11
|
+
* modification, are permitted provided that the following conditions
|
12
|
+
* are met:
|
13
|
+
* 1. Redistributions of source code must retain the above copyright
|
14
|
+
* notice, this list of conditions and the following disclaimer.
|
15
|
+
* 2. Redistributions in binary form must reproduce the above copyright
|
16
|
+
* notice, this list of conditions and the following disclaimer in the
|
17
|
+
* documentation and/or other materials provided with the distribution.
|
18
|
+
*
|
19
|
+
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
|
20
|
+
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
21
|
+
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
22
|
+
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
23
|
+
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
24
|
+
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
25
|
+
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
26
|
+
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
27
|
+
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
28
|
+
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
29
|
+
* POSSIBILITY OF SUCH DAMAGE.
|
30
|
+
*/
|
31
|
+
#ifndef OPJ_STDINT_H
|
32
|
+
#define OPJ_STDINT_H
|
33
|
+
|
34
|
+
#include "opj_config.h"
|
35
|
+
#ifdef OPJ_HAVE_STDINT_H
|
36
|
+
#include <stdint.h>
|
37
|
+
#else
|
38
|
+
#if defined(_WIN32)
|
39
|
+
typedef signed __int8 int8_t;
|
40
|
+
typedef unsigned __int8 uint8_t;
|
41
|
+
typedef signed __int16 int16_t;
|
42
|
+
typedef unsigned __int16 uint16_t;
|
43
|
+
typedef signed __int32 int32_t;
|
44
|
+
typedef unsigned __int32 uint32_t;
|
45
|
+
typedef signed __int64 int64_t;
|
46
|
+
typedef unsigned __int64 uint64_t;
|
47
|
+
#else
|
48
|
+
#error unsupported platform
|
49
|
+
#endif
|
50
|
+
#endif
|
51
|
+
|
52
|
+
#endif /* OPJ_STDINT_H */
|
@@ -1,6 +1,7 @@
|
|
1
1
|
/*
|
2
2
|
* Copyright (C) 2009-2010, Pino Toscano <pino@kde.org>
|
3
3
|
* Copyright (C) 2010, Patrick Spendrin <ps_ml@gmx.de>
|
4
|
+
* Copyright (C) 2014, Hans-Peter Deifel <hpdeifel@gmx.de>
|
4
5
|
*
|
5
6
|
* This program is free software; you can redistribute it and/or modify
|
6
7
|
* it under the terms of the GNU General Public License as published by
|
@@ -106,6 +107,10 @@ POPPLER_CPP_EXPORT time_type convert_date(const std::string &date);
|
|
106
107
|
|
107
108
|
POPPLER_CPP_EXPORT std::ostream& operator<<(std::ostream& stream, const byte_array &array);
|
108
109
|
|
110
|
+
typedef void(*debug_func)(const std::string &, void *);
|
111
|
+
|
112
|
+
POPPLER_CPP_EXPORT void set_debug_error_function(debug_func debug_function, void *closure);
|
113
|
+
|
109
114
|
}
|
110
115
|
|
111
116
|
#endif
|
@@ -21,9 +21,9 @@
|
|
21
21
|
|
22
22
|
#include "poppler-global.h"
|
23
23
|
|
24
|
-
#define POPPLER_VERSION "0.
|
24
|
+
#define POPPLER_VERSION "0.36.0"
|
25
25
|
#define POPPLER_VERSION_MAJOR 0
|
26
|
-
#define POPPLER_VERSION_MINOR
|
26
|
+
#define POPPLER_VERSION_MINOR 36
|
27
27
|
#define POPPLER_VERSION_MICRO 0
|
28
28
|
|
29
29
|
namespace poppler
|
@@ -202,6 +202,8 @@ void poppler_annot_markup_set_popup_is_open (
|
|
202
202
|
gboolean is_open);
|
203
203
|
gboolean poppler_annot_markup_get_popup_rectangle (PopplerAnnotMarkup *poppler_annot,
|
204
204
|
PopplerRectangle *poppler_rect);
|
205
|
+
void poppler_annot_markup_set_popup_rectangle (PopplerAnnotMarkup *poppler_annot,
|
206
|
+
PopplerRectangle *poppler_rect);
|
205
207
|
gdouble poppler_annot_markup_get_opacity (PopplerAnnotMarkup *poppler_annot);
|
206
208
|
void poppler_annot_markup_set_opacity (PopplerAnnotMarkup *poppler_annot,
|
207
209
|
gdouble opacity);
|
@@ -23,7 +23,7 @@
|
|
23
23
|
**
|
24
24
|
** The official C-language API documentation for SQLite is derived
|
25
25
|
** from comments in this file. This file is the authoritative source
|
26
|
-
** on how SQLite interfaces are
|
26
|
+
** on how SQLite interfaces are supposed to operate.
|
27
27
|
**
|
28
28
|
** The name of this file under configuration management is "sqlite.h.in".
|
29
29
|
** The makefile makes some minor changes to this file (such as inserting
|
@@ -43,21 +43,25 @@ extern "C" {
|
|
43
43
|
|
44
44
|
|
45
45
|
/*
|
46
|
-
**
|
46
|
+
** Provide the ability to override linkage features of the interface.
|
47
47
|
*/
|
48
48
|
#ifndef SQLITE_EXTERN
|
49
49
|
# define SQLITE_EXTERN extern
|
50
50
|
#endif
|
51
|
-
|
52
51
|
#ifndef SQLITE_API
|
53
52
|
# define SQLITE_API
|
54
53
|
#endif
|
55
|
-
|
54
|
+
#ifndef SQLITE_CDECL
|
55
|
+
# define SQLITE_CDECL
|
56
|
+
#endif
|
57
|
+
#ifndef SQLITE_STDCALL
|
58
|
+
# define SQLITE_STDCALL
|
59
|
+
#endif
|
56
60
|
|
57
61
|
/*
|
58
62
|
** These no-op macros are used in front of interfaces to mark those
|
59
63
|
** interfaces as either deprecated or experimental. New applications
|
60
|
-
** should not use deprecated interfaces - they are
|
64
|
+
** should not use deprecated interfaces - they are supported for backwards
|
61
65
|
** compatibility only. Application writers should be aware that
|
62
66
|
** experimental interfaces are subject to change in point releases.
|
63
67
|
**
|
@@ -107,9 +111,9 @@ extern "C" {
|
|
107
111
|
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
|
108
112
|
** [sqlite_version()] and [sqlite_source_id()].
|
109
113
|
*/
|
110
|
-
#define SQLITE_VERSION "3.8.
|
111
|
-
#define SQLITE_VERSION_NUMBER
|
112
|
-
#define SQLITE_SOURCE_ID "
|
114
|
+
#define SQLITE_VERSION "3.8.11.1"
|
115
|
+
#define SQLITE_VERSION_NUMBER 3008011
|
116
|
+
#define SQLITE_SOURCE_ID "2015-07-29 20:00:57 cf538e2783e468bbc25e7cb2a9ee64d3e0e80b2f"
|
113
117
|
|
114
118
|
/*
|
115
119
|
** CAPI3REF: Run-Time Library Version Numbers
|
@@ -142,9 +146,9 @@ extern "C" {
|
|
142
146
|
** See also: [sqlite_version()] and [sqlite_source_id()].
|
143
147
|
*/
|
144
148
|
SQLITE_API SQLITE_EXTERN const char sqlite3_version[];
|
145
|
-
SQLITE_API const char *sqlite3_libversion(void);
|
146
|
-
SQLITE_API const char *sqlite3_sourceid(void);
|
147
|
-
SQLITE_API int sqlite3_libversion_number(void);
|
149
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_libversion(void);
|
150
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_sourceid(void);
|
151
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_libversion_number(void);
|
148
152
|
|
149
153
|
/*
|
150
154
|
** CAPI3REF: Run-Time Library Compilation Options Diagnostics
|
@@ -169,8 +173,8 @@ SQLITE_API int sqlite3_libversion_number(void);
|
|
169
173
|
** [sqlite_compileoption_get()] and the [compile_options pragma].
|
170
174
|
*/
|
171
175
|
#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
|
172
|
-
SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
|
173
|
-
SQLITE_API const char *sqlite3_compileoption_get(int N);
|
176
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_compileoption_used(const char *zOptName);
|
177
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_compileoption_get(int N);
|
174
178
|
#endif
|
175
179
|
|
176
180
|
/*
|
@@ -201,7 +205,7 @@ SQLITE_API const char *sqlite3_compileoption_get(int N);
|
|
201
205
|
** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but
|
202
206
|
** can be fully or partially disabled using a call to [sqlite3_config()]
|
203
207
|
** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD],
|
204
|
-
** or [
|
208
|
+
** or [SQLITE_CONFIG_SERIALIZED]. ^(The return value of the
|
205
209
|
** sqlite3_threadsafe() function shows only the compile-time setting of
|
206
210
|
** thread safety, not any run-time changes to that setting made by
|
207
211
|
** sqlite3_config(). In other words, the return value from sqlite3_threadsafe()
|
@@ -209,7 +213,7 @@ SQLITE_API const char *sqlite3_compileoption_get(int N);
|
|
209
213
|
**
|
210
214
|
** See the [threading mode] documentation for additional information.
|
211
215
|
*/
|
212
|
-
SQLITE_API int sqlite3_threadsafe(void);
|
216
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_threadsafe(void);
|
213
217
|
|
214
218
|
/*
|
215
219
|
** CAPI3REF: Database Connection Handle
|
@@ -266,6 +270,7 @@ typedef sqlite_uint64 sqlite3_uint64;
|
|
266
270
|
|
267
271
|
/*
|
268
272
|
** CAPI3REF: Closing A Database Connection
|
273
|
+
** DESTRUCTOR: sqlite3
|
269
274
|
**
|
270
275
|
** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors
|
271
276
|
** for the [sqlite3] object.
|
@@ -305,8 +310,8 @@ typedef sqlite_uint64 sqlite3_uint64;
|
|
305
310
|
** ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer
|
306
311
|
** argument is a harmless no-op.
|
307
312
|
*/
|
308
|
-
SQLITE_API int sqlite3_close(sqlite3*);
|
309
|
-
SQLITE_API int sqlite3_close_v2(sqlite3*);
|
313
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_close(sqlite3*);
|
314
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_close_v2(sqlite3*);
|
310
315
|
|
311
316
|
/*
|
312
317
|
** The type for a callback function.
|
@@ -317,6 +322,7 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);
|
|
317
322
|
|
318
323
|
/*
|
319
324
|
** CAPI3REF: One-Step Query Execution Interface
|
325
|
+
** METHOD: sqlite3
|
320
326
|
**
|
321
327
|
** The sqlite3_exec() interface is a convenience wrapper around
|
322
328
|
** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()],
|
@@ -376,7 +382,7 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);
|
|
376
382
|
** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
|
377
383
|
** </ul>
|
378
384
|
*/
|
379
|
-
SQLITE_API int sqlite3_exec(
|
385
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_exec(
|
380
386
|
sqlite3*, /* An open database */
|
381
387
|
const char *sql, /* SQL to be evaluated */
|
382
388
|
int (*callback)(void*,int,char**,char**), /* Callback function */
|
@@ -497,6 +503,7 @@ SQLITE_API int sqlite3_exec(
|
|
497
503
|
#define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8))
|
498
504
|
#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
|
499
505
|
#define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8))
|
506
|
+
#define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8))
|
500
507
|
|
501
508
|
/*
|
502
509
|
** CAPI3REF: Flags For File Open Operations
|
@@ -755,14 +762,16 @@ struct sqlite3_io_methods {
|
|
755
762
|
** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]
|
756
763
|
** interface.
|
757
764
|
**
|
765
|
+
** <ul>
|
766
|
+
** <li>[[SQLITE_FCNTL_LOCKSTATE]]
|
758
767
|
** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This
|
759
768
|
** opcode causes the xFileControl method to write the current state of
|
760
769
|
** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
|
761
770
|
** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
|
762
771
|
** into an integer that the pArg argument points to. This capability
|
763
|
-
** is used during testing and only
|
764
|
-
** is
|
765
|
-
**
|
772
|
+
** is used during testing and is only available when the SQLITE_TEST
|
773
|
+
** compile-time option is used.
|
774
|
+
**
|
766
775
|
** <li>[[SQLITE_FCNTL_SIZE_HINT]]
|
767
776
|
** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
|
768
777
|
** layer a hint of how large the database file will grow to be during the
|
@@ -887,7 +896,9 @@ struct sqlite3_io_methods {
|
|
887
896
|
** [PRAGMA] processing continues. ^If the [SQLITE_FCNTL_PRAGMA]
|
888
897
|
** file control returns [SQLITE_OK], then the parser assumes that the
|
889
898
|
** VFS has handled the PRAGMA itself and the parser generates a no-op
|
890
|
-
** prepared statement
|
899
|
+
** prepared statement if result string is NULL, or that returns a copy
|
900
|
+
** of the result string if the string is non-NULL.
|
901
|
+
** ^If the [SQLITE_FCNTL_PRAGMA] file control returns
|
891
902
|
** any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
|
892
903
|
** that the VFS encountered an error while handling the [PRAGMA] and the
|
893
904
|
** compilation of the PRAGMA fails with an error. ^The [SQLITE_FCNTL_PRAGMA]
|
@@ -945,12 +956,27 @@ struct sqlite3_io_methods {
|
|
945
956
|
** pointed to by the pArg argument. This capability is used during testing
|
946
957
|
** and only needs to be supported when SQLITE_TEST is defined.
|
947
958
|
**
|
959
|
+
** <li>[[SQLITE_FCNTL_WAL_BLOCK]]
|
960
|
+
** The [SQLITE_FCNTL_WAL_BLOCK] is a signal to the VFS layer that it might
|
961
|
+
** be advantageous to block on the next WAL lock if the lock is not immediately
|
962
|
+
** available. The WAL subsystem issues this signal during rare
|
963
|
+
** circumstances in order to fix a problem with priority inversion.
|
964
|
+
** Applications should <em>not</em> use this file-control.
|
965
|
+
**
|
966
|
+
** <li>[[SQLITE_FCNTL_ZIPVFS]]
|
967
|
+
** The [SQLITE_FCNTL_ZIPVFS] opcode is implemented by zipvfs only. All other
|
968
|
+
** VFS should return SQLITE_NOTFOUND for this opcode.
|
969
|
+
**
|
970
|
+
** <li>[[SQLITE_FCNTL_RBU]]
|
971
|
+
** The [SQLITE_FCNTL_RBU] opcode is implemented by the special VFS used by
|
972
|
+
** the RBU extension only. All other VFS should return SQLITE_NOTFOUND for
|
973
|
+
** this opcode.
|
948
974
|
** </ul>
|
949
975
|
*/
|
950
976
|
#define SQLITE_FCNTL_LOCKSTATE 1
|
951
|
-
#define
|
952
|
-
#define
|
953
|
-
#define
|
977
|
+
#define SQLITE_FCNTL_GET_LOCKPROXYFILE 2
|
978
|
+
#define SQLITE_FCNTL_SET_LOCKPROXYFILE 3
|
979
|
+
#define SQLITE_FCNTL_LAST_ERRNO 4
|
954
980
|
#define SQLITE_FCNTL_SIZE_HINT 5
|
955
981
|
#define SQLITE_FCNTL_CHUNK_SIZE 6
|
956
982
|
#define SQLITE_FCNTL_FILE_POINTER 7
|
@@ -969,6 +995,15 @@ struct sqlite3_io_methods {
|
|
969
995
|
#define SQLITE_FCNTL_SYNC 21
|
970
996
|
#define SQLITE_FCNTL_COMMIT_PHASETWO 22
|
971
997
|
#define SQLITE_FCNTL_WIN32_SET_HANDLE 23
|
998
|
+
#define SQLITE_FCNTL_WAL_BLOCK 24
|
999
|
+
#define SQLITE_FCNTL_ZIPVFS 25
|
1000
|
+
#define SQLITE_FCNTL_RBU 26
|
1001
|
+
|
1002
|
+
/* deprecated names */
|
1003
|
+
#define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE
|
1004
|
+
#define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE
|
1005
|
+
#define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO
|
1006
|
+
|
972
1007
|
|
973
1008
|
/*
|
974
1009
|
** CAPI3REF: Mutex Handle
|
@@ -1220,7 +1255,7 @@ struct sqlite3_vfs {
|
|
1220
1255
|
** </ul>
|
1221
1256
|
**
|
1222
1257
|
** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
|
1223
|
-
** was given
|
1258
|
+
** was given on the corresponding lock.
|
1224
1259
|
**
|
1225
1260
|
** The xShmLock method can transition between unlocked and SHARED or
|
1226
1261
|
** between unlocked and EXCLUSIVE. It cannot transition between SHARED
|
@@ -1317,10 +1352,10 @@ struct sqlite3_vfs {
|
|
1317
1352
|
** must return [SQLITE_OK] on success and some other [error code] upon
|
1318
1353
|
** failure.
|
1319
1354
|
*/
|
1320
|
-
SQLITE_API int sqlite3_initialize(void);
|
1321
|
-
SQLITE_API int sqlite3_shutdown(void);
|
1322
|
-
SQLITE_API int sqlite3_os_init(void);
|
1323
|
-
SQLITE_API int sqlite3_os_end(void);
|
1355
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_initialize(void);
|
1356
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_shutdown(void);
|
1357
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_os_init(void);
|
1358
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_os_end(void);
|
1324
1359
|
|
1325
1360
|
/*
|
1326
1361
|
** CAPI3REF: Configuring The SQLite Library
|
@@ -1351,10 +1386,11 @@ SQLITE_API int sqlite3_os_end(void);
|
|
1351
1386
|
** ^If the option is unknown or SQLite is unable to set the option
|
1352
1387
|
** then this routine returns a non-zero [error code].
|
1353
1388
|
*/
|
1354
|
-
SQLITE_API int sqlite3_config(int, ...);
|
1389
|
+
SQLITE_API int SQLITE_CDECL sqlite3_config(int, ...);
|
1355
1390
|
|
1356
1391
|
/*
|
1357
1392
|
** CAPI3REF: Configure database connections
|
1393
|
+
** METHOD: sqlite3
|
1358
1394
|
**
|
1359
1395
|
** The sqlite3_db_config() interface is used to make configuration
|
1360
1396
|
** changes to a [database connection]. The interface is similar to
|
@@ -1369,7 +1405,7 @@ SQLITE_API int sqlite3_config(int, ...);
|
|
1369
1405
|
** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
|
1370
1406
|
** the call is considered successful.
|
1371
1407
|
*/
|
1372
|
-
SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...);
|
1408
|
+
SQLITE_API int SQLITE_CDECL sqlite3_db_config(sqlite3*, int op, ...);
|
1373
1409
|
|
1374
1410
|
/*
|
1375
1411
|
** CAPI3REF: Memory Allocation Routines
|
@@ -1503,31 +1539,33 @@ struct sqlite3_mem_methods {
|
|
1503
1539
|
** SQLITE_CONFIG_SERIALIZED configuration option.</dd>
|
1504
1540
|
**
|
1505
1541
|
** [[SQLITE_CONFIG_MALLOC]] <dt>SQLITE_CONFIG_MALLOC</dt>
|
1506
|
-
** <dd> ^(
|
1507
|
-
** instance of the [sqlite3_mem_methods] structure.
|
1542
|
+
** <dd> ^(The SQLITE_CONFIG_MALLOC option takes a single argument which is
|
1543
|
+
** a pointer to an instance of the [sqlite3_mem_methods] structure.
|
1544
|
+
** The argument specifies
|
1508
1545
|
** alternative low-level memory allocation routines to be used in place of
|
1509
1546
|
** the memory allocation routines built into SQLite.)^ ^SQLite makes
|
1510
1547
|
** its own private copy of the content of the [sqlite3_mem_methods] structure
|
1511
1548
|
** before the [sqlite3_config()] call returns.</dd>
|
1512
1549
|
**
|
1513
1550
|
** [[SQLITE_CONFIG_GETMALLOC]] <dt>SQLITE_CONFIG_GETMALLOC</dt>
|
1514
|
-
** <dd> ^(
|
1515
|
-
** instance of the [sqlite3_mem_methods] structure.
|
1551
|
+
** <dd> ^(The SQLITE_CONFIG_GETMALLOC option takes a single argument which
|
1552
|
+
** is a pointer to an instance of the [sqlite3_mem_methods] structure.
|
1553
|
+
** The [sqlite3_mem_methods]
|
1516
1554
|
** structure is filled with the currently defined memory allocation routines.)^
|
1517
1555
|
** This option can be used to overload the default memory allocation
|
1518
1556
|
** routines with a wrapper that simulations memory allocation failure or
|
1519
1557
|
** tracks memory usage, for example. </dd>
|
1520
1558
|
**
|
1521
1559
|
** [[SQLITE_CONFIG_MEMSTATUS]] <dt>SQLITE_CONFIG_MEMSTATUS</dt>
|
1522
|
-
** <dd> ^
|
1523
|
-
** boolean, which enables or disables the collection of
|
1524
|
-
** statistics. ^(When memory allocation statistics are
|
1525
|
-
** following SQLite interfaces become non-operational:
|
1560
|
+
** <dd> ^The SQLITE_CONFIG_MEMSTATUS option takes single argument of type int,
|
1561
|
+
** interpreted as a boolean, which enables or disables the collection of
|
1562
|
+
** memory allocation statistics. ^(When memory allocation statistics are
|
1563
|
+
** disabled, the following SQLite interfaces become non-operational:
|
1526
1564
|
** <ul>
|
1527
1565
|
** <li> [sqlite3_memory_used()]
|
1528
1566
|
** <li> [sqlite3_memory_highwater()]
|
1529
1567
|
** <li> [sqlite3_soft_heap_limit64()]
|
1530
|
-
** <li> [
|
1568
|
+
** <li> [sqlite3_status64()]
|
1531
1569
|
** </ul>)^
|
1532
1570
|
** ^Memory allocation statistics are enabled by default unless SQLite is
|
1533
1571
|
** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory
|
@@ -1535,53 +1573,67 @@ struct sqlite3_mem_methods {
|
|
1535
1573
|
** </dd>
|
1536
1574
|
**
|
1537
1575
|
** [[SQLITE_CONFIG_SCRATCH]] <dt>SQLITE_CONFIG_SCRATCH</dt>
|
1538
|
-
** <dd> ^
|
1539
|
-
** scratch memory. There are three arguments
|
1576
|
+
** <dd> ^The SQLITE_CONFIG_SCRATCH option specifies a static memory buffer
|
1577
|
+
** that SQLite can use for scratch memory. ^(There are three arguments
|
1578
|
+
** to SQLITE_CONFIG_SCRATCH: A pointer an 8-byte
|
1540
1579
|
** aligned memory buffer from which the scratch allocations will be
|
1541
1580
|
** drawn, the size of each scratch allocation (sz),
|
1542
|
-
** and the maximum number of scratch allocations (N).
|
1543
|
-
** argument must be a multiple of 16.
|
1581
|
+
** and the maximum number of scratch allocations (N).)^
|
1544
1582
|
** The first argument must be a pointer to an 8-byte aligned buffer
|
1545
1583
|
** of at least sz*N bytes of memory.
|
1546
|
-
** ^SQLite will use
|
1547
|
-
**
|
1548
|
-
**
|
1549
|
-
**
|
1584
|
+
** ^SQLite will not use more than one scratch buffers per thread.
|
1585
|
+
** ^SQLite will never request a scratch buffer that is more than 6
|
1586
|
+
** times the database page size.
|
1587
|
+
** ^If SQLite needs needs additional
|
1550
1588
|
** scratch memory beyond what is provided by this configuration option, then
|
1551
|
-
** [sqlite3_malloc()] will be used to obtain the memory needed
|
1589
|
+
** [sqlite3_malloc()] will be used to obtain the memory needed.<p>
|
1590
|
+
** ^When the application provides any amount of scratch memory using
|
1591
|
+
** SQLITE_CONFIG_SCRATCH, SQLite avoids unnecessary large
|
1592
|
+
** [sqlite3_malloc|heap allocations].
|
1593
|
+
** This can help [Robson proof|prevent memory allocation failures] due to heap
|
1594
|
+
** fragmentation in low-memory embedded systems.
|
1595
|
+
** </dd>
|
1552
1596
|
**
|
1553
1597
|
** [[SQLITE_CONFIG_PAGECACHE]] <dt>SQLITE_CONFIG_PAGECACHE</dt>
|
1554
|
-
** <dd> ^
|
1555
|
-
** the database page cache with the default page
|
1598
|
+
** <dd> ^The SQLITE_CONFIG_PAGECACHE option specifies a static memory buffer
|
1599
|
+
** that SQLite can use for the database page cache with the default page
|
1600
|
+
** cache implementation.
|
1556
1601
|
** This configuration should not be used if an application-define page
|
1557
|
-
** cache implementation is loaded using the SQLITE_CONFIG_PCACHE2
|
1558
|
-
**
|
1602
|
+
** cache implementation is loaded using the [SQLITE_CONFIG_PCACHE2]
|
1603
|
+
** configuration option.
|
1604
|
+
** ^There are three arguments to SQLITE_CONFIG_PAGECACHE: A pointer to
|
1605
|
+
** 8-byte aligned
|
1559
1606
|
** memory, the size of each page buffer (sz), and the number of pages (N).
|
1560
1607
|
** The sz argument should be the size of the largest database page
|
1561
|
-
** (a power of two between 512 and
|
1562
|
-
** page header. ^The
|
1563
|
-
**
|
1564
|
-
** to
|
1565
|
-
**
|
1608
|
+
** (a power of two between 512 and 65536) plus some extra bytes for each
|
1609
|
+
** page header. ^The number of extra bytes needed by the page header
|
1610
|
+
** can be determined using the [SQLITE_CONFIG_PCACHE_HDRSZ] option
|
1611
|
+
** to [sqlite3_config()].
|
1612
|
+
** ^It is harmless, apart from the wasted memory,
|
1613
|
+
** for the sz parameter to be larger than necessary. The first
|
1614
|
+
** argument should pointer to an 8-byte aligned block of memory that
|
1615
|
+
** is at least sz*N bytes of memory, otherwise subsequent behavior is
|
1616
|
+
** undefined.
|
1566
1617
|
** ^SQLite will use the memory provided by the first argument to satisfy its
|
1567
1618
|
** memory needs for the first N pages that it adds to cache. ^If additional
|
1568
1619
|
** page cache memory is needed beyond what is provided by this option, then
|
1569
|
-
** SQLite goes to [sqlite3_malloc()] for the additional storage space
|
1570
|
-
** The pointer in the first argument must
|
1571
|
-
** be aligned to an 8-byte boundary or subsequent behavior of SQLite
|
1572
|
-
** will be undefined.</dd>
|
1620
|
+
** SQLite goes to [sqlite3_malloc()] for the additional storage space.</dd>
|
1573
1621
|
**
|
1574
1622
|
** [[SQLITE_CONFIG_HEAP]] <dt>SQLITE_CONFIG_HEAP</dt>
|
1575
|
-
** <dd> ^
|
1576
|
-
** for all of its dynamic memory allocation needs
|
1577
|
-
** for by [SQLITE_CONFIG_SCRATCH] and
|
1578
|
-
**
|
1623
|
+
** <dd> ^The SQLITE_CONFIG_HEAP option specifies a static memory buffer
|
1624
|
+
** that SQLite will use for all of its dynamic memory allocation needs
|
1625
|
+
** beyond those provided for by [SQLITE_CONFIG_SCRATCH] and
|
1626
|
+
** [SQLITE_CONFIG_PAGECACHE].
|
1627
|
+
** ^The SQLITE_CONFIG_HEAP option is only available if SQLite is compiled
|
1628
|
+
** with either [SQLITE_ENABLE_MEMSYS3] or [SQLITE_ENABLE_MEMSYS5] and returns
|
1629
|
+
** [SQLITE_ERROR] if invoked otherwise.
|
1630
|
+
** ^There are three arguments to SQLITE_CONFIG_HEAP:
|
1631
|
+
** An 8-byte aligned pointer to the memory,
|
1579
1632
|
** the number of bytes in the memory buffer, and the minimum allocation size.
|
1580
1633
|
** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
|
1581
1634
|
** to using its default memory allocator (the system malloc() implementation),
|
1582
1635
|
** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the
|
1583
|
-
** memory pointer is not NULL
|
1584
|
-
** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory
|
1636
|
+
** memory pointer is not NULL then the alternative memory
|
1585
1637
|
** allocator is engaged to handle all of SQLites memory allocation needs.
|
1586
1638
|
** The first pointer (the memory pointer) must be aligned to an 8-byte
|
1587
1639
|
** boundary or subsequent behavior of SQLite will be undefined.
|
@@ -1589,11 +1641,11 @@ struct sqlite3_mem_methods {
|
|
1589
1641
|
** for the minimum allocation size are 2**5 through 2**8.</dd>
|
1590
1642
|
**
|
1591
1643
|
** [[SQLITE_CONFIG_MUTEX]] <dt>SQLITE_CONFIG_MUTEX</dt>
|
1592
|
-
** <dd> ^(
|
1593
|
-
** instance of the [sqlite3_mutex_methods] structure.
|
1594
|
-
** alternative low-level mutex routines to be used
|
1595
|
-
** the mutex routines built into SQLite.)^ ^SQLite makes a copy of
|
1596
|
-
** content of the [sqlite3_mutex_methods] structure before the call to
|
1644
|
+
** <dd> ^(The SQLITE_CONFIG_MUTEX option takes a single argument which is a
|
1645
|
+
** pointer to an instance of the [sqlite3_mutex_methods] structure.
|
1646
|
+
** The argument specifies alternative low-level mutex routines to be used
|
1647
|
+
** in place the mutex routines built into SQLite.)^ ^SQLite makes a copy of
|
1648
|
+
** the content of the [sqlite3_mutex_methods] structure before the call to
|
1597
1649
|
** [sqlite3_config()] returns. ^If SQLite is compiled with
|
1598
1650
|
** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
|
1599
1651
|
** the entire mutexing subsystem is omitted from the build and hence calls to
|
@@ -1601,8 +1653,8 @@ struct sqlite3_mem_methods {
|
|
1601
1653
|
** return [SQLITE_ERROR].</dd>
|
1602
1654
|
**
|
1603
1655
|
** [[SQLITE_CONFIG_GETMUTEX]] <dt>SQLITE_CONFIG_GETMUTEX</dt>
|
1604
|
-
** <dd> ^(
|
1605
|
-
** instance of the [sqlite3_mutex_methods] structure. The
|
1656
|
+
** <dd> ^(The SQLITE_CONFIG_GETMUTEX option takes a single argument which
|
1657
|
+
** is a pointer to an instance of the [sqlite3_mutex_methods] structure. The
|
1606
1658
|
** [sqlite3_mutex_methods]
|
1607
1659
|
** structure is filled with the currently defined mutex routines.)^
|
1608
1660
|
** This option can be used to overload the default mutex allocation
|
@@ -1614,25 +1666,25 @@ struct sqlite3_mem_methods {
|
|
1614
1666
|
** return [SQLITE_ERROR].</dd>
|
1615
1667
|
**
|
1616
1668
|
** [[SQLITE_CONFIG_LOOKASIDE]] <dt>SQLITE_CONFIG_LOOKASIDE</dt>
|
1617
|
-
** <dd> ^(
|
1618
|
-
**
|
1619
|
-
**
|
1669
|
+
** <dd> ^(The SQLITE_CONFIG_LOOKASIDE option takes two arguments that determine
|
1670
|
+
** the default size of lookaside memory on each [database connection].
|
1671
|
+
** The first argument is the
|
1620
1672
|
** size of each lookaside buffer slot and the second is the number of
|
1621
|
-
** slots allocated to each database connection.)^ ^(
|
1622
|
-
** <i>default</i> lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE]
|
1623
|
-
**
|
1673
|
+
** slots allocated to each database connection.)^ ^(SQLITE_CONFIG_LOOKASIDE
|
1674
|
+
** sets the <i>default</i> lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE]
|
1675
|
+
** option to [sqlite3_db_config()] can be used to change the lookaside
|
1624
1676
|
** configuration on individual connections.)^ </dd>
|
1625
1677
|
**
|
1626
1678
|
** [[SQLITE_CONFIG_PCACHE2]] <dt>SQLITE_CONFIG_PCACHE2</dt>
|
1627
|
-
** <dd> ^(
|
1628
|
-
** an [sqlite3_pcache_methods2] object. This object specifies
|
1629
|
-
** to a custom page cache implementation.)^
|
1630
|
-
**
|
1679
|
+
** <dd> ^(The SQLITE_CONFIG_PCACHE2 option takes a single argument which is
|
1680
|
+
** a pointer to an [sqlite3_pcache_methods2] object. This object specifies
|
1681
|
+
** the interface to a custom page cache implementation.)^
|
1682
|
+
** ^SQLite makes a copy of the [sqlite3_pcache_methods2] object.</dd>
|
1631
1683
|
**
|
1632
1684
|
** [[SQLITE_CONFIG_GETPCACHE2]] <dt>SQLITE_CONFIG_GETPCACHE2</dt>
|
1633
|
-
** <dd> ^(
|
1634
|
-
** [sqlite3_pcache_methods2] object. SQLite copies of
|
1635
|
-
** page cache implementation into that object.)^ </dd>
|
1685
|
+
** <dd> ^(The SQLITE_CONFIG_GETPCACHE2 option takes a single argument which
|
1686
|
+
** is a pointer to an [sqlite3_pcache_methods2] object. SQLite copies of
|
1687
|
+
** the current page cache implementation into that object.)^ </dd>
|
1636
1688
|
**
|
1637
1689
|
** [[SQLITE_CONFIG_LOG]] <dt>SQLITE_CONFIG_LOG</dt>
|
1638
1690
|
** <dd> The SQLITE_CONFIG_LOG option is used to configure the SQLite
|
@@ -1655,10 +1707,11 @@ struct sqlite3_mem_methods {
|
|
1655
1707
|
** function must be threadsafe. </dd>
|
1656
1708
|
**
|
1657
1709
|
** [[SQLITE_CONFIG_URI]] <dt>SQLITE_CONFIG_URI
|
1658
|
-
** <dd>^(
|
1659
|
-
** URI handling is globally enabled. If the parameter is zero,
|
1660
|
-
** is globally disabled.)^ ^If URI handling is globally
|
1661
|
-
** passed to [sqlite3_open()], [sqlite3_open_v2()],
|
1710
|
+
** <dd>^(The SQLITE_CONFIG_URI option takes a single argument of type int.
|
1711
|
+
** If non-zero, then URI handling is globally enabled. If the parameter is zero,
|
1712
|
+
** then URI handling is globally disabled.)^ ^If URI handling is globally
|
1713
|
+
** enabled, all filenames passed to [sqlite3_open()], [sqlite3_open_v2()],
|
1714
|
+
** [sqlite3_open16()] or
|
1662
1715
|
** specified as part of [ATTACH] commands are interpreted as URIs, regardless
|
1663
1716
|
** of whether or not the [SQLITE_OPEN_URI] flag is set when the database
|
1664
1717
|
** connection is opened. ^If it is globally disabled, filenames are
|
@@ -1668,9 +1721,10 @@ struct sqlite3_mem_methods {
|
|
1668
1721
|
** [SQLITE_USE_URI] symbol defined.)^
|
1669
1722
|
**
|
1670
1723
|
** [[SQLITE_CONFIG_COVERING_INDEX_SCAN]] <dt>SQLITE_CONFIG_COVERING_INDEX_SCAN
|
1671
|
-
** <dd>^
|
1672
|
-
** a boolean in order to enable or disable
|
1673
|
-
** full table scans in the query optimizer.
|
1724
|
+
** <dd>^The SQLITE_CONFIG_COVERING_INDEX_SCAN option takes a single integer
|
1725
|
+
** argument which is interpreted as a boolean in order to enable or disable
|
1726
|
+
** the use of covering indices for full table scans in the query optimizer.
|
1727
|
+
** ^The default setting is determined
|
1674
1728
|
** by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on"
|
1675
1729
|
** if that compile-time option is omitted.
|
1676
1730
|
** The ability to disable the use of covering indices for full table scans
|
@@ -1710,18 +1764,37 @@ struct sqlite3_mem_methods {
|
|
1710
1764
|
** ^The default setting can be overridden by each database connection using
|
1711
1765
|
** either the [PRAGMA mmap_size] command, or by using the
|
1712
1766
|
** [SQLITE_FCNTL_MMAP_SIZE] file control. ^(The maximum allowed mmap size
|
1713
|
-
**
|
1714
|
-
**
|
1767
|
+
** will be silently truncated if necessary so that it does not exceed the
|
1768
|
+
** compile-time maximum mmap size set by the
|
1715
1769
|
** [SQLITE_MAX_MMAP_SIZE] compile-time option.)^
|
1716
1770
|
** ^If either argument to this option is negative, then that argument is
|
1717
1771
|
** changed to its compile-time default.
|
1718
1772
|
**
|
1719
1773
|
** [[SQLITE_CONFIG_WIN32_HEAPSIZE]]
|
1720
1774
|
** <dt>SQLITE_CONFIG_WIN32_HEAPSIZE
|
1721
|
-
** <dd>^
|
1722
|
-
** with the [SQLITE_WIN32_MALLOC] pre-processor macro
|
1723
|
-
** SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
|
1775
|
+
** <dd>^The SQLITE_CONFIG_WIN32_HEAPSIZE option is only available if SQLite is
|
1776
|
+
** compiled for Windows with the [SQLITE_WIN32_MALLOC] pre-processor macro
|
1777
|
+
** defined. ^SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit unsigned integer value
|
1724
1778
|
** that specifies the maximum size of the created heap.
|
1779
|
+
**
|
1780
|
+
** [[SQLITE_CONFIG_PCACHE_HDRSZ]]
|
1781
|
+
** <dt>SQLITE_CONFIG_PCACHE_HDRSZ
|
1782
|
+
** <dd>^The SQLITE_CONFIG_PCACHE_HDRSZ option takes a single parameter which
|
1783
|
+
** is a pointer to an integer and writes into that integer the number of extra
|
1784
|
+
** bytes per page required for each page in [SQLITE_CONFIG_PAGECACHE].
|
1785
|
+
** The amount of extra space required can change depending on the compiler,
|
1786
|
+
** target platform, and SQLite version.
|
1787
|
+
**
|
1788
|
+
** [[SQLITE_CONFIG_PMASZ]]
|
1789
|
+
** <dt>SQLITE_CONFIG_PMASZ
|
1790
|
+
** <dd>^The SQLITE_CONFIG_PMASZ option takes a single parameter which
|
1791
|
+
** is an unsigned integer and sets the "Minimum PMA Size" for the multithreaded
|
1792
|
+
** sorter to that integer. The default minimum PMA Size is set by the
|
1793
|
+
** [SQLITE_SORTER_PMASZ] compile-time option. New threads are launched
|
1794
|
+
** to help with sort operations when multithreaded sorting
|
1795
|
+
** is enabled (using the [PRAGMA threads] command) and the amount of content
|
1796
|
+
** to be sorted exceeds the page size times the minimum of the
|
1797
|
+
** [PRAGMA cache_size] setting and this value.
|
1725
1798
|
** </dl>
|
1726
1799
|
*/
|
1727
1800
|
#define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */
|
@@ -1747,6 +1820,8 @@ struct sqlite3_mem_methods {
|
|
1747
1820
|
#define SQLITE_CONFIG_SQLLOG 21 /* xSqllog, void* */
|
1748
1821
|
#define SQLITE_CONFIG_MMAP_SIZE 22 /* sqlite3_int64, sqlite3_int64 */
|
1749
1822
|
#define SQLITE_CONFIG_WIN32_HEAPSIZE 23 /* int nByte */
|
1823
|
+
#define SQLITE_CONFIG_PCACHE_HDRSZ 24 /* int *psz */
|
1824
|
+
#define SQLITE_CONFIG_PMASZ 25 /* unsigned int szPma */
|
1750
1825
|
|
1751
1826
|
/*
|
1752
1827
|
** CAPI3REF: Database Connection Configuration Options
|
@@ -1813,15 +1888,17 @@ struct sqlite3_mem_methods {
|
|
1813
1888
|
|
1814
1889
|
/*
|
1815
1890
|
** CAPI3REF: Enable Or Disable Extended Result Codes
|
1891
|
+
** METHOD: sqlite3
|
1816
1892
|
**
|
1817
1893
|
** ^The sqlite3_extended_result_codes() routine enables or disables the
|
1818
1894
|
** [extended result codes] feature of SQLite. ^The extended result
|
1819
1895
|
** codes are disabled by default for historical compatibility.
|
1820
1896
|
*/
|
1821
|
-
SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);
|
1897
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_extended_result_codes(sqlite3*, int onoff);
|
1822
1898
|
|
1823
1899
|
/*
|
1824
1900
|
** CAPI3REF: Last Insert Rowid
|
1901
|
+
** METHOD: sqlite3
|
1825
1902
|
**
|
1826
1903
|
** ^Each entry in most SQLite tables (except for [WITHOUT ROWID] tables)
|
1827
1904
|
** has a unique 64-bit signed
|
@@ -1869,52 +1946,51 @@ SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);
|
|
1869
1946
|
** unpredictable and might not equal either the old or the new
|
1870
1947
|
** last insert [rowid].
|
1871
1948
|
*/
|
1872
|
-
SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
|
1949
|
+
SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_last_insert_rowid(sqlite3*);
|
1873
1950
|
|
1874
1951
|
/*
|
1875
1952
|
** CAPI3REF: Count The Number Of Rows Modified
|
1953
|
+
** METHOD: sqlite3
|
1876
1954
|
**
|
1877
|
-
** ^This function returns the number of
|
1878
|
-
**
|
1879
|
-
** on the
|
1880
|
-
** ^
|
1881
|
-
**
|
1882
|
-
**
|
1883
|
-
**
|
1884
|
-
**
|
1885
|
-
**
|
1886
|
-
**
|
1887
|
-
**
|
1888
|
-
**
|
1889
|
-
**
|
1890
|
-
**
|
1891
|
-
** are
|
1892
|
-
**
|
1893
|
-
**
|
1894
|
-
**
|
1895
|
-
**
|
1896
|
-
**
|
1897
|
-
**
|
1898
|
-
**
|
1899
|
-
**
|
1900
|
-
**
|
1901
|
-
**
|
1902
|
-
**
|
1903
|
-
** ^
|
1904
|
-
**
|
1905
|
-
**
|
1906
|
-
**
|
1907
|
-
**
|
1908
|
-
**
|
1909
|
-
**
|
1910
|
-
** ^
|
1911
|
-
**
|
1912
|
-
**
|
1913
|
-
** the
|
1914
|
-
**
|
1915
|
-
**
|
1916
|
-
** However, the number returned does not include changes
|
1917
|
-
** caused by subtriggers since those have their own context.)^
|
1955
|
+
** ^This function returns the number of rows modified, inserted or
|
1956
|
+
** deleted by the most recently completed INSERT, UPDATE or DELETE
|
1957
|
+
** statement on the database connection specified by the only parameter.
|
1958
|
+
** ^Executing any other type of SQL statement does not modify the value
|
1959
|
+
** returned by this function.
|
1960
|
+
**
|
1961
|
+
** ^Only changes made directly by the INSERT, UPDATE or DELETE statement are
|
1962
|
+
** considered - auxiliary changes caused by [CREATE TRIGGER | triggers],
|
1963
|
+
** [foreign key actions] or [REPLACE] constraint resolution are not counted.
|
1964
|
+
**
|
1965
|
+
** Changes to a view that are intercepted by
|
1966
|
+
** [INSTEAD OF trigger | INSTEAD OF triggers] are not counted. ^The value
|
1967
|
+
** returned by sqlite3_changes() immediately after an INSERT, UPDATE or
|
1968
|
+
** DELETE statement run on a view is always zero. Only changes made to real
|
1969
|
+
** tables are counted.
|
1970
|
+
**
|
1971
|
+
** Things are more complicated if the sqlite3_changes() function is
|
1972
|
+
** executed while a trigger program is running. This may happen if the
|
1973
|
+
** program uses the [changes() SQL function], or if some other callback
|
1974
|
+
** function invokes sqlite3_changes() directly. Essentially:
|
1975
|
+
**
|
1976
|
+
** <ul>
|
1977
|
+
** <li> ^(Before entering a trigger program the value returned by
|
1978
|
+
** sqlite3_changes() function is saved. After the trigger program
|
1979
|
+
** has finished, the original value is restored.)^
|
1980
|
+
**
|
1981
|
+
** <li> ^(Within a trigger program each INSERT, UPDATE and DELETE
|
1982
|
+
** statement sets the value returned by sqlite3_changes()
|
1983
|
+
** upon completion as normal. Of course, this value will not include
|
1984
|
+
** any changes performed by sub-triggers, as the sqlite3_changes()
|
1985
|
+
** value will be saved and restored after each sub-trigger has run.)^
|
1986
|
+
** </ul>
|
1987
|
+
**
|
1988
|
+
** ^This means that if the changes() SQL function (or similar) is used
|
1989
|
+
** by the first INSERT, UPDATE or DELETE statement within a trigger, it
|
1990
|
+
** returns the value as set when the calling statement began executing.
|
1991
|
+
** ^If it is used by the second or subsequent such statement within a trigger
|
1992
|
+
** program, the value returned reflects the number of rows modified by the
|
1993
|
+
** previous INSERT, UPDATE or DELETE statement within the same trigger.
|
1918
1994
|
**
|
1919
1995
|
** See also the [sqlite3_total_changes()] interface, the
|
1920
1996
|
** [count_changes pragma], and the [changes() SQL function].
|
@@ -1923,25 +1999,23 @@ SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
|
|
1923
1999
|
** while [sqlite3_changes()] is running then the value returned
|
1924
2000
|
** is unpredictable and not meaningful.
|
1925
2001
|
*/
|
1926
|
-
SQLITE_API int sqlite3_changes(sqlite3*);
|
2002
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_changes(sqlite3*);
|
1927
2003
|
|
1928
2004
|
/*
|
1929
2005
|
** CAPI3REF: Total Number Of Rows Modified
|
2006
|
+
** METHOD: sqlite3
|
1930
2007
|
**
|
1931
|
-
** ^This function returns the number of
|
1932
|
-
** [UPDATE] or [DELETE] statements
|
1933
|
-
**
|
1934
|
-
**
|
1935
|
-
**
|
1936
|
-
**
|
1937
|
-
**
|
1938
|
-
** count
|
1939
|
-
**
|
1940
|
-
** are counted.
|
1941
|
-
**
|
1942
|
-
** the statement that makes them is completed (when the statement handle
|
1943
|
-
** is passed to [sqlite3_reset()] or [sqlite3_finalize()]).
|
1944
|
-
**
|
2008
|
+
** ^This function returns the total number of rows inserted, modified or
|
2009
|
+
** deleted by all [INSERT], [UPDATE] or [DELETE] statements completed
|
2010
|
+
** since the database connection was opened, including those executed as
|
2011
|
+
** part of trigger programs. ^Executing any other type of SQL statement
|
2012
|
+
** does not affect the value returned by sqlite3_total_changes().
|
2013
|
+
**
|
2014
|
+
** ^Changes made as part of [foreign key actions] are included in the
|
2015
|
+
** count, but those made as part of REPLACE constraint resolution are
|
2016
|
+
** not. ^Changes to a view that are intercepted by INSTEAD OF triggers
|
2017
|
+
** are not counted.
|
2018
|
+
**
|
1945
2019
|
** See also the [sqlite3_changes()] interface, the
|
1946
2020
|
** [count_changes pragma], and the [total_changes() SQL function].
|
1947
2021
|
**
|
@@ -1949,10 +2023,11 @@ SQLITE_API int sqlite3_changes(sqlite3*);
|
|
1949
2023
|
** while [sqlite3_total_changes()] is running then the value
|
1950
2024
|
** returned is unpredictable and not meaningful.
|
1951
2025
|
*/
|
1952
|
-
SQLITE_API int sqlite3_total_changes(sqlite3*);
|
2026
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_total_changes(sqlite3*);
|
1953
2027
|
|
1954
2028
|
/*
|
1955
2029
|
** CAPI3REF: Interrupt A Long-Running Query
|
2030
|
+
** METHOD: sqlite3
|
1956
2031
|
**
|
1957
2032
|
** ^This function causes any pending database operation to abort and
|
1958
2033
|
** return at its earliest opportunity. This routine is typically
|
@@ -1988,7 +2063,7 @@ SQLITE_API int sqlite3_total_changes(sqlite3*);
|
|
1988
2063
|
** If the database connection closes while [sqlite3_interrupt()]
|
1989
2064
|
** is running then bad things will likely happen.
|
1990
2065
|
*/
|
1991
|
-
SQLITE_API void sqlite3_interrupt(sqlite3*);
|
2066
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_interrupt(sqlite3*);
|
1992
2067
|
|
1993
2068
|
/*
|
1994
2069
|
** CAPI3REF: Determine If An SQL Statement Is Complete
|
@@ -2023,11 +2098,13 @@ SQLITE_API void sqlite3_interrupt(sqlite3*);
|
|
2023
2098
|
** The input to [sqlite3_complete16()] must be a zero-terminated
|
2024
2099
|
** UTF-16 string in native byte order.
|
2025
2100
|
*/
|
2026
|
-
SQLITE_API int sqlite3_complete(const char *sql);
|
2027
|
-
SQLITE_API int sqlite3_complete16(const void *sql);
|
2101
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_complete(const char *sql);
|
2102
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_complete16(const void *sql);
|
2028
2103
|
|
2029
2104
|
/*
|
2030
2105
|
** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors
|
2106
|
+
** KEYWORDS: {busy-handler callback} {busy handler}
|
2107
|
+
** METHOD: sqlite3
|
2031
2108
|
**
|
2032
2109
|
** ^The sqlite3_busy_handler(D,X,P) routine sets a callback function X
|
2033
2110
|
** that might be invoked with argument P whenever
|
@@ -2044,7 +2121,7 @@ SQLITE_API int sqlite3_complete16(const void *sql);
|
|
2044
2121
|
** ^The first argument to the busy handler is a copy of the void* pointer which
|
2045
2122
|
** is the third argument to sqlite3_busy_handler(). ^The second argument to
|
2046
2123
|
** the busy handler callback is the number of times that the busy handler has
|
2047
|
-
** been invoked for the same locking event. ^If the
|
2124
|
+
** been invoked previously for the same locking event. ^If the
|
2048
2125
|
** busy callback returns 0, then no additional attempts are made to
|
2049
2126
|
** access the database and [SQLITE_BUSY] is returned
|
2050
2127
|
** to the application.
|
@@ -2083,10 +2160,11 @@ SQLITE_API int sqlite3_complete16(const void *sql);
|
|
2083
2160
|
** A busy handler must not close the database connection
|
2084
2161
|
** or [prepared statement] that invoked the busy handler.
|
2085
2162
|
*/
|
2086
|
-
SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
|
2163
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
|
2087
2164
|
|
2088
2165
|
/*
|
2089
2166
|
** CAPI3REF: Set A Busy Timeout
|
2167
|
+
** METHOD: sqlite3
|
2090
2168
|
**
|
2091
2169
|
** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps
|
2092
2170
|
** for a specified amount of time when a table is locked. ^The handler
|
@@ -2099,16 +2177,17 @@ SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
|
|
2099
2177
|
** turns off all busy handlers.
|
2100
2178
|
**
|
2101
2179
|
** ^(There can only be a single busy handler for a particular
|
2102
|
-
** [database connection]
|
2180
|
+
** [database connection] at any given moment. If another busy handler
|
2103
2181
|
** was defined (using [sqlite3_busy_handler()]) prior to calling
|
2104
2182
|
** this routine, that other busy handler is cleared.)^
|
2105
2183
|
**
|
2106
2184
|
** See also: [PRAGMA busy_timeout]
|
2107
2185
|
*/
|
2108
|
-
SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);
|
2186
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_busy_timeout(sqlite3*, int ms);
|
2109
2187
|
|
2110
2188
|
/*
|
2111
2189
|
** CAPI3REF: Convenience Routines For Running Queries
|
2190
|
+
** METHOD: sqlite3
|
2112
2191
|
**
|
2113
2192
|
** This is a legacy interface that is preserved for backwards compatibility.
|
2114
2193
|
** Use of this interface is not recommended.
|
@@ -2179,7 +2258,7 @@ SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);
|
|
2179
2258
|
** reflected in subsequent calls to [sqlite3_errcode()] or
|
2180
2259
|
** [sqlite3_errmsg()].
|
2181
2260
|
*/
|
2182
|
-
SQLITE_API int sqlite3_get_table(
|
2261
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_get_table(
|
2183
2262
|
sqlite3 *db, /* An open database */
|
2184
2263
|
const char *zSql, /* SQL to be evaluated */
|
2185
2264
|
char ***pazResult, /* Results of the query */
|
@@ -2187,13 +2266,17 @@ SQLITE_API int sqlite3_get_table(
|
|
2187
2266
|
int *pnColumn, /* Number of result columns written here */
|
2188
2267
|
char **pzErrmsg /* Error msg written here */
|
2189
2268
|
);
|
2190
|
-
SQLITE_API void sqlite3_free_table(char **result);
|
2269
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_free_table(char **result);
|
2191
2270
|
|
2192
2271
|
/*
|
2193
2272
|
** CAPI3REF: Formatted String Printing Functions
|
2194
2273
|
**
|
2195
2274
|
** These routines are work-alikes of the "printf()" family of functions
|
2196
2275
|
** from the standard C library.
|
2276
|
+
** These routines understand most of the common K&R formatting options,
|
2277
|
+
** plus some additional non-standard formats, detailed below.
|
2278
|
+
** Note that some of the more obscure formatting options from recent
|
2279
|
+
** C-library standards are omitted from this implementation.
|
2197
2280
|
**
|
2198
2281
|
** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
|
2199
2282
|
** results into memory obtained from [sqlite3_malloc()].
|
@@ -2226,7 +2309,7 @@ SQLITE_API void sqlite3_free_table(char **result);
|
|
2226
2309
|
** These routines all implement some additional formatting
|
2227
2310
|
** options that are useful for constructing SQL statements.
|
2228
2311
|
** All of the usual printf() formatting options apply. In addition, there
|
2229
|
-
** is are "%q", "%Q", and "%z" options.
|
2312
|
+
** is are "%q", "%Q", "%w" and "%z" options.
|
2230
2313
|
**
|
2231
2314
|
** ^(The %q option works like %s in that it substitutes a nul-terminated
|
2232
2315
|
** string from the argument list. But %q also doubles every '\'' character.
|
@@ -2279,14 +2362,20 @@ SQLITE_API void sqlite3_free_table(char **result);
|
|
2279
2362
|
** The code above will render a correct SQL statement in the zSQL
|
2280
2363
|
** variable even if the zText variable is a NULL pointer.
|
2281
2364
|
**
|
2365
|
+
** ^(The "%w" formatting option is like "%q" except that it expects to
|
2366
|
+
** be contained within double-quotes instead of single quotes, and it
|
2367
|
+
** escapes the double-quote character instead of the single-quote
|
2368
|
+
** character.)^ The "%w" formatting option is intended for safely inserting
|
2369
|
+
** table and column names into a constructed SQL statement.
|
2370
|
+
**
|
2282
2371
|
** ^(The "%z" formatting option works like "%s" but with the
|
2283
2372
|
** addition that after the string has been read and copied into
|
2284
2373
|
** the result, [sqlite3_free()] is called on the input string.)^
|
2285
2374
|
*/
|
2286
|
-
SQLITE_API char *sqlite3_mprintf(const char*,...);
|
2287
|
-
SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
|
2288
|
-
SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
|
2289
|
-
SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
|
2375
|
+
SQLITE_API char *SQLITE_CDECL sqlite3_mprintf(const char*,...);
|
2376
|
+
SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf(const char*, va_list);
|
2377
|
+
SQLITE_API char *SQLITE_CDECL sqlite3_snprintf(int,char*,const char*, ...);
|
2378
|
+
SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf(int,char*,const char*, va_list);
|
2290
2379
|
|
2291
2380
|
/*
|
2292
2381
|
** CAPI3REF: Memory Allocation Subsystem
|
@@ -2303,6 +2392,10 @@ SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
|
|
2303
2392
|
** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
|
2304
2393
|
** a NULL pointer.
|
2305
2394
|
**
|
2395
|
+
** ^The sqlite3_malloc64(N) routine works just like
|
2396
|
+
** sqlite3_malloc(N) except that N is an unsigned 64-bit integer instead
|
2397
|
+
** of a signed 32-bit integer.
|
2398
|
+
**
|
2306
2399
|
** ^Calling sqlite3_free() with a pointer previously returned
|
2307
2400
|
** by sqlite3_malloc() or sqlite3_realloc() releases that memory so
|
2308
2401
|
** that it might be reused. ^The sqlite3_free() routine is
|
@@ -2314,24 +2407,38 @@ SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
|
|
2314
2407
|
** might result if sqlite3_free() is called with a non-NULL pointer that
|
2315
2408
|
** was not obtained from sqlite3_malloc() or sqlite3_realloc().
|
2316
2409
|
**
|
2317
|
-
** ^
|
2318
|
-
** prior memory allocation to be at least N bytes
|
2319
|
-
**
|
2320
|
-
** parameter.)^ ^ If the first parameter to sqlite3_realloc()
|
2410
|
+
** ^The sqlite3_realloc(X,N) interface attempts to resize a
|
2411
|
+
** prior memory allocation X to be at least N bytes.
|
2412
|
+
** ^If the X parameter to sqlite3_realloc(X,N)
|
2321
2413
|
** is a NULL pointer then its behavior is identical to calling
|
2322
|
-
** sqlite3_malloc(N)
|
2323
|
-
** ^If the
|
2414
|
+
** sqlite3_malloc(N).
|
2415
|
+
** ^If the N parameter to sqlite3_realloc(X,N) is zero or
|
2324
2416
|
** negative then the behavior is exactly the same as calling
|
2325
|
-
** sqlite3_free(
|
2326
|
-
** ^sqlite3_realloc() returns a pointer to a memory allocation
|
2327
|
-
** of at least N bytes in size or NULL if
|
2417
|
+
** sqlite3_free(X).
|
2418
|
+
** ^sqlite3_realloc(X,N) returns a pointer to a memory allocation
|
2419
|
+
** of at least N bytes in size or NULL if insufficient memory is available.
|
2328
2420
|
** ^If M is the size of the prior allocation, then min(N,M) bytes
|
2329
2421
|
** of the prior allocation are copied into the beginning of buffer returned
|
2330
|
-
** by sqlite3_realloc() and the prior allocation is freed.
|
2331
|
-
** ^If sqlite3_realloc() returns NULL, then the
|
2332
|
-
** is not freed.
|
2333
|
-
**
|
2334
|
-
** ^The
|
2422
|
+
** by sqlite3_realloc(X,N) and the prior allocation is freed.
|
2423
|
+
** ^If sqlite3_realloc(X,N) returns NULL and N is positive, then the
|
2424
|
+
** prior allocation is not freed.
|
2425
|
+
**
|
2426
|
+
** ^The sqlite3_realloc64(X,N) interfaces works the same as
|
2427
|
+
** sqlite3_realloc(X,N) except that N is a 64-bit unsigned integer instead
|
2428
|
+
** of a 32-bit signed integer.
|
2429
|
+
**
|
2430
|
+
** ^If X is a memory allocation previously obtained from sqlite3_malloc(),
|
2431
|
+
** sqlite3_malloc64(), sqlite3_realloc(), or sqlite3_realloc64(), then
|
2432
|
+
** sqlite3_msize(X) returns the size of that memory allocation in bytes.
|
2433
|
+
** ^The value returned by sqlite3_msize(X) might be larger than the number
|
2434
|
+
** of bytes requested when X was allocated. ^If X is a NULL pointer then
|
2435
|
+
** sqlite3_msize(X) returns zero. If X points to something that is not
|
2436
|
+
** the beginning of memory allocation, or if it points to a formerly
|
2437
|
+
** valid memory allocation that has now been freed, then the behavior
|
2438
|
+
** of sqlite3_msize(X) is undefined and possibly harmful.
|
2439
|
+
**
|
2440
|
+
** ^The memory returned by sqlite3_malloc(), sqlite3_realloc(),
|
2441
|
+
** sqlite3_malloc64(), and sqlite3_realloc64()
|
2335
2442
|
** is always aligned to at least an 8 byte boundary, or to a
|
2336
2443
|
** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time
|
2337
2444
|
** option is used.
|
@@ -2358,9 +2465,12 @@ SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
|
|
2358
2465
|
** a block of memory after it has been released using
|
2359
2466
|
** [sqlite3_free()] or [sqlite3_realloc()].
|
2360
2467
|
*/
|
2361
|
-
SQLITE_API void *sqlite3_malloc(int);
|
2362
|
-
SQLITE_API void *
|
2363
|
-
SQLITE_API void
|
2468
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_malloc(int);
|
2469
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_malloc64(sqlite3_uint64);
|
2470
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_realloc(void*, int);
|
2471
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_realloc64(void*, sqlite3_uint64);
|
2472
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_free(void*);
|
2473
|
+
SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize(void*);
|
2364
2474
|
|
2365
2475
|
/*
|
2366
2476
|
** CAPI3REF: Memory Allocator Statistics
|
@@ -2385,8 +2495,8 @@ SQLITE_API void sqlite3_free(void*);
|
|
2385
2495
|
** by [sqlite3_memory_highwater(1)] is the high-water mark
|
2386
2496
|
** prior to the reset.
|
2387
2497
|
*/
|
2388
|
-
SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
|
2389
|
-
SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
|
2498
|
+
SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_used(void);
|
2499
|
+
SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_highwater(int resetFlag);
|
2390
2500
|
|
2391
2501
|
/*
|
2392
2502
|
** CAPI3REF: Pseudo-Random Number Generator
|
@@ -2398,20 +2508,22 @@ SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
|
|
2398
2508
|
** applications to access the same PRNG for other purposes.
|
2399
2509
|
**
|
2400
2510
|
** ^A call to this routine stores N bytes of randomness into buffer P.
|
2401
|
-
** ^
|
2511
|
+
** ^The P parameter can be a NULL pointer.
|
2402
2512
|
**
|
2403
2513
|
** ^If this routine has not been previously called or if the previous
|
2404
|
-
** call had N less than one, then the PRNG is
|
2405
|
-
** obtained from the xRandomness method of
|
2406
|
-
**
|
2407
|
-
** the
|
2514
|
+
** call had N less than one or a NULL pointer for P, then the PRNG is
|
2515
|
+
** seeded using randomness obtained from the xRandomness method of
|
2516
|
+
** the default [sqlite3_vfs] object.
|
2517
|
+
** ^If the previous call to this routine had an N of 1 or more and a
|
2518
|
+
** non-NULL P then the pseudo-randomness is generated
|
2408
2519
|
** internally and without recourse to the [sqlite3_vfs] xRandomness
|
2409
2520
|
** method.
|
2410
2521
|
*/
|
2411
|
-
SQLITE_API void sqlite3_randomness(int N, void *P);
|
2522
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_randomness(int N, void *P);
|
2412
2523
|
|
2413
2524
|
/*
|
2414
2525
|
** CAPI3REF: Compile-Time Authorization Callbacks
|
2526
|
+
** METHOD: sqlite3
|
2415
2527
|
**
|
2416
2528
|
** ^This routine registers an authorizer callback with a particular
|
2417
2529
|
** [database connection], supplied in the first argument.
|
@@ -2490,7 +2602,7 @@ SQLITE_API void sqlite3_randomness(int N, void *P);
|
|
2490
2602
|
** as stated in the previous paragraph, sqlite3_step() invokes
|
2491
2603
|
** sqlite3_prepare_v2() to reprepare a statement after a schema change.
|
2492
2604
|
*/
|
2493
|
-
SQLITE_API int sqlite3_set_authorizer(
|
2605
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_set_authorizer(
|
2494
2606
|
sqlite3*,
|
2495
2607
|
int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
|
2496
2608
|
void *pUserData
|
@@ -2568,6 +2680,7 @@ SQLITE_API int sqlite3_set_authorizer(
|
|
2568
2680
|
|
2569
2681
|
/*
|
2570
2682
|
** CAPI3REF: Tracing And Profiling Functions
|
2683
|
+
** METHOD: sqlite3
|
2571
2684
|
**
|
2572
2685
|
** These routines register callback functions that can be used for
|
2573
2686
|
** tracing and profiling the execution of SQL statements.
|
@@ -2594,12 +2707,13 @@ SQLITE_API int sqlite3_set_authorizer(
|
|
2594
2707
|
** sqlite3_profile() function is considered experimental and is
|
2595
2708
|
** subject to change in future versions of SQLite.
|
2596
2709
|
*/
|
2597
|
-
SQLITE_API void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
|
2598
|
-
SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
|
2710
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
|
2711
|
+
SQLITE_API SQLITE_EXPERIMENTAL void *SQLITE_STDCALL sqlite3_profile(sqlite3*,
|
2599
2712
|
void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
|
2600
2713
|
|
2601
2714
|
/*
|
2602
2715
|
** CAPI3REF: Query Progress Callbacks
|
2716
|
+
** METHOD: sqlite3
|
2603
2717
|
**
|
2604
2718
|
** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback
|
2605
2719
|
** function X to be invoked periodically during long running calls to
|
@@ -2629,10 +2743,11 @@ SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
|
|
2629
2743
|
** database connections for the meaning of "modify" in this paragraph.
|
2630
2744
|
**
|
2631
2745
|
*/
|
2632
|
-
SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
|
2746
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
|
2633
2747
|
|
2634
2748
|
/*
|
2635
2749
|
** CAPI3REF: Opening A New Database Connection
|
2750
|
+
** CONSTRUCTOR: sqlite3
|
2636
2751
|
**
|
2637
2752
|
** ^These routines open an SQLite database file as specified by the
|
2638
2753
|
** filename argument. ^The filename argument is interpreted as UTF-8 for
|
@@ -2647,9 +2762,9 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
|
|
2647
2762
|
** an English language description of the error following a failure of any
|
2648
2763
|
** of the sqlite3_open() routines.
|
2649
2764
|
**
|
2650
|
-
** ^The default encoding
|
2651
|
-
** sqlite3_open() or sqlite3_open_v2()
|
2652
|
-
** UTF-16 in the native byte order
|
2765
|
+
** ^The default encoding will be UTF-8 for databases created using
|
2766
|
+
** sqlite3_open() or sqlite3_open_v2(). ^The default encoding for databases
|
2767
|
+
** created using sqlite3_open16() will be UTF-16 in the native byte order.
|
2653
2768
|
**
|
2654
2769
|
** Whether or not an error occurs when it is opened, resources
|
2655
2770
|
** associated with the [database connection] handle should be released by
|
@@ -2737,13 +2852,14 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
|
|
2737
2852
|
** then it is interpreted as an absolute path. ^If the path does not begin
|
2738
2853
|
** with a '/' (meaning that the authority section is omitted from the URI)
|
2739
2854
|
** then the path is interpreted as a relative path.
|
2740
|
-
** ^On windows, the first component of an absolute path
|
2741
|
-
** is a drive specification (e.g. "C:").
|
2855
|
+
** ^(On windows, the first component of an absolute path
|
2856
|
+
** is a drive specification (e.g. "C:").)^
|
2742
2857
|
**
|
2743
2858
|
** [[core URI query parameters]]
|
2744
2859
|
** The query component of a URI may contain parameters that are interpreted
|
2745
2860
|
** either by SQLite itself, or by a [VFS | custom VFS implementation].
|
2746
|
-
** SQLite
|
2861
|
+
** SQLite and its built-in [VFSes] interpret the
|
2862
|
+
** following query parameters:
|
2747
2863
|
**
|
2748
2864
|
** <ul>
|
2749
2865
|
** <li> <b>vfs</b>: ^The "vfs" parameter may be used to specify the name of
|
@@ -2778,11 +2894,9 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
|
|
2778
2894
|
** a URI filename, its value overrides any behavior requested by setting
|
2779
2895
|
** SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag.
|
2780
2896
|
**
|
2781
|
-
** <li> <b>psow</b>: ^The psow parameter
|
2782
|
-
** "1") or "false" (or "off" or "no" or "0") to indicate that the
|
2897
|
+
** <li> <b>psow</b>: ^The psow parameter indicates whether or not the
|
2783
2898
|
** [powersafe overwrite] property does or does not apply to the
|
2784
|
-
** storage media on which the database file resides.
|
2785
|
-
** parameter only works for the built-in unix and Windows VFSes.
|
2899
|
+
** storage media on which the database file resides.
|
2786
2900
|
**
|
2787
2901
|
** <li> <b>nolock</b>: ^The nolock parameter is a boolean query parameter
|
2788
2902
|
** which if set disables file locking in rollback journal modes. This
|
@@ -2858,15 +2972,15 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
|
|
2858
2972
|
**
|
2859
2973
|
** See also: [sqlite3_temp_directory]
|
2860
2974
|
*/
|
2861
|
-
SQLITE_API int sqlite3_open(
|
2975
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_open(
|
2862
2976
|
const char *filename, /* Database filename (UTF-8) */
|
2863
2977
|
sqlite3 **ppDb /* OUT: SQLite db handle */
|
2864
2978
|
);
|
2865
|
-
SQLITE_API int sqlite3_open16(
|
2979
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_open16(
|
2866
2980
|
const void *filename, /* Database filename (UTF-16) */
|
2867
2981
|
sqlite3 **ppDb /* OUT: SQLite db handle */
|
2868
2982
|
);
|
2869
|
-
SQLITE_API int sqlite3_open_v2(
|
2983
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_open_v2(
|
2870
2984
|
const char *filename, /* Database filename (UTF-8) */
|
2871
2985
|
sqlite3 **ppDb, /* OUT: SQLite db handle */
|
2872
2986
|
int flags, /* Flags */
|
@@ -2912,19 +3026,22 @@ SQLITE_API int sqlite3_open_v2(
|
|
2912
3026
|
** VFS method, then the behavior of this routine is undefined and probably
|
2913
3027
|
** undesirable.
|
2914
3028
|
*/
|
2915
|
-
SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
|
2916
|
-
SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
|
2917
|
-
SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
|
3029
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_uri_parameter(const char *zFilename, const char *zParam);
|
3030
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
|
3031
|
+
SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
|
2918
3032
|
|
2919
3033
|
|
2920
3034
|
/*
|
2921
3035
|
** CAPI3REF: Error Codes And Messages
|
2922
|
-
**
|
2923
|
-
**
|
2924
|
-
**
|
2925
|
-
**
|
2926
|
-
**
|
2927
|
-
**
|
3036
|
+
** METHOD: sqlite3
|
3037
|
+
**
|
3038
|
+
** ^If the most recent sqlite3_* API call associated with
|
3039
|
+
** [database connection] D failed, then the sqlite3_errcode(D) interface
|
3040
|
+
** returns the numeric [result code] or [extended result code] for that
|
3041
|
+
** API call.
|
3042
|
+
** If the most recent API call was successful,
|
3043
|
+
** then the return value from sqlite3_errcode() is undefined.
|
3044
|
+
** ^The sqlite3_extended_errcode()
|
2928
3045
|
** interface is the same except that it always returns the
|
2929
3046
|
** [extended result code] even when extended result codes are
|
2930
3047
|
** disabled.
|
@@ -2955,40 +3072,41 @@ SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int
|
|
2955
3072
|
** was invoked incorrectly by the application. In that case, the
|
2956
3073
|
** error code and message may or may not be set.
|
2957
3074
|
*/
|
2958
|
-
SQLITE_API int sqlite3_errcode(sqlite3 *db);
|
2959
|
-
SQLITE_API int sqlite3_extended_errcode(sqlite3 *db);
|
2960
|
-
SQLITE_API const char *sqlite3_errmsg(sqlite3*);
|
2961
|
-
SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
|
2962
|
-
SQLITE_API const char *sqlite3_errstr(int);
|
3075
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_errcode(sqlite3 *db);
|
3076
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_extended_errcode(sqlite3 *db);
|
3077
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_errmsg(sqlite3*);
|
3078
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_errmsg16(sqlite3*);
|
3079
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_errstr(int);
|
2963
3080
|
|
2964
3081
|
/*
|
2965
|
-
** CAPI3REF:
|
3082
|
+
** CAPI3REF: Prepared Statement Object
|
2966
3083
|
** KEYWORDS: {prepared statement} {prepared statements}
|
2967
3084
|
**
|
2968
|
-
** An instance of this object represents a single SQL statement
|
2969
|
-
**
|
2970
|
-
**
|
3085
|
+
** An instance of this object represents a single SQL statement that
|
3086
|
+
** has been compiled into binary form and is ready to be evaluated.
|
3087
|
+
**
|
3088
|
+
** Think of each SQL statement as a separate computer program. The
|
3089
|
+
** original SQL text is source code. A prepared statement object
|
3090
|
+
** is the compiled object code. All SQL must be converted into a
|
3091
|
+
** prepared statement before it can be run.
|
2971
3092
|
**
|
2972
|
-
** The life of a statement object goes
|
3093
|
+
** The life-cycle of a prepared statement object usually goes like this:
|
2973
3094
|
**
|
2974
3095
|
** <ol>
|
2975
|
-
** <li> Create the object using [sqlite3_prepare_v2()]
|
2976
|
-
**
|
2977
|
-
** <li> Bind values to [host parameters] using the sqlite3_bind_*()
|
3096
|
+
** <li> Create the prepared statement object using [sqlite3_prepare_v2()].
|
3097
|
+
** <li> Bind values to [parameters] using the sqlite3_bind_*()
|
2978
3098
|
** interfaces.
|
2979
3099
|
** <li> Run the SQL by calling [sqlite3_step()] one or more times.
|
2980
|
-
** <li> Reset the statement using [sqlite3_reset()] then go back
|
3100
|
+
** <li> Reset the prepared statement using [sqlite3_reset()] then go back
|
2981
3101
|
** to step 2. Do this zero or more times.
|
2982
3102
|
** <li> Destroy the object using [sqlite3_finalize()].
|
2983
3103
|
** </ol>
|
2984
|
-
**
|
2985
|
-
** Refer to documentation on individual methods above for additional
|
2986
|
-
** information.
|
2987
3104
|
*/
|
2988
3105
|
typedef struct sqlite3_stmt sqlite3_stmt;
|
2989
3106
|
|
2990
3107
|
/*
|
2991
3108
|
** CAPI3REF: Run-time Limits
|
3109
|
+
** METHOD: sqlite3
|
2992
3110
|
**
|
2993
3111
|
** ^(This interface allows the size of various constructs to be limited
|
2994
3112
|
** on a connection by connection basis. The first parameter is the
|
@@ -3026,7 +3144,7 @@ typedef struct sqlite3_stmt sqlite3_stmt;
|
|
3026
3144
|
**
|
3027
3145
|
** New run-time limit categories may be added in future releases.
|
3028
3146
|
*/
|
3029
|
-
SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
|
3147
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_limit(sqlite3*, int id, int newVal);
|
3030
3148
|
|
3031
3149
|
/*
|
3032
3150
|
** CAPI3REF: Run-Time Limit Categories
|
@@ -3078,6 +3196,10 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
|
|
3078
3196
|
**
|
3079
3197
|
** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
|
3080
3198
|
** <dd>The maximum depth of recursion for triggers.</dd>)^
|
3199
|
+
**
|
3200
|
+
** [[SQLITE_LIMIT_WORKER_THREADS]] ^(<dt>SQLITE_LIMIT_WORKER_THREADS</dt>
|
3201
|
+
** <dd>The maximum number of auxiliary worker threads that a single
|
3202
|
+
** [prepared statement] may start.</dd>)^
|
3081
3203
|
** </dl>
|
3082
3204
|
*/
|
3083
3205
|
#define SQLITE_LIMIT_LENGTH 0
|
@@ -3091,10 +3213,13 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
|
|
3091
3213
|
#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8
|
3092
3214
|
#define SQLITE_LIMIT_VARIABLE_NUMBER 9
|
3093
3215
|
#define SQLITE_LIMIT_TRIGGER_DEPTH 10
|
3216
|
+
#define SQLITE_LIMIT_WORKER_THREADS 11
|
3094
3217
|
|
3095
3218
|
/*
|
3096
3219
|
** CAPI3REF: Compiling An SQL Statement
|
3097
3220
|
** KEYWORDS: {SQL statement compiler}
|
3221
|
+
** METHOD: sqlite3
|
3222
|
+
** CONSTRUCTOR: sqlite3_stmt
|
3098
3223
|
**
|
3099
3224
|
** To execute an SQL query, it must first be compiled into a byte-code
|
3100
3225
|
** program using one of these routines.
|
@@ -3108,16 +3233,14 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
|
|
3108
3233
|
** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2()
|
3109
3234
|
** use UTF-16.
|
3110
3235
|
**
|
3111
|
-
** ^If the nByte argument is
|
3112
|
-
** first zero terminator. ^If nByte is
|
3113
|
-
** number of
|
3114
|
-
**
|
3115
|
-
** the
|
3116
|
-
**
|
3117
|
-
**
|
3118
|
-
**
|
3119
|
-
** the nul-terminator bytes as this saves SQLite from having to
|
3120
|
-
** make a copy of the input string.
|
3236
|
+
** ^If the nByte argument is negative, then zSql is read up to the
|
3237
|
+
** first zero terminator. ^If nByte is positive, then it is the
|
3238
|
+
** number of bytes read from zSql. ^If nByte is zero, then no prepared
|
3239
|
+
** statement is generated.
|
3240
|
+
** If the caller knows that the supplied string is nul-terminated, then
|
3241
|
+
** there is a small performance advantage to passing an nByte parameter that
|
3242
|
+
** is the number of bytes in the input string <i>including</i>
|
3243
|
+
** the nul-terminator.
|
3121
3244
|
**
|
3122
3245
|
** ^If pzTail is not NULL then *pzTail is made to point to the first byte
|
3123
3246
|
** past the end of the first SQL statement in zSql. These routines only
|
@@ -3173,28 +3296,28 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
|
|
3173
3296
|
** </li>
|
3174
3297
|
** </ol>
|
3175
3298
|
*/
|
3176
|
-
SQLITE_API int sqlite3_prepare(
|
3299
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_prepare(
|
3177
3300
|
sqlite3 *db, /* Database handle */
|
3178
3301
|
const char *zSql, /* SQL statement, UTF-8 encoded */
|
3179
3302
|
int nByte, /* Maximum length of zSql in bytes. */
|
3180
3303
|
sqlite3_stmt **ppStmt, /* OUT: Statement handle */
|
3181
3304
|
const char **pzTail /* OUT: Pointer to unused portion of zSql */
|
3182
3305
|
);
|
3183
|
-
SQLITE_API int sqlite3_prepare_v2(
|
3306
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_prepare_v2(
|
3184
3307
|
sqlite3 *db, /* Database handle */
|
3185
3308
|
const char *zSql, /* SQL statement, UTF-8 encoded */
|
3186
3309
|
int nByte, /* Maximum length of zSql in bytes. */
|
3187
3310
|
sqlite3_stmt **ppStmt, /* OUT: Statement handle */
|
3188
3311
|
const char **pzTail /* OUT: Pointer to unused portion of zSql */
|
3189
3312
|
);
|
3190
|
-
SQLITE_API int sqlite3_prepare16(
|
3313
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_prepare16(
|
3191
3314
|
sqlite3 *db, /* Database handle */
|
3192
3315
|
const void *zSql, /* SQL statement, UTF-16 encoded */
|
3193
3316
|
int nByte, /* Maximum length of zSql in bytes. */
|
3194
3317
|
sqlite3_stmt **ppStmt, /* OUT: Statement handle */
|
3195
3318
|
const void **pzTail /* OUT: Pointer to unused portion of zSql */
|
3196
3319
|
);
|
3197
|
-
SQLITE_API int sqlite3_prepare16_v2(
|
3320
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_prepare16_v2(
|
3198
3321
|
sqlite3 *db, /* Database handle */
|
3199
3322
|
const void *zSql, /* SQL statement, UTF-16 encoded */
|
3200
3323
|
int nByte, /* Maximum length of zSql in bytes. */
|
@@ -3204,15 +3327,17 @@ SQLITE_API int sqlite3_prepare16_v2(
|
|
3204
3327
|
|
3205
3328
|
/*
|
3206
3329
|
** CAPI3REF: Retrieving Statement SQL
|
3330
|
+
** METHOD: sqlite3_stmt
|
3207
3331
|
**
|
3208
3332
|
** ^This interface can be used to retrieve a saved copy of the original
|
3209
3333
|
** SQL text used to create a [prepared statement] if that statement was
|
3210
3334
|
** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
|
3211
3335
|
*/
|
3212
|
-
SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
|
3336
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_sql(sqlite3_stmt *pStmt);
|
3213
3337
|
|
3214
3338
|
/*
|
3215
3339
|
** CAPI3REF: Determine If An SQL Statement Writes The Database
|
3340
|
+
** METHOD: sqlite3_stmt
|
3216
3341
|
**
|
3217
3342
|
** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if
|
3218
3343
|
** and only if the [prepared statement] X makes no direct changes to
|
@@ -3240,10 +3365,11 @@ SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
|
|
3240
3365
|
** change the configuration of a database connection, they do not make
|
3241
3366
|
** changes to the content of the database files on disk.
|
3242
3367
|
*/
|
3243
|
-
SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
|
3368
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
|
3244
3369
|
|
3245
3370
|
/*
|
3246
3371
|
** CAPI3REF: Determine If A Prepared Statement Has Been Reset
|
3372
|
+
** METHOD: sqlite3_stmt
|
3247
3373
|
**
|
3248
3374
|
** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the
|
3249
3375
|
** [prepared statement] S has been stepped at least once using
|
@@ -3259,7 +3385,7 @@ SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
|
|
3259
3385
|
** for example, in diagnostic routines to search for prepared
|
3260
3386
|
** statements that are holding a transaction open.
|
3261
3387
|
*/
|
3262
|
-
SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*);
|
3388
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_stmt_busy(sqlite3_stmt*);
|
3263
3389
|
|
3264
3390
|
/*
|
3265
3391
|
** CAPI3REF: Dynamically Typed Value Object
|
@@ -3274,7 +3400,9 @@ SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*);
|
|
3274
3400
|
** Some interfaces require a protected sqlite3_value. Other interfaces
|
3275
3401
|
** will accept either a protected or an unprotected sqlite3_value.
|
3276
3402
|
** Every interface that accepts sqlite3_value arguments specifies
|
3277
|
-
** whether or not it requires a protected sqlite3_value.
|
3403
|
+
** whether or not it requires a protected sqlite3_value. The
|
3404
|
+
** [sqlite3_value_dup()] interface can be used to construct a new
|
3405
|
+
** protected sqlite3_value from an unprotected sqlite3_value.
|
3278
3406
|
**
|
3279
3407
|
** The terms "protected" and "unprotected" refer to whether or not
|
3280
3408
|
** a mutex is held. An internal mutex is held for a protected
|
@@ -3318,6 +3446,7 @@ typedef struct sqlite3_context sqlite3_context;
|
|
3318
3446
|
** CAPI3REF: Binding Values To Prepared Statements
|
3319
3447
|
** KEYWORDS: {host parameter} {host parameters} {host parameter name}
|
3320
3448
|
** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
|
3449
|
+
** METHOD: sqlite3_stmt
|
3321
3450
|
**
|
3322
3451
|
** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,
|
3323
3452
|
** literals may be replaced by a [parameter] that matches one of following
|
@@ -3364,18 +3493,18 @@ typedef struct sqlite3_context sqlite3_context;
|
|
3364
3493
|
** If the fourth parameter to sqlite3_bind_blob() is negative, then
|
3365
3494
|
** the behavior is undefined.
|
3366
3495
|
** If a non-negative fourth parameter is provided to sqlite3_bind_text()
|
3367
|
-
** or sqlite3_bind_text16()
|
3496
|
+
** or sqlite3_bind_text16() or sqlite3_bind_text64() then
|
3497
|
+
** that parameter must be the byte offset
|
3368
3498
|
** where the NUL terminator would occur assuming the string were NUL
|
3369
3499
|
** terminated. If any NUL characters occur at byte offsets less than
|
3370
3500
|
** the value of the fourth parameter then the resulting string value will
|
3371
3501
|
** contain embedded NULs. The result of expressions involving strings
|
3372
3502
|
** with embedded NULs is undefined.
|
3373
3503
|
**
|
3374
|
-
** ^The fifth argument to
|
3375
|
-
**
|
3504
|
+
** ^The fifth argument to the BLOB and string binding interfaces
|
3505
|
+
** is a destructor used to dispose of the BLOB or
|
3376
3506
|
** string after SQLite has finished with it. ^The destructor is called
|
3377
|
-
** to dispose of the BLOB or string even if the call to
|
3378
|
-
** sqlite3_bind_text(), or sqlite3_bind_text16() fails.
|
3507
|
+
** to dispose of the BLOB or string even if the call to bind API fails.
|
3379
3508
|
** ^If the fifth argument is
|
3380
3509
|
** the special value [SQLITE_STATIC], then SQLite assumes that the
|
3381
3510
|
** information is in static, unmanaged space and does not need to be freed.
|
@@ -3383,6 +3512,14 @@ typedef struct sqlite3_context sqlite3_context;
|
|
3383
3512
|
** SQLite makes its own private copy of the data immediately, before
|
3384
3513
|
** the sqlite3_bind_*() routine returns.
|
3385
3514
|
**
|
3515
|
+
** ^The sixth argument to sqlite3_bind_text64() must be one of
|
3516
|
+
** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]
|
3517
|
+
** to specify the encoding of the text in the third parameter. If
|
3518
|
+
** the sixth argument to sqlite3_bind_text64() is not one of the
|
3519
|
+
** allowed values shown above, or if the text encoding is different
|
3520
|
+
** from the encoding specified by the sixth parameter, then the behavior
|
3521
|
+
** is undefined.
|
3522
|
+
**
|
3386
3523
|
** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
|
3387
3524
|
** is filled with zeroes. ^A zeroblob uses a fixed amount of memory
|
3388
3525
|
** (just an integer to hold its size) while it is being processed.
|
@@ -3403,24 +3540,33 @@ typedef struct sqlite3_context sqlite3_context;
|
|
3403
3540
|
**
|
3404
3541
|
** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
|
3405
3542
|
** [error code] if anything goes wrong.
|
3543
|
+
** ^[SQLITE_TOOBIG] might be returned if the size of a string or BLOB
|
3544
|
+
** exceeds limits imposed by [sqlite3_limit]([SQLITE_LIMIT_LENGTH]) or
|
3545
|
+
** [SQLITE_MAX_LENGTH].
|
3406
3546
|
** ^[SQLITE_RANGE] is returned if the parameter
|
3407
3547
|
** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails.
|
3408
3548
|
**
|
3409
3549
|
** See also: [sqlite3_bind_parameter_count()],
|
3410
3550
|
** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()].
|
3411
3551
|
*/
|
3412
|
-
SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
|
3413
|
-
SQLITE_API int
|
3414
|
-
|
3415
|
-
SQLITE_API int
|
3416
|
-
SQLITE_API int
|
3417
|
-
SQLITE_API int
|
3418
|
-
SQLITE_API int
|
3419
|
-
SQLITE_API int
|
3420
|
-
SQLITE_API int
|
3552
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
|
3553
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64,
|
3554
|
+
void(*)(void*));
|
3555
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_double(sqlite3_stmt*, int, double);
|
3556
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_int(sqlite3_stmt*, int, int);
|
3557
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
|
3558
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_null(sqlite3_stmt*, int);
|
3559
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
|
3560
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
|
3561
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
|
3562
|
+
void(*)(void*), unsigned char encoding);
|
3563
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
|
3564
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
|
3565
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64);
|
3421
3566
|
|
3422
3567
|
/*
|
3423
3568
|
** CAPI3REF: Number Of SQL Parameters
|
3569
|
+
** METHOD: sqlite3_stmt
|
3424
3570
|
**
|
3425
3571
|
** ^This routine can be used to find the number of [SQL parameters]
|
3426
3572
|
** in a [prepared statement]. SQL parameters are tokens of the
|
@@ -3437,10 +3583,11 @@ SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
|
|
3437
3583
|
** [sqlite3_bind_parameter_name()], and
|
3438
3584
|
** [sqlite3_bind_parameter_index()].
|
3439
3585
|
*/
|
3440
|
-
SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
|
3586
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_count(sqlite3_stmt*);
|
3441
3587
|
|
3442
3588
|
/*
|
3443
3589
|
** CAPI3REF: Name Of A Host Parameter
|
3590
|
+
** METHOD: sqlite3_stmt
|
3444
3591
|
**
|
3445
3592
|
** ^The sqlite3_bind_parameter_name(P,N) interface returns
|
3446
3593
|
** the name of the N-th [SQL parameter] in the [prepared statement] P.
|
@@ -3464,10 +3611,11 @@ SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
|
|
3464
3611
|
** [sqlite3_bind_parameter_count()], and
|
3465
3612
|
** [sqlite3_bind_parameter_index()].
|
3466
3613
|
*/
|
3467
|
-
SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
|
3614
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_bind_parameter_name(sqlite3_stmt*, int);
|
3468
3615
|
|
3469
3616
|
/*
|
3470
3617
|
** CAPI3REF: Index Of A Parameter With A Given Name
|
3618
|
+
** METHOD: sqlite3_stmt
|
3471
3619
|
**
|
3472
3620
|
** ^Return the index of an SQL parameter given its name. ^The
|
3473
3621
|
** index value returned is suitable for use as the second
|
@@ -3480,19 +3628,21 @@ SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
|
|
3480
3628
|
** [sqlite3_bind_parameter_count()], and
|
3481
3629
|
** [sqlite3_bind_parameter_index()].
|
3482
3630
|
*/
|
3483
|
-
SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
|
3631
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
|
3484
3632
|
|
3485
3633
|
/*
|
3486
3634
|
** CAPI3REF: Reset All Bindings On A Prepared Statement
|
3635
|
+
** METHOD: sqlite3_stmt
|
3487
3636
|
**
|
3488
3637
|
** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset
|
3489
3638
|
** the [sqlite3_bind_blob | bindings] on a [prepared statement].
|
3490
3639
|
** ^Use this routine to reset all host parameters to NULL.
|
3491
3640
|
*/
|
3492
|
-
SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
|
3641
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_clear_bindings(sqlite3_stmt*);
|
3493
3642
|
|
3494
3643
|
/*
|
3495
3644
|
** CAPI3REF: Number Of Columns In A Result Set
|
3645
|
+
** METHOD: sqlite3_stmt
|
3496
3646
|
**
|
3497
3647
|
** ^Return the number of columns in the result set returned by the
|
3498
3648
|
** [prepared statement]. ^This routine returns 0 if pStmt is an SQL
|
@@ -3500,10 +3650,11 @@ SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
|
|
3500
3650
|
**
|
3501
3651
|
** See also: [sqlite3_data_count()]
|
3502
3652
|
*/
|
3503
|
-
SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
|
3653
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_column_count(sqlite3_stmt *pStmt);
|
3504
3654
|
|
3505
3655
|
/*
|
3506
3656
|
** CAPI3REF: Column Names In A Result Set
|
3657
|
+
** METHOD: sqlite3_stmt
|
3507
3658
|
**
|
3508
3659
|
** ^These routines return the name assigned to a particular column
|
3509
3660
|
** in the result set of a [SELECT] statement. ^The sqlite3_column_name()
|
@@ -3528,11 +3679,12 @@ SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
|
|
3528
3679
|
** then the name of the column is unspecified and may change from
|
3529
3680
|
** one release of SQLite to the next.
|
3530
3681
|
*/
|
3531
|
-
SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N);
|
3532
|
-
SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
|
3682
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_column_name(sqlite3_stmt*, int N);
|
3683
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_column_name16(sqlite3_stmt*, int N);
|
3533
3684
|
|
3534
3685
|
/*
|
3535
3686
|
** CAPI3REF: Source Of Data In A Query Result
|
3687
|
+
** METHOD: sqlite3_stmt
|
3536
3688
|
**
|
3537
3689
|
** ^These routines provide a means to determine the database, table, and
|
3538
3690
|
** table column that is the origin of a particular result column in
|
@@ -3576,15 +3728,16 @@ SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
|
|
3576
3728
|
** for the same [prepared statement] and result column
|
3577
3729
|
** at the same time then the results are undefined.
|
3578
3730
|
*/
|
3579
|
-
SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int);
|
3580
|
-
SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
|
3581
|
-
SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int);
|
3582
|
-
SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
|
3583
|
-
SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
|
3584
|
-
SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
|
3731
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_column_database_name(sqlite3_stmt*,int);
|
3732
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_column_database_name16(sqlite3_stmt*,int);
|
3733
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_column_table_name(sqlite3_stmt*,int);
|
3734
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_column_table_name16(sqlite3_stmt*,int);
|
3735
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_column_origin_name(sqlite3_stmt*,int);
|
3736
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_column_origin_name16(sqlite3_stmt*,int);
|
3585
3737
|
|
3586
3738
|
/*
|
3587
3739
|
** CAPI3REF: Declared Datatype Of A Query Result
|
3740
|
+
** METHOD: sqlite3_stmt
|
3588
3741
|
**
|
3589
3742
|
** ^(The first parameter is a [prepared statement].
|
3590
3743
|
** If this statement is a [SELECT] statement and the Nth column of the
|
@@ -3612,11 +3765,12 @@ SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
|
|
3612
3765
|
** is associated with individual values, not with the containers
|
3613
3766
|
** used to hold those values.
|
3614
3767
|
*/
|
3615
|
-
SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int);
|
3616
|
-
SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
|
3768
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_column_decltype(sqlite3_stmt*,int);
|
3769
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_column_decltype16(sqlite3_stmt*,int);
|
3617
3770
|
|
3618
3771
|
/*
|
3619
3772
|
** CAPI3REF: Evaluate An SQL Statement
|
3773
|
+
** METHOD: sqlite3_stmt
|
3620
3774
|
**
|
3621
3775
|
** After a [prepared statement] has been prepared using either
|
3622
3776
|
** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy
|
@@ -3692,10 +3846,11 @@ SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
|
|
3692
3846
|
** then the more specific [error codes] are returned directly
|
3693
3847
|
** by sqlite3_step(). The use of the "v2" interface is recommended.
|
3694
3848
|
*/
|
3695
|
-
SQLITE_API int sqlite3_step(sqlite3_stmt*);
|
3849
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_step(sqlite3_stmt*);
|
3696
3850
|
|
3697
3851
|
/*
|
3698
3852
|
** CAPI3REF: Number of columns in a result set
|
3853
|
+
** METHOD: sqlite3_stmt
|
3699
3854
|
**
|
3700
3855
|
** ^The sqlite3_data_count(P) interface returns the number of columns in the
|
3701
3856
|
** current row of the result set of [prepared statement] P.
|
@@ -3712,7 +3867,7 @@ SQLITE_API int sqlite3_step(sqlite3_stmt*);
|
|
3712
3867
|
**
|
3713
3868
|
** See also: [sqlite3_column_count()]
|
3714
3869
|
*/
|
3715
|
-
SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
|
3870
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_data_count(sqlite3_stmt *pStmt);
|
3716
3871
|
|
3717
3872
|
/*
|
3718
3873
|
** CAPI3REF: Fundamental Datatypes
|
@@ -3749,8 +3904,7 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
|
|
3749
3904
|
/*
|
3750
3905
|
** CAPI3REF: Result Values From A Query
|
3751
3906
|
** KEYWORDS: {column access functions}
|
3752
|
-
**
|
3753
|
-
** These routines form the "result set" interface.
|
3907
|
+
** METHOD: sqlite3_stmt
|
3754
3908
|
**
|
3755
3909
|
** ^These routines return information about a single column of the current
|
3756
3910
|
** result row of a query. ^In every case the first argument is a pointer
|
@@ -3811,13 +3965,14 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
|
|
3811
3965
|
** even empty strings, are always zero-terminated. ^The return
|
3812
3966
|
** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
|
3813
3967
|
**
|
3814
|
-
** ^The object returned by [sqlite3_column_value()] is an
|
3815
|
-
** [unprotected sqlite3_value] object.
|
3816
|
-
** may only be used with
|
3968
|
+
** <b>Warning:</b> ^The object returned by [sqlite3_column_value()] is an
|
3969
|
+
** [unprotected sqlite3_value] object. In a multithreaded environment,
|
3970
|
+
** an unprotected sqlite3_value object may only be used safely with
|
3971
|
+
** [sqlite3_bind_value()] and [sqlite3_result_value()].
|
3817
3972
|
** If the [unprotected sqlite3_value] object returned by
|
3818
3973
|
** [sqlite3_column_value()] is used in any other way, including calls
|
3819
3974
|
** to routines like [sqlite3_value_int()], [sqlite3_value_text()],
|
3820
|
-
** or [sqlite3_value_bytes()],
|
3975
|
+
** or [sqlite3_value_bytes()], the behavior is not threadsafe.
|
3821
3976
|
**
|
3822
3977
|
** These routines attempt to convert the value where appropriate. ^For
|
3823
3978
|
** example, if the internal representation is FLOAT and a text result
|
@@ -3848,12 +4003,6 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
|
|
3848
4003
|
** </table>
|
3849
4004
|
** </blockquote>)^
|
3850
4005
|
**
|
3851
|
-
** The table above makes reference to standard C library functions atoi()
|
3852
|
-
** and atof(). SQLite does not really use these functions. It has its
|
3853
|
-
** own equivalent internal routines. The atoi() and atof() names are
|
3854
|
-
** used in the table for brevity and because they are familiar to most
|
3855
|
-
** C programmers.
|
3856
|
-
**
|
3857
4006
|
** Note that when type conversions occur, pointers returned by prior
|
3858
4007
|
** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
|
3859
4008
|
** sqlite3_column_text16() may be invalidated.
|
@@ -3878,7 +4027,7 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
|
|
3878
4027
|
** of conversion are done in place when it is possible, but sometimes they
|
3879
4028
|
** are not possible and in those cases prior pointers are invalidated.
|
3880
4029
|
**
|
3881
|
-
** The safest
|
4030
|
+
** The safest policy is to invoke these routines
|
3882
4031
|
** in one of the following ways:
|
3883
4032
|
**
|
3884
4033
|
** <ul>
|
@@ -3898,7 +4047,7 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
|
|
3898
4047
|
** ^The pointers returned are valid until a type conversion occurs as
|
3899
4048
|
** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
|
3900
4049
|
** [sqlite3_finalize()] is called. ^The memory space used to hold strings
|
3901
|
-
** and BLOBs is freed automatically. Do <
|
4050
|
+
** and BLOBs is freed automatically. Do <em>not</em> pass the pointers returned
|
3902
4051
|
** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
|
3903
4052
|
** [sqlite3_free()].
|
3904
4053
|
**
|
@@ -3908,19 +4057,20 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
|
|
3908
4057
|
** pointer. Subsequent calls to [sqlite3_errcode()] will return
|
3909
4058
|
** [SQLITE_NOMEM].)^
|
3910
4059
|
*/
|
3911
|
-
SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
|
3912
|
-
SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
|
3913
|
-
SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
|
3914
|
-
SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
|
3915
|
-
SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
|
3916
|
-
SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
|
3917
|
-
SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
|
3918
|
-
SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
|
3919
|
-
SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
|
3920
|
-
SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
|
4060
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_column_blob(sqlite3_stmt*, int iCol);
|
4061
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes(sqlite3_stmt*, int iCol);
|
4062
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
|
4063
|
+
SQLITE_API double SQLITE_STDCALL sqlite3_column_double(sqlite3_stmt*, int iCol);
|
4064
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_column_int(sqlite3_stmt*, int iCol);
|
4065
|
+
SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_column_int64(sqlite3_stmt*, int iCol);
|
4066
|
+
SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_column_text(sqlite3_stmt*, int iCol);
|
4067
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_column_text16(sqlite3_stmt*, int iCol);
|
4068
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_column_type(sqlite3_stmt*, int iCol);
|
4069
|
+
SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_column_value(sqlite3_stmt*, int iCol);
|
3921
4070
|
|
3922
4071
|
/*
|
3923
4072
|
** CAPI3REF: Destroy A Prepared Statement Object
|
4073
|
+
** DESTRUCTOR: sqlite3_stmt
|
3924
4074
|
**
|
3925
4075
|
** ^The sqlite3_finalize() function is called to delete a [prepared statement].
|
3926
4076
|
** ^If the most recent evaluation of the statement encountered no errors
|
@@ -3944,10 +4094,11 @@ SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
|
|
3944
4094
|
** statement after it has been finalized can result in undefined and
|
3945
4095
|
** undesirable behavior such as segfaults and heap corruption.
|
3946
4096
|
*/
|
3947
|
-
SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
|
4097
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_finalize(sqlite3_stmt *pStmt);
|
3948
4098
|
|
3949
4099
|
/*
|
3950
4100
|
** CAPI3REF: Reset A Prepared Statement Object
|
4101
|
+
** METHOD: sqlite3_stmt
|
3951
4102
|
**
|
3952
4103
|
** The sqlite3_reset() function is called to reset a [prepared statement]
|
3953
4104
|
** object back to its initial state, ready to be re-executed.
|
@@ -3970,13 +4121,14 @@ SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
|
|
3970
4121
|
** ^The [sqlite3_reset(S)] interface does not change the values
|
3971
4122
|
** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
|
3972
4123
|
*/
|
3973
|
-
SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
|
4124
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_reset(sqlite3_stmt *pStmt);
|
3974
4125
|
|
3975
4126
|
/*
|
3976
4127
|
** CAPI3REF: Create Or Redefine SQL Functions
|
3977
4128
|
** KEYWORDS: {function creation routines}
|
3978
4129
|
** KEYWORDS: {application-defined SQL function}
|
3979
4130
|
** KEYWORDS: {application-defined SQL functions}
|
4131
|
+
** METHOD: sqlite3
|
3980
4132
|
**
|
3981
4133
|
** ^These functions (collectively known as "function creation routines")
|
3982
4134
|
** are used to add SQL functions or aggregates or to redefine the behavior
|
@@ -4069,7 +4221,7 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
|
|
4069
4221
|
** close the database connection nor finalize or reset the prepared
|
4070
4222
|
** statement in which the function is running.
|
4071
4223
|
*/
|
4072
|
-
SQLITE_API int sqlite3_create_function(
|
4224
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_create_function(
|
4073
4225
|
sqlite3 *db,
|
4074
4226
|
const char *zFunctionName,
|
4075
4227
|
int nArg,
|
@@ -4079,7 +4231,7 @@ SQLITE_API int sqlite3_create_function(
|
|
4079
4231
|
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
|
4080
4232
|
void (*xFinal)(sqlite3_context*)
|
4081
4233
|
);
|
4082
|
-
SQLITE_API int sqlite3_create_function16(
|
4234
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_create_function16(
|
4083
4235
|
sqlite3 *db,
|
4084
4236
|
const void *zFunctionName,
|
4085
4237
|
int nArg,
|
@@ -4089,7 +4241,7 @@ SQLITE_API int sqlite3_create_function16(
|
|
4089
4241
|
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
|
4090
4242
|
void (*xFinal)(sqlite3_context*)
|
4091
4243
|
);
|
4092
|
-
SQLITE_API int sqlite3_create_function_v2(
|
4244
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_create_function_v2(
|
4093
4245
|
sqlite3 *db,
|
4094
4246
|
const char *zFunctionName,
|
4095
4247
|
int nArg,
|
@@ -4107,9 +4259,9 @@ SQLITE_API int sqlite3_create_function_v2(
|
|
4107
4259
|
** These constant define integer codes that represent the various
|
4108
4260
|
** text encodings supported by SQLite.
|
4109
4261
|
*/
|
4110
|
-
#define SQLITE_UTF8 1
|
4111
|
-
#define SQLITE_UTF16LE 2
|
4112
|
-
#define SQLITE_UTF16BE 3
|
4262
|
+
#define SQLITE_UTF8 1 /* IMP: R-37514-35566 */
|
4263
|
+
#define SQLITE_UTF16LE 2 /* IMP: R-03371-37637 */
|
4264
|
+
#define SQLITE_UTF16BE 3 /* IMP: R-51971-34154 */
|
4113
4265
|
#define SQLITE_UTF16 4 /* Use native byte order */
|
4114
4266
|
#define SQLITE_ANY 5 /* Deprecated */
|
4115
4267
|
#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */
|
@@ -4131,25 +4283,26 @@ SQLITE_API int sqlite3_create_function_v2(
|
|
4131
4283
|
** These functions are [deprecated]. In order to maintain
|
4132
4284
|
** backwards compatibility with older code, these functions continue
|
4133
4285
|
** to be supported. However, new applications should avoid
|
4134
|
-
** the use of these functions. To
|
4135
|
-
**
|
4286
|
+
** the use of these functions. To encourage programmers to avoid
|
4287
|
+
** these functions, we will not explain what they do.
|
4136
4288
|
*/
|
4137
4289
|
#ifndef SQLITE_OMIT_DEPRECATED
|
4138
|
-
SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*);
|
4139
|
-
SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*);
|
4140
|
-
SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
|
4141
|
-
SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
|
4142
|
-
SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
|
4143
|
-
SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),
|
4290
|
+
SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_aggregate_count(sqlite3_context*);
|
4291
|
+
SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_expired(sqlite3_stmt*);
|
4292
|
+
SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
|
4293
|
+
SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_global_recover(void);
|
4294
|
+
SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL sqlite3_thread_cleanup(void);
|
4295
|
+
SQLITE_API SQLITE_DEPRECATED int SQLITE_STDCALL sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),
|
4144
4296
|
void*,sqlite3_int64);
|
4145
4297
|
#endif
|
4146
4298
|
|
4147
4299
|
/*
|
4148
|
-
** CAPI3REF: Obtaining SQL
|
4300
|
+
** CAPI3REF: Obtaining SQL Values
|
4301
|
+
** METHOD: sqlite3_value
|
4149
4302
|
**
|
4150
4303
|
** The C-language implementation of SQL functions and aggregates uses
|
4151
4304
|
** this set of interface routines to access the parameter values on
|
4152
|
-
** the function or aggregate.
|
4305
|
+
** the function or aggregate.
|
4153
4306
|
**
|
4154
4307
|
** The xFunc (for scalar functions) or xStep (for aggregates) parameters
|
4155
4308
|
** to [sqlite3_create_function()] and [sqlite3_create_function16()]
|
@@ -4164,7 +4317,7 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
|
|
4164
4317
|
** object results in undefined behavior.
|
4165
4318
|
**
|
4166
4319
|
** ^These routines work just like the corresponding [column access functions]
|
4167
|
-
** except that
|
4320
|
+
** except that these routines take a single [protected sqlite3_value] object
|
4168
4321
|
** pointer instead of a [sqlite3_stmt*] pointer and an integer column number.
|
4169
4322
|
**
|
4170
4323
|
** ^The sqlite3_value_text16() interface extracts a UTF-16 string
|
@@ -4189,21 +4342,39 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
|
|
4189
4342
|
** These routines must be called from the same thread as
|
4190
4343
|
** the SQL function that supplied the [sqlite3_value*] parameters.
|
4191
4344
|
*/
|
4192
|
-
SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
|
4193
|
-
SQLITE_API int sqlite3_value_bytes(sqlite3_value*);
|
4194
|
-
SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
|
4195
|
-
SQLITE_API double sqlite3_value_double(sqlite3_value*);
|
4196
|
-
SQLITE_API int sqlite3_value_int(sqlite3_value*);
|
4197
|
-
SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
|
4198
|
-
SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*);
|
4199
|
-
SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
|
4200
|
-
SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
|
4201
|
-
SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
|
4202
|
-
SQLITE_API int sqlite3_value_type(sqlite3_value*);
|
4203
|
-
SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
|
4345
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_value_blob(sqlite3_value*);
|
4346
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes(sqlite3_value*);
|
4347
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_value_bytes16(sqlite3_value*);
|
4348
|
+
SQLITE_API double SQLITE_STDCALL sqlite3_value_double(sqlite3_value*);
|
4349
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_value_int(sqlite3_value*);
|
4350
|
+
SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_value_int64(sqlite3_value*);
|
4351
|
+
SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_value_text(sqlite3_value*);
|
4352
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16(sqlite3_value*);
|
4353
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16le(sqlite3_value*);
|
4354
|
+
SQLITE_API const void *SQLITE_STDCALL sqlite3_value_text16be(sqlite3_value*);
|
4355
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_value_type(sqlite3_value*);
|
4356
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_value_numeric_type(sqlite3_value*);
|
4357
|
+
|
4358
|
+
/*
|
4359
|
+
** CAPI3REF: Copy And Free SQL Values
|
4360
|
+
** METHOD: sqlite3_value
|
4361
|
+
**
|
4362
|
+
** ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value]
|
4363
|
+
** object D and returns a pointer to that copy. ^The [sqlite3_value] returned
|
4364
|
+
** is a [protected sqlite3_value] object even if the input is not.
|
4365
|
+
** ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a
|
4366
|
+
** memory allocation fails.
|
4367
|
+
**
|
4368
|
+
** ^The sqlite3_value_free(V) interface frees an [sqlite3_value] object
|
4369
|
+
** previously obtained from [sqlite3_value_dup()]. ^If V is a NULL pointer
|
4370
|
+
** then sqlite3_value_free(V) is a harmless no-op.
|
4371
|
+
*/
|
4372
|
+
SQLITE_API SQLITE_EXPERIMENTAL sqlite3_value *SQLITE_STDCALL sqlite3_value_dup(const sqlite3_value*);
|
4373
|
+
SQLITE_API SQLITE_EXPERIMENTAL void SQLITE_STDCALL sqlite3_value_free(sqlite3_value*);
|
4204
4374
|
|
4205
4375
|
/*
|
4206
4376
|
** CAPI3REF: Obtain Aggregate Function Context
|
4377
|
+
** METHOD: sqlite3_context
|
4207
4378
|
**
|
4208
4379
|
** Implementations of aggregate SQL functions use this
|
4209
4380
|
** routine to allocate memory for storing their state.
|
@@ -4244,10 +4415,11 @@ SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
|
|
4244
4415
|
** This routine must be called from the same thread in which
|
4245
4416
|
** the aggregate SQL function is running.
|
4246
4417
|
*/
|
4247
|
-
SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
|
4418
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context*, int nBytes);
|
4248
4419
|
|
4249
4420
|
/*
|
4250
4421
|
** CAPI3REF: User Data For Functions
|
4422
|
+
** METHOD: sqlite3_context
|
4251
4423
|
**
|
4252
4424
|
** ^The sqlite3_user_data() interface returns a copy of
|
4253
4425
|
** the pointer that was the pUserData parameter (the 5th parameter)
|
@@ -4258,10 +4430,11 @@ SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
|
|
4258
4430
|
** This routine must be called from the same thread in which
|
4259
4431
|
** the application-defined function is running.
|
4260
4432
|
*/
|
4261
|
-
SQLITE_API void *sqlite3_user_data(sqlite3_context*);
|
4433
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_user_data(sqlite3_context*);
|
4262
4434
|
|
4263
4435
|
/*
|
4264
4436
|
** CAPI3REF: Database Connection For Functions
|
4437
|
+
** METHOD: sqlite3_context
|
4265
4438
|
**
|
4266
4439
|
** ^The sqlite3_context_db_handle() interface returns a copy of
|
4267
4440
|
** the pointer to the [database connection] (the 1st parameter)
|
@@ -4269,10 +4442,11 @@ SQLITE_API void *sqlite3_user_data(sqlite3_context*);
|
|
4269
4442
|
** and [sqlite3_create_function16()] routines that originally
|
4270
4443
|
** registered the application defined function.
|
4271
4444
|
*/
|
4272
|
-
SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
|
4445
|
+
SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_context_db_handle(sqlite3_context*);
|
4273
4446
|
|
4274
4447
|
/*
|
4275
4448
|
** CAPI3REF: Function Auxiliary Data
|
4449
|
+
** METHOD: sqlite3_context
|
4276
4450
|
**
|
4277
4451
|
** These functions may be used by (non-aggregate) SQL functions to
|
4278
4452
|
** associate metadata with argument values. If the same value is passed to
|
@@ -4321,8 +4495,8 @@ SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
|
|
4321
4495
|
** These routines must be called from the same thread in which
|
4322
4496
|
** the SQL function is running.
|
4323
4497
|
*/
|
4324
|
-
SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
|
4325
|
-
SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
|
4498
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_get_auxdata(sqlite3_context*, int N);
|
4499
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
|
4326
4500
|
|
4327
4501
|
|
4328
4502
|
/*
|
@@ -4345,6 +4519,7 @@ typedef void (*sqlite3_destructor_type)(void*);
|
|
4345
4519
|
|
4346
4520
|
/*
|
4347
4521
|
** CAPI3REF: Setting The Result Of An SQL Function
|
4522
|
+
** METHOD: sqlite3_context
|
4348
4523
|
**
|
4349
4524
|
** These routines are used by the xFunc or xFinal callbacks that
|
4350
4525
|
** implement SQL functions and aggregates. See
|
@@ -4360,9 +4535,9 @@ typedef void (*sqlite3_destructor_type)(void*);
|
|
4360
4535
|
** to by the second parameter and which is N bytes long where N is the
|
4361
4536
|
** third parameter.
|
4362
4537
|
**
|
4363
|
-
** ^The sqlite3_result_zeroblob()
|
4364
|
-
** the application-defined function to be
|
4365
|
-
** bytes and N bytes in size
|
4538
|
+
** ^The sqlite3_result_zeroblob(C,N) and sqlite3_result_zeroblob64(C,N)
|
4539
|
+
** interfaces set the result of the application-defined function to be
|
4540
|
+
** a BLOB containing all zero bytes and N bytes in size.
|
4366
4541
|
**
|
4367
4542
|
** ^The sqlite3_result_double() interface sets the result from
|
4368
4543
|
** an application-defined function to be a floating point value specified
|
@@ -4411,6 +4586,10 @@ typedef void (*sqlite3_destructor_type)(void*);
|
|
4411
4586
|
** set the return value of the application-defined function to be
|
4412
4587
|
** a text string which is represented as UTF-8, UTF-16 native byte order,
|
4413
4588
|
** UTF-16 little endian, or UTF-16 big endian, respectively.
|
4589
|
+
** ^The sqlite3_result_text64() interface sets the return value of an
|
4590
|
+
** application-defined function to be a text string in an encoding
|
4591
|
+
** specified by the fifth (and last) parameter, which must be one
|
4592
|
+
** of [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE].
|
4414
4593
|
** ^SQLite takes the text result from the application from
|
4415
4594
|
** the 2nd parameter of the sqlite3_result_text* interfaces.
|
4416
4595
|
** ^If the 3rd parameter to the sqlite3_result_text* interfaces
|
@@ -4440,7 +4619,7 @@ typedef void (*sqlite3_destructor_type)(void*);
|
|
4440
4619
|
** from [sqlite3_malloc()] before it returns.
|
4441
4620
|
**
|
4442
4621
|
** ^The sqlite3_result_value() interface sets the result of
|
4443
|
-
** the application-defined function to be a copy the
|
4622
|
+
** the application-defined function to be a copy of the
|
4444
4623
|
** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The
|
4445
4624
|
** sqlite3_result_value() interface makes a copy of the [sqlite3_value]
|
4446
4625
|
** so that the [sqlite3_value] specified in the parameter may change or
|
@@ -4453,25 +4632,31 @@ typedef void (*sqlite3_destructor_type)(void*);
|
|
4453
4632
|
** than the one containing the application-defined function that received
|
4454
4633
|
** the [sqlite3_context] pointer, the results are undefined.
|
4455
4634
|
*/
|
4456
|
-
SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
|
4457
|
-
SQLITE_API void
|
4458
|
-
|
4459
|
-
SQLITE_API void
|
4460
|
-
SQLITE_API void
|
4461
|
-
SQLITE_API void
|
4462
|
-
SQLITE_API void
|
4463
|
-
SQLITE_API void
|
4464
|
-
SQLITE_API void
|
4465
|
-
SQLITE_API void
|
4466
|
-
SQLITE_API void
|
4467
|
-
SQLITE_API void
|
4468
|
-
SQLITE_API void
|
4469
|
-
SQLITE_API void
|
4470
|
-
|
4471
|
-
SQLITE_API void
|
4635
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
|
4636
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_blob64(sqlite3_context*,const void*,
|
4637
|
+
sqlite3_uint64,void(*)(void*));
|
4638
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_double(sqlite3_context*, double);
|
4639
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_error(sqlite3_context*, const char*, int);
|
4640
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_error16(sqlite3_context*, const void*, int);
|
4641
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_error_toobig(sqlite3_context*);
|
4642
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context*);
|
4643
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_error_code(sqlite3_context*, int);
|
4644
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_int(sqlite3_context*, int);
|
4645
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
|
4646
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_null(sqlite3_context*);
|
4647
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
|
4648
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64,
|
4649
|
+
void(*)(void*), unsigned char encoding);
|
4650
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
|
4651
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
|
4652
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
|
4653
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context*, sqlite3_value*);
|
4654
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context*, int n);
|
4655
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n);
|
4472
4656
|
|
4473
4657
|
/*
|
4474
4658
|
** CAPI3REF: Define New Collating Sequences
|
4659
|
+
** METHOD: sqlite3
|
4475
4660
|
**
|
4476
4661
|
** ^These functions add, remove, or modify a [collation] associated
|
4477
4662
|
** with the [database connection] specified as the first argument.
|
@@ -4549,14 +4734,14 @@ SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
|
|
4549
4734
|
**
|
4550
4735
|
** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()].
|
4551
4736
|
*/
|
4552
|
-
SQLITE_API int sqlite3_create_collation(
|
4737
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_create_collation(
|
4553
4738
|
sqlite3*,
|
4554
4739
|
const char *zName,
|
4555
4740
|
int eTextRep,
|
4556
4741
|
void *pArg,
|
4557
4742
|
int(*xCompare)(void*,int,const void*,int,const void*)
|
4558
4743
|
);
|
4559
|
-
SQLITE_API int sqlite3_create_collation_v2(
|
4744
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_create_collation_v2(
|
4560
4745
|
sqlite3*,
|
4561
4746
|
const char *zName,
|
4562
4747
|
int eTextRep,
|
@@ -4564,7 +4749,7 @@ SQLITE_API int sqlite3_create_collation_v2(
|
|
4564
4749
|
int(*xCompare)(void*,int,const void*,int,const void*),
|
4565
4750
|
void(*xDestroy)(void*)
|
4566
4751
|
);
|
4567
|
-
SQLITE_API int sqlite3_create_collation16(
|
4752
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_create_collation16(
|
4568
4753
|
sqlite3*,
|
4569
4754
|
const void *zName,
|
4570
4755
|
int eTextRep,
|
@@ -4574,6 +4759,7 @@ SQLITE_API int sqlite3_create_collation16(
|
|
4574
4759
|
|
4575
4760
|
/*
|
4576
4761
|
** CAPI3REF: Collation Needed Callbacks
|
4762
|
+
** METHOD: sqlite3
|
4577
4763
|
**
|
4578
4764
|
** ^To avoid having to register all collation sequences before a database
|
4579
4765
|
** can be used, a single callback function may be registered with the
|
@@ -4598,12 +4784,12 @@ SQLITE_API int sqlite3_create_collation16(
|
|
4598
4784
|
** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
|
4599
4785
|
** [sqlite3_create_collation_v2()].
|
4600
4786
|
*/
|
4601
|
-
SQLITE_API int sqlite3_collation_needed(
|
4787
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed(
|
4602
4788
|
sqlite3*,
|
4603
4789
|
void*,
|
4604
4790
|
void(*)(void*,sqlite3*,int eTextRep,const char*)
|
4605
4791
|
);
|
4606
|
-
SQLITE_API int sqlite3_collation_needed16(
|
4792
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_collation_needed16(
|
4607
4793
|
sqlite3*,
|
4608
4794
|
void*,
|
4609
4795
|
void(*)(void*,sqlite3*,int eTextRep,const void*)
|
@@ -4617,11 +4803,11 @@ SQLITE_API int sqlite3_collation_needed16(
|
|
4617
4803
|
** The code to implement this API is not available in the public release
|
4618
4804
|
** of SQLite.
|
4619
4805
|
*/
|
4620
|
-
SQLITE_API int sqlite3_key(
|
4806
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_key(
|
4621
4807
|
sqlite3 *db, /* Database to be rekeyed */
|
4622
4808
|
const void *pKey, int nKey /* The key */
|
4623
4809
|
);
|
4624
|
-
SQLITE_API int sqlite3_key_v2(
|
4810
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_key_v2(
|
4625
4811
|
sqlite3 *db, /* Database to be rekeyed */
|
4626
4812
|
const char *zDbName, /* Name of the database */
|
4627
4813
|
const void *pKey, int nKey /* The key */
|
@@ -4635,11 +4821,11 @@ SQLITE_API int sqlite3_key_v2(
|
|
4635
4821
|
** The code to implement this API is not available in the public release
|
4636
4822
|
** of SQLite.
|
4637
4823
|
*/
|
4638
|
-
SQLITE_API int sqlite3_rekey(
|
4824
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_rekey(
|
4639
4825
|
sqlite3 *db, /* Database to be rekeyed */
|
4640
4826
|
const void *pKey, int nKey /* The new key */
|
4641
4827
|
);
|
4642
|
-
SQLITE_API int sqlite3_rekey_v2(
|
4828
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_rekey_v2(
|
4643
4829
|
sqlite3 *db, /* Database to be rekeyed */
|
4644
4830
|
const char *zDbName, /* Name of the database */
|
4645
4831
|
const void *pKey, int nKey /* The new key */
|
@@ -4649,7 +4835,7 @@ SQLITE_API int sqlite3_rekey_v2(
|
|
4649
4835
|
** Specify the activation key for a SEE database. Unless
|
4650
4836
|
** activated, none of the SEE routines will work.
|
4651
4837
|
*/
|
4652
|
-
SQLITE_API void sqlite3_activate_see(
|
4838
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_activate_see(
|
4653
4839
|
const char *zPassPhrase /* Activation phrase */
|
4654
4840
|
);
|
4655
4841
|
#endif
|
@@ -4659,7 +4845,7 @@ SQLITE_API void sqlite3_activate_see(
|
|
4659
4845
|
** Specify the activation key for a CEROD database. Unless
|
4660
4846
|
** activated, none of the CEROD routines will work.
|
4661
4847
|
*/
|
4662
|
-
SQLITE_API void sqlite3_activate_cerod(
|
4848
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_activate_cerod(
|
4663
4849
|
const char *zPassPhrase /* Activation phrase */
|
4664
4850
|
);
|
4665
4851
|
#endif
|
@@ -4681,7 +4867,7 @@ SQLITE_API void sqlite3_activate_cerod(
|
|
4681
4867
|
** all, then the behavior of sqlite3_sleep() may deviate from the description
|
4682
4868
|
** in the previous paragraphs.
|
4683
4869
|
*/
|
4684
|
-
SQLITE_API int sqlite3_sleep(int);
|
4870
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_sleep(int);
|
4685
4871
|
|
4686
4872
|
/*
|
4687
4873
|
** CAPI3REF: Name Of The Folder Holding Temporary Files
|
@@ -4781,6 +4967,7 @@ SQLITE_API SQLITE_EXTERN char *sqlite3_data_directory;
|
|
4781
4967
|
/*
|
4782
4968
|
** CAPI3REF: Test For Auto-Commit Mode
|
4783
4969
|
** KEYWORDS: {autocommit mode}
|
4970
|
+
** METHOD: sqlite3
|
4784
4971
|
**
|
4785
4972
|
** ^The sqlite3_get_autocommit() interface returns non-zero or
|
4786
4973
|
** zero if the given database connection is or is not in autocommit mode,
|
@@ -4799,10 +4986,11 @@ SQLITE_API SQLITE_EXTERN char *sqlite3_data_directory;
|
|
4799
4986
|
** connection while this routine is running, then the return value
|
4800
4987
|
** is undefined.
|
4801
4988
|
*/
|
4802
|
-
SQLITE_API int sqlite3_get_autocommit(sqlite3*);
|
4989
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_get_autocommit(sqlite3*);
|
4803
4990
|
|
4804
4991
|
/*
|
4805
4992
|
** CAPI3REF: Find The Database Handle Of A Prepared Statement
|
4993
|
+
** METHOD: sqlite3_stmt
|
4806
4994
|
**
|
4807
4995
|
** ^The sqlite3_db_handle interface returns the [database connection] handle
|
4808
4996
|
** to which a [prepared statement] belongs. ^The [database connection]
|
@@ -4811,10 +4999,11 @@ SQLITE_API int sqlite3_get_autocommit(sqlite3*);
|
|
4811
4999
|
** to the [sqlite3_prepare_v2()] call (or its variants) that was used to
|
4812
5000
|
** create the statement in the first place.
|
4813
5001
|
*/
|
4814
|
-
SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
|
5002
|
+
SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3_db_handle(sqlite3_stmt*);
|
4815
5003
|
|
4816
5004
|
/*
|
4817
5005
|
** CAPI3REF: Return The Filename For A Database Connection
|
5006
|
+
** METHOD: sqlite3
|
4818
5007
|
**
|
4819
5008
|
** ^The sqlite3_db_filename(D,N) interface returns a pointer to a filename
|
4820
5009
|
** associated with database N of connection D. ^The main database file
|
@@ -4827,19 +5016,21 @@ SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
|
|
4827
5016
|
** will be an absolute pathname, even if the filename used
|
4828
5017
|
** to open the database originally was a URI or relative pathname.
|
4829
5018
|
*/
|
4830
|
-
SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);
|
5019
|
+
SQLITE_API const char *SQLITE_STDCALL sqlite3_db_filename(sqlite3 *db, const char *zDbName);
|
4831
5020
|
|
4832
5021
|
/*
|
4833
5022
|
** CAPI3REF: Determine if a database is read-only
|
5023
|
+
** METHOD: sqlite3
|
4834
5024
|
**
|
4835
5025
|
** ^The sqlite3_db_readonly(D,N) interface returns 1 if the database N
|
4836
5026
|
** of connection D is read-only, 0 if it is read/write, or -1 if N is not
|
4837
5027
|
** the name of a database on connection D.
|
4838
5028
|
*/
|
4839
|
-
SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
|
5029
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
|
4840
5030
|
|
4841
5031
|
/*
|
4842
5032
|
** CAPI3REF: Find the next prepared statement
|
5033
|
+
** METHOD: sqlite3
|
4843
5034
|
**
|
4844
5035
|
** ^This interface returns a pointer to the next [prepared statement] after
|
4845
5036
|
** pStmt associated with the [database connection] pDb. ^If pStmt is NULL
|
@@ -4851,10 +5042,11 @@ SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
|
|
4851
5042
|
** [sqlite3_next_stmt(D,S)] must refer to an open database
|
4852
5043
|
** connection and in particular must not be a NULL pointer.
|
4853
5044
|
*/
|
4854
|
-
SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
|
5045
|
+
SQLITE_API sqlite3_stmt *SQLITE_STDCALL sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
|
4855
5046
|
|
4856
5047
|
/*
|
4857
5048
|
** CAPI3REF: Commit And Rollback Notification Callbacks
|
5049
|
+
** METHOD: sqlite3
|
4858
5050
|
**
|
4859
5051
|
** ^The sqlite3_commit_hook() interface registers a callback
|
4860
5052
|
** function to be invoked whenever a transaction is [COMMIT | committed].
|
@@ -4899,11 +5091,12 @@ SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
|
|
4899
5091
|
**
|
4900
5092
|
** See also the [sqlite3_update_hook()] interface.
|
4901
5093
|
*/
|
4902
|
-
SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
|
4903
|
-
SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
|
5094
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
|
5095
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
|
4904
5096
|
|
4905
5097
|
/*
|
4906
5098
|
** CAPI3REF: Data Change Notification Callbacks
|
5099
|
+
** METHOD: sqlite3
|
4907
5100
|
**
|
4908
5101
|
** ^The sqlite3_update_hook() interface registers a callback function
|
4909
5102
|
** with the [database connection] identified by the first argument
|
@@ -4950,7 +5143,7 @@ SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
|
|
4950
5143
|
** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()]
|
4951
5144
|
** interfaces.
|
4952
5145
|
*/
|
4953
|
-
SQLITE_API void *sqlite3_update_hook(
|
5146
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_update_hook(
|
4954
5147
|
sqlite3*,
|
4955
5148
|
void(*)(void *,int ,char const *,char const *,sqlite3_int64),
|
4956
5149
|
void*
|
@@ -4980,12 +5173,17 @@ SQLITE_API void *sqlite3_update_hook(
|
|
4980
5173
|
** future releases of SQLite. Applications that care about shared
|
4981
5174
|
** cache setting should set it explicitly.
|
4982
5175
|
**
|
5176
|
+
** Note: This method is disabled on MacOS X 10.7 and iOS version 5.0
|
5177
|
+
** and will always return SQLITE_MISUSE. On those systems,
|
5178
|
+
** shared cache mode should be enabled per-database connection via
|
5179
|
+
** [sqlite3_open_v2()] with [SQLITE_OPEN_SHAREDCACHE].
|
5180
|
+
**
|
4983
5181
|
** This interface is threadsafe on processors where writing a
|
4984
5182
|
** 32-bit integer is atomic.
|
4985
5183
|
**
|
4986
5184
|
** See Also: [SQLite Shared-Cache Mode]
|
4987
5185
|
*/
|
4988
|
-
SQLITE_API int sqlite3_enable_shared_cache(int);
|
5186
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_enable_shared_cache(int);
|
4989
5187
|
|
4990
5188
|
/*
|
4991
5189
|
** CAPI3REF: Attempt To Free Heap Memory
|
@@ -5001,10 +5199,11 @@ SQLITE_API int sqlite3_enable_shared_cache(int);
|
|
5001
5199
|
**
|
5002
5200
|
** See also: [sqlite3_db_release_memory()]
|
5003
5201
|
*/
|
5004
|
-
SQLITE_API int sqlite3_release_memory(int);
|
5202
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_release_memory(int);
|
5005
5203
|
|
5006
5204
|
/*
|
5007
5205
|
** CAPI3REF: Free Memory Used By A Database Connection
|
5206
|
+
** METHOD: sqlite3
|
5008
5207
|
**
|
5009
5208
|
** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap
|
5010
5209
|
** memory as possible from database connection D. Unlike the
|
@@ -5014,7 +5213,7 @@ SQLITE_API int sqlite3_release_memory(int);
|
|
5014
5213
|
**
|
5015
5214
|
** See also: [sqlite3_release_memory()]
|
5016
5215
|
*/
|
5017
|
-
SQLITE_API int sqlite3_db_release_memory(sqlite3*);
|
5216
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_db_release_memory(sqlite3*);
|
5018
5217
|
|
5019
5218
|
/*
|
5020
5219
|
** CAPI3REF: Impose A Limit On Heap Size
|
@@ -5066,7 +5265,7 @@ SQLITE_API int sqlite3_db_release_memory(sqlite3*);
|
|
5066
5265
|
** The circumstances under which SQLite will enforce the soft heap limit may
|
5067
5266
|
** changes in future releases of SQLite.
|
5068
5267
|
*/
|
5069
|
-
SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);
|
5268
|
+
SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 N);
|
5070
5269
|
|
5071
5270
|
/*
|
5072
5271
|
** CAPI3REF: Deprecated Soft Heap Limit Interface
|
@@ -5077,26 +5276,34 @@ SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);
|
|
5077
5276
|
** only. All new applications should use the
|
5078
5277
|
** [sqlite3_soft_heap_limit64()] interface rather than this one.
|
5079
5278
|
*/
|
5080
|
-
SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);
|
5279
|
+
SQLITE_API SQLITE_DEPRECATED void SQLITE_STDCALL sqlite3_soft_heap_limit(int N);
|
5081
5280
|
|
5082
5281
|
|
5083
5282
|
/*
|
5084
5283
|
** CAPI3REF: Extract Metadata About A Column Of A Table
|
5085
|
-
**
|
5086
|
-
**
|
5087
|
-
**
|
5088
|
-
**
|
5284
|
+
** METHOD: sqlite3
|
5285
|
+
**
|
5286
|
+
** ^(The sqlite3_table_column_metadata(X,D,T,C,....) routine returns
|
5287
|
+
** information about column C of table T in database D
|
5288
|
+
** on [database connection] X.)^ ^The sqlite3_table_column_metadata()
|
5289
|
+
** interface returns SQLITE_OK and fills in the non-NULL pointers in
|
5290
|
+
** the final five arguments with appropriate values if the specified
|
5291
|
+
** column exists. ^The sqlite3_table_column_metadata() interface returns
|
5292
|
+
** SQLITE_ERROR and if the specified column does not exist.
|
5293
|
+
** ^If the column-name parameter to sqlite3_table_column_metadata() is a
|
5294
|
+
** NULL pointer, then this routine simply checks for the existance of the
|
5295
|
+
** table and returns SQLITE_OK if the table exists and SQLITE_ERROR if it
|
5296
|
+
** does not.
|
5089
5297
|
**
|
5090
5298
|
** ^The column is identified by the second, third and fourth parameters to
|
5091
|
-
** this function. ^The second parameter is either the name of the database
|
5299
|
+
** this function. ^(The second parameter is either the name of the database
|
5092
5300
|
** (i.e. "main", "temp", or an attached database) containing the specified
|
5093
|
-
** table or NULL. ^If it is NULL, then all attached databases are searched
|
5301
|
+
** table or NULL.)^ ^If it is NULL, then all attached databases are searched
|
5094
5302
|
** for the table using the same algorithm used by the database engine to
|
5095
5303
|
** resolve unqualified table references.
|
5096
5304
|
**
|
5097
5305
|
** ^The third and fourth parameters to this function are the table and column
|
5098
|
-
** name of the desired column, respectively.
|
5099
|
-
** may be NULL.
|
5306
|
+
** name of the desired column, respectively.
|
5100
5307
|
**
|
5101
5308
|
** ^Metadata is returned by writing to the memory locations passed as the 5th
|
5102
5309
|
** and subsequent parameters to this function. ^Any of these arguments may be
|
@@ -5115,16 +5322,17 @@ SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);
|
|
5115
5322
|
** </blockquote>)^
|
5116
5323
|
**
|
5117
5324
|
** ^The memory pointed to by the character pointers returned for the
|
5118
|
-
** declaration type and collation sequence is valid
|
5325
|
+
** declaration type and collation sequence is valid until the next
|
5119
5326
|
** call to any SQLite API function.
|
5120
5327
|
**
|
5121
5328
|
** ^If the specified table is actually a view, an [error code] is returned.
|
5122
5329
|
**
|
5123
|
-
** ^If the specified column is "rowid", "oid" or "_rowid_" and
|
5330
|
+
** ^If the specified column is "rowid", "oid" or "_rowid_" and the table
|
5331
|
+
** is not a [WITHOUT ROWID] table and an
|
5124
5332
|
** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
|
5125
5333
|
** parameters are set for the explicitly declared column. ^(If there is no
|
5126
|
-
**
|
5127
|
-
**
|
5334
|
+
** [INTEGER PRIMARY KEY] column, then the outputs
|
5335
|
+
** for the [rowid] are set as follows:
|
5128
5336
|
**
|
5129
5337
|
** <pre>
|
5130
5338
|
** data type: "INTEGER"
|
@@ -5134,15 +5342,11 @@ SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);
|
|
5134
5342
|
** auto increment: 0
|
5135
5343
|
** </pre>)^
|
5136
5344
|
**
|
5137
|
-
** ^
|
5138
|
-
**
|
5139
|
-
**
|
5140
|
-
** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^
|
5141
|
-
**
|
5142
|
-
** ^This API is only available if the library was compiled with the
|
5143
|
-
** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined.
|
5345
|
+
** ^This function causes all database schemas to be read from disk and
|
5346
|
+
** parsed, if that has not already been done, and returns an error if
|
5347
|
+
** any errors are encountered while loading the schema.
|
5144
5348
|
*/
|
5145
|
-
SQLITE_API int sqlite3_table_column_metadata(
|
5349
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_table_column_metadata(
|
5146
5350
|
sqlite3 *db, /* Connection handle */
|
5147
5351
|
const char *zDbName, /* Database name or NULL */
|
5148
5352
|
const char *zTableName, /* Table name */
|
@@ -5156,6 +5360,7 @@ SQLITE_API int sqlite3_table_column_metadata(
|
|
5156
5360
|
|
5157
5361
|
/*
|
5158
5362
|
** CAPI3REF: Load An Extension
|
5363
|
+
** METHOD: sqlite3
|
5159
5364
|
**
|
5160
5365
|
** ^This interface loads an SQLite extension library from the named file.
|
5161
5366
|
**
|
@@ -5188,7 +5393,7 @@ SQLITE_API int sqlite3_table_column_metadata(
|
|
5188
5393
|
**
|
5189
5394
|
** See also the [load_extension() SQL function].
|
5190
5395
|
*/
|
5191
|
-
SQLITE_API int sqlite3_load_extension(
|
5396
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_load_extension(
|
5192
5397
|
sqlite3 *db, /* Load the extension into this database connection */
|
5193
5398
|
const char *zFile, /* Name of the shared library containing extension */
|
5194
5399
|
const char *zProc, /* Entry point. Derived from zFile if 0 */
|
@@ -5197,6 +5402,7 @@ SQLITE_API int sqlite3_load_extension(
|
|
5197
5402
|
|
5198
5403
|
/*
|
5199
5404
|
** CAPI3REF: Enable Or Disable Extension Loading
|
5405
|
+
** METHOD: sqlite3
|
5200
5406
|
**
|
5201
5407
|
** ^So as not to open security holes in older applications that are
|
5202
5408
|
** unprepared to deal with [extension loading], and as a means of disabling
|
@@ -5208,7 +5414,7 @@ SQLITE_API int sqlite3_load_extension(
|
|
5208
5414
|
** to turn extension loading on and call it with onoff==0 to turn
|
5209
5415
|
** it back off again.
|
5210
5416
|
*/
|
5211
|
-
SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
|
5417
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_enable_load_extension(sqlite3 *db, int onoff);
|
5212
5418
|
|
5213
5419
|
/*
|
5214
5420
|
** CAPI3REF: Automatically Load Statically Linked Extensions
|
@@ -5246,7 +5452,7 @@ SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
|
|
5246
5452
|
** See also: [sqlite3_reset_auto_extension()]
|
5247
5453
|
** and [sqlite3_cancel_auto_extension()]
|
5248
5454
|
*/
|
5249
|
-
SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
|
5455
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_auto_extension(void (*xEntryPoint)(void));
|
5250
5456
|
|
5251
5457
|
/*
|
5252
5458
|
** CAPI3REF: Cancel Automatic Extension Loading
|
@@ -5258,7 +5464,7 @@ SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
|
|
5258
5464
|
** unregistered and it returns 0 if X was not on the list of initialization
|
5259
5465
|
** routines.
|
5260
5466
|
*/
|
5261
|
-
SQLITE_API int sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));
|
5467
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));
|
5262
5468
|
|
5263
5469
|
/*
|
5264
5470
|
** CAPI3REF: Reset Automatic Extension Loading
|
@@ -5266,7 +5472,7 @@ SQLITE_API int sqlite3_cancel_auto_extension(void (*xEntryPoint)(void));
|
|
5266
5472
|
** ^This interface disables all automatic extensions previously
|
5267
5473
|
** registered using [sqlite3_auto_extension()].
|
5268
5474
|
*/
|
5269
|
-
SQLITE_API void sqlite3_reset_auto_extension(void);
|
5475
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_reset_auto_extension(void);
|
5270
5476
|
|
5271
5477
|
/*
|
5272
5478
|
** The interface to the virtual-table mechanism is currently considered
|
@@ -5446,6 +5652,7 @@ struct sqlite3_index_info {
|
|
5446
5652
|
|
5447
5653
|
/*
|
5448
5654
|
** CAPI3REF: Register A Virtual Table Implementation
|
5655
|
+
** METHOD: sqlite3
|
5449
5656
|
**
|
5450
5657
|
** ^These routines are used to register a new [virtual table module] name.
|
5451
5658
|
** ^Module names must be registered before
|
@@ -5469,13 +5676,13 @@ struct sqlite3_index_info {
|
|
5469
5676
|
** interface is equivalent to sqlite3_create_module_v2() with a NULL
|
5470
5677
|
** destructor.
|
5471
5678
|
*/
|
5472
|
-
SQLITE_API int sqlite3_create_module(
|
5679
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_create_module(
|
5473
5680
|
sqlite3 *db, /* SQLite connection to register module with */
|
5474
5681
|
const char *zName, /* Name of the module */
|
5475
5682
|
const sqlite3_module *p, /* Methods for the module */
|
5476
5683
|
void *pClientData /* Client data for xCreate/xConnect */
|
5477
5684
|
);
|
5478
|
-
SQLITE_API int sqlite3_create_module_v2(
|
5685
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_create_module_v2(
|
5479
5686
|
sqlite3 *db, /* SQLite connection to register module with */
|
5480
5687
|
const char *zName, /* Name of the module */
|
5481
5688
|
const sqlite3_module *p, /* Methods for the module */
|
@@ -5503,7 +5710,7 @@ SQLITE_API int sqlite3_create_module_v2(
|
|
5503
5710
|
*/
|
5504
5711
|
struct sqlite3_vtab {
|
5505
5712
|
const sqlite3_module *pModule; /* The module for this virtual table */
|
5506
|
-
int nRef; /*
|
5713
|
+
int nRef; /* Number of open cursors */
|
5507
5714
|
char *zErrMsg; /* Error message from sqlite3_mprintf() */
|
5508
5715
|
/* Virtual table implementations will typically add additional fields */
|
5509
5716
|
};
|
@@ -5538,10 +5745,11 @@ struct sqlite3_vtab_cursor {
|
|
5538
5745
|
** to declare the format (the names and datatypes of the columns) of
|
5539
5746
|
** the virtual tables they implement.
|
5540
5747
|
*/
|
5541
|
-
SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
|
5748
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_declare_vtab(sqlite3*, const char *zSQL);
|
5542
5749
|
|
5543
5750
|
/*
|
5544
5751
|
** CAPI3REF: Overload A Function For A Virtual Table
|
5752
|
+
** METHOD: sqlite3
|
5545
5753
|
**
|
5546
5754
|
** ^(Virtual tables can provide alternative implementations of functions
|
5547
5755
|
** using the [xFindFunction] method of the [virtual table module].
|
@@ -5556,7 +5764,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
|
|
5556
5764
|
** purpose is to be a placeholder function that can be overloaded
|
5557
5765
|
** by a [virtual table].
|
5558
5766
|
*/
|
5559
|
-
SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
|
5767
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
|
5560
5768
|
|
5561
5769
|
/*
|
5562
5770
|
** The interface to the virtual-table mechanism defined above (back up
|
@@ -5584,6 +5792,8 @@ typedef struct sqlite3_blob sqlite3_blob;
|
|
5584
5792
|
|
5585
5793
|
/*
|
5586
5794
|
** CAPI3REF: Open A BLOB For Incremental I/O
|
5795
|
+
** METHOD: sqlite3
|
5796
|
+
** CONSTRUCTOR: sqlite3_blob
|
5587
5797
|
**
|
5588
5798
|
** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located
|
5589
5799
|
** in row iRow, column zColumn, table zTable in database zDb;
|
@@ -5593,26 +5803,42 @@ typedef struct sqlite3_blob sqlite3_blob;
|
|
5593
5803
|
** SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
|
5594
5804
|
** </pre>)^
|
5595
5805
|
**
|
5806
|
+
** ^(Parameter zDb is not the filename that contains the database, but
|
5807
|
+
** rather the symbolic name of the database. For attached databases, this is
|
5808
|
+
** the name that appears after the AS keyword in the [ATTACH] statement.
|
5809
|
+
** For the main database file, the database name is "main". For TEMP
|
5810
|
+
** tables, the database name is "temp".)^
|
5811
|
+
**
|
5596
5812
|
** ^If the flags parameter is non-zero, then the BLOB is opened for read
|
5597
|
-
** and write access. ^If
|
5598
|
-
**
|
5599
|
-
**
|
5600
|
-
**
|
5601
|
-
**
|
5602
|
-
**
|
5603
|
-
** the
|
5604
|
-
**
|
5605
|
-
**
|
5606
|
-
**
|
5607
|
-
**
|
5608
|
-
** ^(
|
5609
|
-
**
|
5610
|
-
**
|
5611
|
-
** ^
|
5612
|
-
**
|
5613
|
-
**
|
5614
|
-
**
|
5615
|
-
**
|
5813
|
+
** and write access. ^If the flags parameter is zero, the BLOB is opened for
|
5814
|
+
** read-only access.
|
5815
|
+
**
|
5816
|
+
** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is stored
|
5817
|
+
** in *ppBlob. Otherwise an [error code] is returned and, unless the error
|
5818
|
+
** code is SQLITE_MISUSE, *ppBlob is set to NULL.)^ ^This means that, provided
|
5819
|
+
** the API is not misused, it is always safe to call [sqlite3_blob_close()]
|
5820
|
+
** on *ppBlob after this function it returns.
|
5821
|
+
**
|
5822
|
+
** This function fails with SQLITE_ERROR if any of the following are true:
|
5823
|
+
** <ul>
|
5824
|
+
** <li> ^(Database zDb does not exist)^,
|
5825
|
+
** <li> ^(Table zTable does not exist within database zDb)^,
|
5826
|
+
** <li> ^(Table zTable is a WITHOUT ROWID table)^,
|
5827
|
+
** <li> ^(Column zColumn does not exist)^,
|
5828
|
+
** <li> ^(Row iRow is not present in the table)^,
|
5829
|
+
** <li> ^(The specified column of row iRow contains a value that is not
|
5830
|
+
** a TEXT or BLOB value)^,
|
5831
|
+
** <li> ^(Column zColumn is part of an index, PRIMARY KEY or UNIQUE
|
5832
|
+
** constraint and the blob is being opened for read/write access)^,
|
5833
|
+
** <li> ^([foreign key constraints | Foreign key constraints] are enabled,
|
5834
|
+
** column zColumn is part of a [child key] definition and the blob is
|
5835
|
+
** being opened for read/write access)^.
|
5836
|
+
** </ul>
|
5837
|
+
**
|
5838
|
+
** ^Unless it returns SQLITE_MISUSE, this function sets the
|
5839
|
+
** [database connection] error code and message accessible via
|
5840
|
+
** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions.
|
5841
|
+
**
|
5616
5842
|
**
|
5617
5843
|
** ^(If the row that a BLOB handle points to is modified by an
|
5618
5844
|
** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects
|
@@ -5630,18 +5856,14 @@ typedef struct sqlite3_blob sqlite3_blob;
|
|
5630
5856
|
** interface. Use the [UPDATE] SQL command to change the size of a
|
5631
5857
|
** blob.
|
5632
5858
|
**
|
5633
|
-
** ^The [sqlite3_blob_open()] interface will fail for a [WITHOUT ROWID]
|
5634
|
-
** table. Incremental BLOB I/O is not possible on [WITHOUT ROWID] tables.
|
5635
|
-
**
|
5636
5859
|
** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces
|
5637
|
-
** and the built-in [zeroblob] SQL function
|
5638
|
-
**
|
5639
|
-
** this interface.
|
5860
|
+
** and the built-in [zeroblob] SQL function may be used to create a
|
5861
|
+
** zero-filled blob to read or write using the incremental-blob interface.
|
5640
5862
|
**
|
5641
5863
|
** To avoid a resource leak, every open [BLOB handle] should eventually
|
5642
5864
|
** be released by a call to [sqlite3_blob_close()].
|
5643
5865
|
*/
|
5644
|
-
SQLITE_API int sqlite3_blob_open(
|
5866
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_blob_open(
|
5645
5867
|
sqlite3*,
|
5646
5868
|
const char *zDb,
|
5647
5869
|
const char *zTable,
|
@@ -5653,6 +5875,7 @@ SQLITE_API int sqlite3_blob_open(
|
|
5653
5875
|
|
5654
5876
|
/*
|
5655
5877
|
** CAPI3REF: Move a BLOB Handle to a New Row
|
5878
|
+
** METHOD: sqlite3_blob
|
5656
5879
|
**
|
5657
5880
|
** ^This function is used to move an existing blob handle so that it points
|
5658
5881
|
** to a different row of the same database table. ^The new row is identified
|
@@ -5673,34 +5896,34 @@ SQLITE_API int sqlite3_blob_open(
|
|
5673
5896
|
**
|
5674
5897
|
** ^This function sets the database handle error code and message.
|
5675
5898
|
*/
|
5676
|
-
SQLITE_API
|
5899
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);
|
5677
5900
|
|
5678
5901
|
/*
|
5679
5902
|
** CAPI3REF: Close A BLOB Handle
|
5903
|
+
** DESTRUCTOR: sqlite3_blob
|
5680
5904
|
**
|
5681
|
-
** ^
|
5682
|
-
**
|
5683
|
-
**
|
5684
|
-
** if there are no other BLOBs, no pending prepared statements, and the
|
5685
|
-
** database connection is in [autocommit mode].
|
5686
|
-
** ^If any writes were made to the BLOB, they might be held in cache
|
5687
|
-
** until the close operation if they will fit.
|
5688
|
-
**
|
5689
|
-
** ^(Closing the BLOB often forces the changes
|
5690
|
-
** out to disk and so if any I/O errors occur, they will likely occur
|
5691
|
-
** at the time when the BLOB is closed. Any errors that occur during
|
5692
|
-
** closing are reported as a non-zero return value.)^
|
5905
|
+
** ^This function closes an open [BLOB handle]. ^(The BLOB handle is closed
|
5906
|
+
** unconditionally. Even if this routine returns an error code, the
|
5907
|
+
** handle is still closed.)^
|
5693
5908
|
**
|
5694
|
-
** ^
|
5695
|
-
**
|
5909
|
+
** ^If the blob handle being closed was opened for read-write access, and if
|
5910
|
+
** the database is in auto-commit mode and there are no other open read-write
|
5911
|
+
** blob handles or active write statements, the current transaction is
|
5912
|
+
** committed. ^If an error occurs while committing the transaction, an error
|
5913
|
+
** code is returned and the transaction rolled back.
|
5696
5914
|
**
|
5697
|
-
**
|
5698
|
-
**
|
5915
|
+
** Calling this function with an argument that is not a NULL pointer or an
|
5916
|
+
** open blob handle results in undefined behaviour. ^Calling this routine
|
5917
|
+
** with a null pointer (such as would be returned by a failed call to
|
5918
|
+
** [sqlite3_blob_open()]) is a harmless no-op. ^Otherwise, if this function
|
5919
|
+
** is passed a valid open blob handle, the values returned by the
|
5920
|
+
** sqlite3_errcode() and sqlite3_errmsg() functions are set before returning.
|
5699
5921
|
*/
|
5700
|
-
SQLITE_API int sqlite3_blob_close(sqlite3_blob *);
|
5922
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_blob_close(sqlite3_blob *);
|
5701
5923
|
|
5702
5924
|
/*
|
5703
5925
|
** CAPI3REF: Return The Size Of An Open BLOB
|
5926
|
+
** METHOD: sqlite3_blob
|
5704
5927
|
**
|
5705
5928
|
** ^Returns the size in bytes of the BLOB accessible via the
|
5706
5929
|
** successfully opened [BLOB handle] in its only argument. ^The
|
@@ -5712,10 +5935,11 @@ SQLITE_API int sqlite3_blob_close(sqlite3_blob *);
|
|
5712
5935
|
** been closed by [sqlite3_blob_close()]. Passing any other pointer in
|
5713
5936
|
** to this routine results in undefined and probably undesirable behavior.
|
5714
5937
|
*/
|
5715
|
-
SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);
|
5938
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_blob_bytes(sqlite3_blob *);
|
5716
5939
|
|
5717
5940
|
/*
|
5718
5941
|
** CAPI3REF: Read Data From A BLOB Incrementally
|
5942
|
+
** METHOD: sqlite3_blob
|
5719
5943
|
**
|
5720
5944
|
** ^(This function is used to read data from an open [BLOB handle] into a
|
5721
5945
|
** caller-supplied buffer. N bytes of data are copied into buffer Z
|
@@ -5740,26 +5964,33 @@ SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);
|
|
5740
5964
|
**
|
5741
5965
|
** See also: [sqlite3_blob_write()].
|
5742
5966
|
*/
|
5743
|
-
SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
|
5967
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
|
5744
5968
|
|
5745
5969
|
/*
|
5746
5970
|
** CAPI3REF: Write Data Into A BLOB Incrementally
|
5971
|
+
** METHOD: sqlite3_blob
|
5747
5972
|
**
|
5748
|
-
** ^This function is used to write data into an open [BLOB handle] from a
|
5749
|
-
** caller-supplied buffer.
|
5750
|
-
** into the open BLOB, starting at offset iOffset.
|
5973
|
+
** ^(This function is used to write data into an open [BLOB handle] from a
|
5974
|
+
** caller-supplied buffer. N bytes of data are copied from the buffer Z
|
5975
|
+
** into the open BLOB, starting at offset iOffset.)^
|
5976
|
+
**
|
5977
|
+
** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
|
5978
|
+
** Otherwise, an [error code] or an [extended error code] is returned.)^
|
5979
|
+
** ^Unless SQLITE_MISUSE is returned, this function sets the
|
5980
|
+
** [database connection] error code and message accessible via
|
5981
|
+
** [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions.
|
5751
5982
|
**
|
5752
5983
|
** ^If the [BLOB handle] passed as the first argument was not opened for
|
5753
5984
|
** writing (the flags parameter to [sqlite3_blob_open()] was zero),
|
5754
5985
|
** this function returns [SQLITE_READONLY].
|
5755
5986
|
**
|
5756
|
-
**
|
5987
|
+
** This function may only modify the contents of the BLOB; it is
|
5757
5988
|
** not possible to increase the size of a BLOB using this API.
|
5758
5989
|
** ^If offset iOffset is less than N bytes from the end of the BLOB,
|
5759
|
-
** [SQLITE_ERROR] is returned and no data is written.
|
5760
|
-
**
|
5761
|
-
**
|
5762
|
-
**
|
5990
|
+
** [SQLITE_ERROR] is returned and no data is written. The size of the
|
5991
|
+
** BLOB (and hence the maximum value of N+iOffset) can be determined
|
5992
|
+
** using the [sqlite3_blob_bytes()] interface. ^If N or iOffset are less
|
5993
|
+
** than zero [SQLITE_ERROR] is returned and no data is written.
|
5763
5994
|
**
|
5764
5995
|
** ^An attempt to write to an expired [BLOB handle] fails with an
|
5765
5996
|
** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred
|
@@ -5768,9 +5999,6 @@ SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
|
|
5768
5999
|
** have been overwritten by the statement that expired the BLOB handle
|
5769
6000
|
** or by other independent statements.
|
5770
6001
|
**
|
5771
|
-
** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
|
5772
|
-
** Otherwise, an [error code] or an [extended error code] is returned.)^
|
5773
|
-
**
|
5774
6002
|
** This routine only works on a [BLOB handle] which has been created
|
5775
6003
|
** by a prior successful call to [sqlite3_blob_open()] and which has not
|
5776
6004
|
** been closed by [sqlite3_blob_close()]. Passing any other pointer in
|
@@ -5778,7 +6006,7 @@ SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
|
|
5778
6006
|
**
|
5779
6007
|
** See also: [sqlite3_blob_read()].
|
5780
6008
|
*/
|
5781
|
-
SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
|
6009
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
|
5782
6010
|
|
5783
6011
|
/*
|
5784
6012
|
** CAPI3REF: Virtual File System Objects
|
@@ -5809,9 +6037,9 @@ SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOff
|
|
5809
6037
|
** ^(If the default VFS is unregistered, another VFS is chosen as
|
5810
6038
|
** the default. The choice for the new VFS is arbitrary.)^
|
5811
6039
|
*/
|
5812
|
-
SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
|
5813
|
-
SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
|
5814
|
-
SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
|
6040
|
+
SQLITE_API sqlite3_vfs *SQLITE_STDCALL sqlite3_vfs_find(const char *zVfsName);
|
6041
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
|
6042
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_vfs_unregister(sqlite3_vfs*);
|
5815
6043
|
|
5816
6044
|
/*
|
5817
6045
|
** CAPI3REF: Mutexes
|
@@ -5823,34 +6051,34 @@ SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
|
|
5823
6051
|
**
|
5824
6052
|
** The SQLite source code contains multiple implementations
|
5825
6053
|
** of these mutex routines. An appropriate implementation
|
5826
|
-
** is selected automatically at compile-time.
|
6054
|
+
** is selected automatically at compile-time. The following
|
5827
6055
|
** implementations are available in the SQLite core:
|
5828
6056
|
**
|
5829
6057
|
** <ul>
|
5830
6058
|
** <li> SQLITE_MUTEX_PTHREADS
|
5831
6059
|
** <li> SQLITE_MUTEX_W32
|
5832
6060
|
** <li> SQLITE_MUTEX_NOOP
|
5833
|
-
** </ul>
|
6061
|
+
** </ul>
|
5834
6062
|
**
|
5835
|
-
**
|
6063
|
+
** The SQLITE_MUTEX_NOOP implementation is a set of routines
|
5836
6064
|
** that does no real locking and is appropriate for use in
|
5837
|
-
** a single-threaded application.
|
6065
|
+
** a single-threaded application. The SQLITE_MUTEX_PTHREADS and
|
5838
6066
|
** SQLITE_MUTEX_W32 implementations are appropriate for use on Unix
|
5839
6067
|
** and Windows.
|
5840
6068
|
**
|
5841
|
-
**
|
6069
|
+
** If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
|
5842
6070
|
** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
|
5843
6071
|
** implementation is included with the library. In this case the
|
5844
6072
|
** application must supply a custom mutex implementation using the
|
5845
6073
|
** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function
|
5846
6074
|
** before calling sqlite3_initialize() or any other public sqlite3_
|
5847
|
-
** function that calls sqlite3_initialize().
|
6075
|
+
** function that calls sqlite3_initialize().
|
5848
6076
|
**
|
5849
6077
|
** ^The sqlite3_mutex_alloc() routine allocates a new
|
5850
|
-
** mutex and returns a pointer to it. ^
|
5851
|
-
**
|
5852
|
-
**
|
5853
|
-
**
|
6078
|
+
** mutex and returns a pointer to it. ^The sqlite3_mutex_alloc()
|
6079
|
+
** routine returns NULL if it is unable to allocate the requested
|
6080
|
+
** mutex. The argument to sqlite3_mutex_alloc() must one of these
|
6081
|
+
** integer constants:
|
5854
6082
|
**
|
5855
6083
|
** <ul>
|
5856
6084
|
** <li> SQLITE_MUTEX_FAST
|
@@ -5863,7 +6091,8 @@ SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
|
|
5863
6091
|
** <li> SQLITE_MUTEX_STATIC_PMEM
|
5864
6092
|
** <li> SQLITE_MUTEX_STATIC_APP1
|
5865
6093
|
** <li> SQLITE_MUTEX_STATIC_APP2
|
5866
|
-
**
|
6094
|
+
** <li> SQLITE_MUTEX_STATIC_APP3
|
6095
|
+
** </ul>
|
5867
6096
|
**
|
5868
6097
|
** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE)
|
5869
6098
|
** cause sqlite3_mutex_alloc() to create
|
@@ -5871,14 +6100,14 @@ SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
|
|
5871
6100
|
** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
|
5872
6101
|
** The mutex implementation does not need to make a distinction
|
5873
6102
|
** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
|
5874
|
-
** not want to.
|
5875
|
-
** cases where it really needs one.
|
6103
|
+
** not want to. SQLite will only request a recursive mutex in
|
6104
|
+
** cases where it really needs one. If a faster non-recursive mutex
|
5876
6105
|
** implementation is available on the host platform, the mutex subsystem
|
5877
6106
|
** might return such a mutex in response to SQLITE_MUTEX_FAST.
|
5878
6107
|
**
|
5879
6108
|
** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other
|
5880
6109
|
** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return
|
5881
|
-
** a pointer to a static preexisting mutex. ^
|
6110
|
+
** a pointer to a static preexisting mutex. ^Nine static mutexes are
|
5882
6111
|
** used by the current version of SQLite. Future versions of SQLite
|
5883
6112
|
** may add additional static mutexes. Static mutexes are for internal
|
5884
6113
|
** use by SQLite only. Applications that use SQLite mutexes should
|
@@ -5887,16 +6116,13 @@ SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
|
|
5887
6116
|
**
|
5888
6117
|
** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
|
5889
6118
|
** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
|
5890
|
-
** returns a different mutex on every call. ^
|
6119
|
+
** returns a different mutex on every call. ^For the static
|
5891
6120
|
** mutex types, the same mutex is returned on every call that has
|
5892
6121
|
** the same type number.
|
5893
6122
|
**
|
5894
6123
|
** ^The sqlite3_mutex_free() routine deallocates a previously
|
5895
|
-
** allocated dynamic mutex.
|
5896
|
-
**
|
5897
|
-
** use when they are deallocated. Attempting to deallocate a static
|
5898
|
-
** mutex results in undefined behavior. ^SQLite never deallocates
|
5899
|
-
** a static mutex.
|
6124
|
+
** allocated dynamic mutex. Attempting to deallocate a static
|
6125
|
+
** mutex results in undefined behavior.
|
5900
6126
|
**
|
5901
6127
|
** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
|
5902
6128
|
** to enter a mutex. ^If another thread is already within the mutex,
|
@@ -5904,23 +6130,21 @@ SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
|
|
5904
6130
|
** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
|
5905
6131
|
** upon successful entry. ^(Mutexes created using
|
5906
6132
|
** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread.
|
5907
|
-
** In such cases the
|
6133
|
+
** In such cases, the
|
5908
6134
|
** mutex must be exited an equal number of times before another thread
|
5909
|
-
** can enter.)^
|
5910
|
-
**
|
5911
|
-
** SQLite will never exhibit
|
5912
|
-
** such behavior in its own use of mutexes.)^
|
6135
|
+
** can enter.)^ If the same thread tries to enter any mutex other
|
6136
|
+
** than an SQLITE_MUTEX_RECURSIVE more than once, the behavior is undefined.
|
5913
6137
|
**
|
5914
6138
|
** ^(Some systems (for example, Windows 95) do not support the operation
|
5915
6139
|
** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try()
|
5916
|
-
** will always return SQLITE_BUSY.
|
5917
|
-
** sqlite3_mutex_try() as an optimization so this is acceptable
|
6140
|
+
** will always return SQLITE_BUSY. The SQLite core only ever uses
|
6141
|
+
** sqlite3_mutex_try() as an optimization so this is acceptable
|
6142
|
+
** behavior.)^
|
5918
6143
|
**
|
5919
6144
|
** ^The sqlite3_mutex_leave() routine exits a mutex that was
|
5920
|
-
** previously entered by the same thread.
|
6145
|
+
** previously entered by the same thread. The behavior
|
5921
6146
|
** is undefined if the mutex is not currently entered by the
|
5922
|
-
** calling thread or is not currently allocated.
|
5923
|
-
** never do either.)^
|
6147
|
+
** calling thread or is not currently allocated.
|
5924
6148
|
**
|
5925
6149
|
** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or
|
5926
6150
|
** sqlite3_mutex_leave() is a NULL pointer, then all three routines
|
@@ -5928,11 +6152,11 @@ SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
|
|
5928
6152
|
**
|
5929
6153
|
** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
|
5930
6154
|
*/
|
5931
|
-
SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int);
|
5932
|
-
SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*);
|
5933
|
-
SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*);
|
5934
|
-
SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*);
|
5935
|
-
SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
|
6155
|
+
SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_mutex_alloc(int);
|
6156
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_mutex_free(sqlite3_mutex*);
|
6157
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_mutex_enter(sqlite3_mutex*);
|
6158
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_mutex_try(sqlite3_mutex*);
|
6159
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_mutex_leave(sqlite3_mutex*);
|
5936
6160
|
|
5937
6161
|
/*
|
5938
6162
|
** CAPI3REF: Mutex Methods Object
|
@@ -5941,9 +6165,9 @@ SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
|
|
5941
6165
|
** used to allocate and use mutexes.
|
5942
6166
|
**
|
5943
6167
|
** Usually, the default mutex implementations provided by SQLite are
|
5944
|
-
** sufficient, however the
|
6168
|
+
** sufficient, however the application has the option of substituting a custom
|
5945
6169
|
** implementation for specialized deployments or systems for which SQLite
|
5946
|
-
** does not provide a suitable implementation. In this case, the
|
6170
|
+
** does not provide a suitable implementation. In this case, the application
|
5947
6171
|
** creates and populates an instance of this structure to pass
|
5948
6172
|
** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option.
|
5949
6173
|
** Additionally, an instance of this structure can be used as an
|
@@ -5984,13 +6208,13 @@ SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
|
|
5984
6208
|
** (i.e. it is acceptable to provide an implementation that segfaults if
|
5985
6209
|
** it is passed a NULL pointer).
|
5986
6210
|
**
|
5987
|
-
** The xMutexInit() method must be threadsafe.
|
6211
|
+
** The xMutexInit() method must be threadsafe. It must be harmless to
|
5988
6212
|
** invoke xMutexInit() multiple times within the same process and without
|
5989
6213
|
** intervening calls to xMutexEnd(). Second and subsequent calls to
|
5990
6214
|
** xMutexInit() must be no-ops.
|
5991
6215
|
**
|
5992
|
-
**
|
5993
|
-
** and its associates).
|
6216
|
+
** xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
|
6217
|
+
** and its associates). Similarly, xMutexAlloc() must not use SQLite memory
|
5994
6218
|
** allocation for a static mutex. ^However xMutexAlloc() may use SQLite
|
5995
6219
|
** memory allocation for a fast or recursive mutex.
|
5996
6220
|
**
|
@@ -6016,34 +6240,34 @@ struct sqlite3_mutex_methods {
|
|
6016
6240
|
** CAPI3REF: Mutex Verification Routines
|
6017
6241
|
**
|
6018
6242
|
** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines
|
6019
|
-
** are intended for use inside assert() statements.
|
6243
|
+
** are intended for use inside assert() statements. The SQLite core
|
6020
6244
|
** never uses these routines except inside an assert() and applications
|
6021
|
-
** are advised to follow the lead of the core.
|
6245
|
+
** are advised to follow the lead of the core. The SQLite core only
|
6022
6246
|
** provides implementations for these routines when it is compiled
|
6023
|
-
** with the SQLITE_DEBUG flag.
|
6247
|
+
** with the SQLITE_DEBUG flag. External mutex implementations
|
6024
6248
|
** are only required to provide these routines if SQLITE_DEBUG is
|
6025
6249
|
** defined and if NDEBUG is not defined.
|
6026
6250
|
**
|
6027
|
-
**
|
6251
|
+
** These routines should return true if the mutex in their argument
|
6028
6252
|
** is held or not held, respectively, by the calling thread.
|
6029
6253
|
**
|
6030
|
-
**
|
6254
|
+
** The implementation is not required to provide versions of these
|
6031
6255
|
** routines that actually work. If the implementation does not provide working
|
6032
6256
|
** versions of these routines, it should at least provide stubs that always
|
6033
6257
|
** return true so that one does not get spurious assertion failures.
|
6034
6258
|
**
|
6035
|
-
**
|
6259
|
+
** If the argument to sqlite3_mutex_held() is a NULL pointer then
|
6036
6260
|
** the routine should return 1. This seems counter-intuitive since
|
6037
6261
|
** clearly the mutex cannot be held if it does not exist. But
|
6038
6262
|
** the reason the mutex does not exist is because the build is not
|
6039
6263
|
** using mutexes. And we do not want the assert() containing the
|
6040
6264
|
** call to sqlite3_mutex_held() to fail, so a non-zero return is
|
6041
|
-
** the appropriate thing to do.
|
6265
|
+
** the appropriate thing to do. The sqlite3_mutex_notheld()
|
6042
6266
|
** interface should also return 1 when given a NULL pointer.
|
6043
6267
|
*/
|
6044
6268
|
#ifndef NDEBUG
|
6045
|
-
SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*);
|
6046
|
-
SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);
|
6269
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_mutex_held(sqlite3_mutex*);
|
6270
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_mutex_notheld(sqlite3_mutex*);
|
6047
6271
|
#endif
|
6048
6272
|
|
6049
6273
|
/*
|
@@ -6069,9 +6293,13 @@ SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);
|
|
6069
6293
|
#define SQLITE_MUTEX_STATIC_APP1 8 /* For use by application */
|
6070
6294
|
#define SQLITE_MUTEX_STATIC_APP2 9 /* For use by application */
|
6071
6295
|
#define SQLITE_MUTEX_STATIC_APP3 10 /* For use by application */
|
6296
|
+
#define SQLITE_MUTEX_STATIC_VFS1 11 /* For use by built-in VFS */
|
6297
|
+
#define SQLITE_MUTEX_STATIC_VFS2 12 /* For use by extension VFS */
|
6298
|
+
#define SQLITE_MUTEX_STATIC_VFS3 13 /* For use by application VFS */
|
6072
6299
|
|
6073
6300
|
/*
|
6074
6301
|
** CAPI3REF: Retrieve the mutex for a database connection
|
6302
|
+
** METHOD: sqlite3
|
6075
6303
|
**
|
6076
6304
|
** ^This interface returns a pointer the [sqlite3_mutex] object that
|
6077
6305
|
** serializes access to the [database connection] given in the argument
|
@@ -6079,10 +6307,11 @@ SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);
|
|
6079
6307
|
** ^If the [threading mode] is Single-thread or Multi-thread then this
|
6080
6308
|
** routine returns a NULL pointer.
|
6081
6309
|
*/
|
6082
|
-
SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
|
6310
|
+
SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_db_mutex(sqlite3*);
|
6083
6311
|
|
6084
6312
|
/*
|
6085
6313
|
** CAPI3REF: Low-Level Control Of Database Files
|
6314
|
+
** METHOD: sqlite3
|
6086
6315
|
**
|
6087
6316
|
** ^The [sqlite3_file_control()] interface makes a direct call to the
|
6088
6317
|
** xFileControl method for the [sqlite3_io_methods] object associated
|
@@ -6113,7 +6342,7 @@ SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
|
|
6113
6342
|
**
|
6114
6343
|
** See also: [SQLITE_FCNTL_LOCKSTATE]
|
6115
6344
|
*/
|
6116
|
-
SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
|
6345
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
|
6117
6346
|
|
6118
6347
|
/*
|
6119
6348
|
** CAPI3REF: Testing Interface
|
@@ -6132,7 +6361,7 @@ SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*
|
|
6132
6361
|
** Unlike most of the SQLite API, this function is not guaranteed to
|
6133
6362
|
** operate consistently from one release to the next.
|
6134
6363
|
*/
|
6135
|
-
SQLITE_API int sqlite3_test_control(int op, ...);
|
6364
|
+
SQLITE_API int SQLITE_CDECL sqlite3_test_control(int op, ...);
|
6136
6365
|
|
6137
6366
|
/*
|
6138
6367
|
** CAPI3REF: Testing Interface Operation Codes
|
@@ -6160,17 +6389,19 @@ SQLITE_API int sqlite3_test_control(int op, ...);
|
|
6160
6389
|
#define SQLITE_TESTCTRL_ISKEYWORD 16
|
6161
6390
|
#define SQLITE_TESTCTRL_SCRATCHMALLOC 17
|
6162
6391
|
#define SQLITE_TESTCTRL_LOCALTIME_FAULT 18
|
6163
|
-
#define SQLITE_TESTCTRL_EXPLAIN_STMT 19
|
6392
|
+
#define SQLITE_TESTCTRL_EXPLAIN_STMT 19 /* NOT USED */
|
6164
6393
|
#define SQLITE_TESTCTRL_NEVER_CORRUPT 20
|
6165
6394
|
#define SQLITE_TESTCTRL_VDBE_COVERAGE 21
|
6166
6395
|
#define SQLITE_TESTCTRL_BYTEORDER 22
|
6167
6396
|
#define SQLITE_TESTCTRL_ISINIT 23
|
6168
|
-
#define
|
6397
|
+
#define SQLITE_TESTCTRL_SORTER_MMAP 24
|
6398
|
+
#define SQLITE_TESTCTRL_IMPOSTER 25
|
6399
|
+
#define SQLITE_TESTCTRL_LAST 25
|
6169
6400
|
|
6170
6401
|
/*
|
6171
6402
|
** CAPI3REF: SQLite Runtime Status
|
6172
6403
|
**
|
6173
|
-
** ^
|
6404
|
+
** ^These interfaces are used to retrieve runtime status information
|
6174
6405
|
** about the performance of SQLite, and optionally to reset various
|
6175
6406
|
** highwater marks. ^The first argument is an integer code for
|
6176
6407
|
** the specific parameter to measure. ^(Recognized integer codes
|
@@ -6184,19 +6415,22 @@ SQLITE_API int sqlite3_test_control(int op, ...);
|
|
6184
6415
|
** ^(Other parameters record only the highwater mark and not the current
|
6185
6416
|
** value. For these latter parameters nothing is written into *pCurrent.)^
|
6186
6417
|
**
|
6187
|
-
** ^The sqlite3_status()
|
6188
|
-
** non-zero [error code] on failure.
|
6418
|
+
** ^The sqlite3_status() and sqlite3_status64() routines return
|
6419
|
+
** SQLITE_OK on success and a non-zero [error code] on failure.
|
6189
6420
|
**
|
6190
|
-
**
|
6191
|
-
**
|
6192
|
-
**
|
6193
|
-
** *pHighwater reflect the status of SQLite at different points in time
|
6194
|
-
** and it is possible that another thread might change the parameter
|
6195
|
-
** in between the times when *pCurrent and *pHighwater are written.
|
6421
|
+
** If either the current value or the highwater mark is too large to
|
6422
|
+
** be represented by a 32-bit integer, then the values returned by
|
6423
|
+
** sqlite3_status() are undefined.
|
6196
6424
|
**
|
6197
6425
|
** See also: [sqlite3_db_status()]
|
6198
6426
|
*/
|
6199
|
-
SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
|
6427
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
|
6428
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_status64(
|
6429
|
+
int op,
|
6430
|
+
sqlite3_int64 *pCurrent,
|
6431
|
+
sqlite3_int64 *pHighwater,
|
6432
|
+
int resetFlag
|
6433
|
+
);
|
6200
6434
|
|
6201
6435
|
|
6202
6436
|
/*
|
@@ -6294,6 +6528,7 @@ SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetF
|
|
6294
6528
|
|
6295
6529
|
/*
|
6296
6530
|
** CAPI3REF: Database Connection Status
|
6531
|
+
** METHOD: sqlite3
|
6297
6532
|
**
|
6298
6533
|
** ^This interface is used to retrieve runtime status information
|
6299
6534
|
** about a single [database connection]. ^The first argument is the
|
@@ -6314,7 +6549,7 @@ SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetF
|
|
6314
6549
|
**
|
6315
6550
|
** See also: [sqlite3_status()] and [sqlite3_stmt_status()].
|
6316
6551
|
*/
|
6317
|
-
SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
|
6552
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
|
6318
6553
|
|
6319
6554
|
/*
|
6320
6555
|
** CAPI3REF: Status Parameters for database connections
|
@@ -6356,12 +6591,12 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r
|
|
6356
6591
|
** the current value is always zero.)^
|
6357
6592
|
**
|
6358
6593
|
** [[SQLITE_DBSTATUS_CACHE_USED]] ^(<dt>SQLITE_DBSTATUS_CACHE_USED</dt>
|
6359
|
-
** <dd>This parameter returns the approximate number of
|
6594
|
+
** <dd>This parameter returns the approximate number of bytes of heap
|
6360
6595
|
** memory used by all pager caches associated with the database connection.)^
|
6361
6596
|
** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
|
6362
6597
|
**
|
6363
6598
|
** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(<dt>SQLITE_DBSTATUS_SCHEMA_USED</dt>
|
6364
|
-
** <dd>This parameter returns the approximate number of
|
6599
|
+
** <dd>This parameter returns the approximate number of bytes of heap
|
6365
6600
|
** memory used to store the schema for all databases associated
|
6366
6601
|
** with the connection - main, temp, and any [ATTACH]-ed databases.)^
|
6367
6602
|
** ^The full amount of memory used by the schemas is reported, even if the
|
@@ -6370,7 +6605,7 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r
|
|
6370
6605
|
** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0.
|
6371
6606
|
**
|
6372
6607
|
** [[SQLITE_DBSTATUS_STMT_USED]] ^(<dt>SQLITE_DBSTATUS_STMT_USED</dt>
|
6373
|
-
** <dd>This parameter returns the approximate number of
|
6608
|
+
** <dd>This parameter returns the approximate number of bytes of heap
|
6374
6609
|
** and lookaside memory used by all prepared statements associated with
|
6375
6610
|
** the database connection.)^
|
6376
6611
|
** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0.
|
@@ -6422,6 +6657,7 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r
|
|
6422
6657
|
|
6423
6658
|
/*
|
6424
6659
|
** CAPI3REF: Prepared Statement Status
|
6660
|
+
** METHOD: sqlite3_stmt
|
6425
6661
|
**
|
6426
6662
|
** ^(Each prepared statement maintains various
|
6427
6663
|
** [SQLITE_STMTSTATUS counters] that measure the number
|
@@ -6443,7 +6679,7 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r
|
|
6443
6679
|
**
|
6444
6680
|
** See also: [sqlite3_status()] and [sqlite3_db_status()].
|
6445
6681
|
*/
|
6446
|
-
SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
|
6682
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
|
6447
6683
|
|
6448
6684
|
/*
|
6449
6685
|
** CAPI3REF: Status Parameters for prepared statements
|
@@ -6770,6 +7006,10 @@ typedef struct sqlite3_backup sqlite3_backup;
|
|
6770
7006
|
** must be different or else sqlite3_backup_init(D,N,S,M) will fail with
|
6771
7007
|
** an error.
|
6772
7008
|
**
|
7009
|
+
** ^A call to sqlite3_backup_init() will fail, returning SQLITE_ERROR, if
|
7010
|
+
** there is already a read or read-write transaction open on the
|
7011
|
+
** destination database.
|
7012
|
+
**
|
6773
7013
|
** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is
|
6774
7014
|
** returned and an error code and error message are stored in the
|
6775
7015
|
** destination [database connection] D.
|
@@ -6862,20 +7102,20 @@ typedef struct sqlite3_backup sqlite3_backup;
|
|
6862
7102
|
** is not a permanent error and does not affect the return value of
|
6863
7103
|
** sqlite3_backup_finish().
|
6864
7104
|
**
|
6865
|
-
** [[
|
7105
|
+
** [[sqlite3_backup_remaining()]] [[sqlite3_backup_pagecount()]]
|
6866
7106
|
** <b>sqlite3_backup_remaining() and sqlite3_backup_pagecount()</b>
|
6867
7107
|
**
|
6868
|
-
** ^
|
6869
|
-
**
|
6870
|
-
**
|
6871
|
-
**
|
6872
|
-
**
|
6873
|
-
**
|
6874
|
-
**
|
6875
|
-
**
|
6876
|
-
**
|
6877
|
-
**
|
6878
|
-
**
|
7108
|
+
** ^The sqlite3_backup_remaining() routine returns the number of pages still
|
7109
|
+
** to be backed up at the conclusion of the most recent sqlite3_backup_step().
|
7110
|
+
** ^The sqlite3_backup_pagecount() routine returns the total number of pages
|
7111
|
+
** in the source database at the conclusion of the most recent
|
7112
|
+
** sqlite3_backup_step().
|
7113
|
+
** ^(The values returned by these functions are only updated by
|
7114
|
+
** sqlite3_backup_step(). If the source database is modified in a way that
|
7115
|
+
** changes the size of the source database or the number of pages remaining,
|
7116
|
+
** those changes are not reflected in the output of sqlite3_backup_pagecount()
|
7117
|
+
** and sqlite3_backup_remaining() until after the next
|
7118
|
+
** sqlite3_backup_step().)^
|
6879
7119
|
**
|
6880
7120
|
** <b>Concurrent Usage of Database Handles</b>
|
6881
7121
|
**
|
@@ -6908,19 +7148,20 @@ typedef struct sqlite3_backup sqlite3_backup;
|
|
6908
7148
|
** same time as another thread is invoking sqlite3_backup_step() it is
|
6909
7149
|
** possible that they return invalid values.
|
6910
7150
|
*/
|
6911
|
-
SQLITE_API sqlite3_backup *sqlite3_backup_init(
|
7151
|
+
SQLITE_API sqlite3_backup *SQLITE_STDCALL sqlite3_backup_init(
|
6912
7152
|
sqlite3 *pDest, /* Destination database handle */
|
6913
7153
|
const char *zDestName, /* Destination database name */
|
6914
7154
|
sqlite3 *pSource, /* Source database handle */
|
6915
7155
|
const char *zSourceName /* Source database name */
|
6916
7156
|
);
|
6917
|
-
SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage);
|
6918
|
-
SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p);
|
6919
|
-
SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p);
|
6920
|
-
SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);
|
7157
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_backup_step(sqlite3_backup *p, int nPage);
|
7158
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_backup_finish(sqlite3_backup *p);
|
7159
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_backup_remaining(sqlite3_backup *p);
|
7160
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_backup_pagecount(sqlite3_backup *p);
|
6921
7161
|
|
6922
7162
|
/*
|
6923
7163
|
** CAPI3REF: Unlock Notification
|
7164
|
+
** METHOD: sqlite3
|
6924
7165
|
**
|
6925
7166
|
** ^When running in shared-cache mode, a database operation may fail with
|
6926
7167
|
** an [SQLITE_LOCKED] error if the required locks on the shared-cache or
|
@@ -7033,7 +7274,7 @@ SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);
|
|
7033
7274
|
** the special "DROP TABLE/INDEX" case, the extended error code is just
|
7034
7275
|
** SQLITE_LOCKED.)^
|
7035
7276
|
*/
|
7036
|
-
SQLITE_API int sqlite3_unlock_notify(
|
7277
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_unlock_notify(
|
7037
7278
|
sqlite3 *pBlocked, /* Waiting connection */
|
7038
7279
|
void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */
|
7039
7280
|
void *pNotifyArg /* Argument to pass to xNotify */
|
@@ -7048,8 +7289,8 @@ SQLITE_API int sqlite3_unlock_notify(
|
|
7048
7289
|
** strings in a case-independent fashion, using the same definition of "case
|
7049
7290
|
** independence" that SQLite uses internally when comparing identifiers.
|
7050
7291
|
*/
|
7051
|
-
SQLITE_API int sqlite3_stricmp(const char *, const char *);
|
7052
|
-
SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);
|
7292
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_stricmp(const char *, const char *);
|
7293
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_strnicmp(const char *, const char *, int);
|
7053
7294
|
|
7054
7295
|
/*
|
7055
7296
|
** CAPI3REF: String Globbing
|
@@ -7064,7 +7305,7 @@ SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);
|
|
7064
7305
|
** Note that this routine returns zero on a match and non-zero if the strings
|
7065
7306
|
** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].
|
7066
7307
|
*/
|
7067
|
-
SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr);
|
7308
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_strglob(const char *zGlob, const char *zStr);
|
7068
7309
|
|
7069
7310
|
/*
|
7070
7311
|
** CAPI3REF: Error Logging Interface
|
@@ -7087,18 +7328,17 @@ SQLITE_API int sqlite3_strglob(const char *zGlob, const char *zStr);
|
|
7087
7328
|
** a few hundred characters, it will be truncated to the length of the
|
7088
7329
|
** buffer.
|
7089
7330
|
*/
|
7090
|
-
SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
|
7331
|
+
SQLITE_API void SQLITE_CDECL sqlite3_log(int iErrCode, const char *zFormat, ...);
|
7091
7332
|
|
7092
7333
|
/*
|
7093
7334
|
** CAPI3REF: Write-Ahead Log Commit Hook
|
7335
|
+
** METHOD: sqlite3
|
7094
7336
|
**
|
7095
7337
|
** ^The [sqlite3_wal_hook()] function is used to register a callback that
|
7096
|
-
**
|
7097
|
-
** [write-ahead log] (i.e. whenever a transaction is committed in
|
7098
|
-
** [journal_mode | journal_mode=WAL mode]).
|
7338
|
+
** is invoked each time data is committed to a database in wal mode.
|
7099
7339
|
**
|
7100
|
-
** ^The callback is invoked by SQLite after the commit has taken place and
|
7101
|
-
** the associated write-lock on the database released
|
7340
|
+
** ^(The callback is invoked by SQLite after the commit has taken place and
|
7341
|
+
** the associated write-lock on the database released)^, so the implementation
|
7102
7342
|
** may read, write or [checkpoint] the database as required.
|
7103
7343
|
**
|
7104
7344
|
** ^The first parameter passed to the callback function when it is invoked
|
@@ -7124,7 +7364,7 @@ SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
|
|
7124
7364
|
** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
|
7125
7365
|
** those overwrite any prior [sqlite3_wal_hook()] settings.
|
7126
7366
|
*/
|
7127
|
-
SQLITE_API void *sqlite3_wal_hook(
|
7367
|
+
SQLITE_API void *SQLITE_STDCALL sqlite3_wal_hook(
|
7128
7368
|
sqlite3*,
|
7129
7369
|
int(*)(void *,sqlite3*,const char*,int),
|
7130
7370
|
void*
|
@@ -7132,6 +7372,7 @@ SQLITE_API void *sqlite3_wal_hook(
|
|
7132
7372
|
|
7133
7373
|
/*
|
7134
7374
|
** CAPI3REF: Configure an auto-checkpoint
|
7375
|
+
** METHOD: sqlite3
|
7135
7376
|
**
|
7136
7377
|
** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around
|
7137
7378
|
** [sqlite3_wal_hook()] that causes any database on [database connection] D
|
@@ -7158,104 +7399,123 @@ SQLITE_API void *sqlite3_wal_hook(
|
|
7158
7399
|
** is only necessary if the default setting is found to be suboptimal
|
7159
7400
|
** for a particular application.
|
7160
7401
|
*/
|
7161
|
-
SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
|
7402
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
|
7162
7403
|
|
7163
7404
|
/*
|
7164
7405
|
** CAPI3REF: Checkpoint a database
|
7406
|
+
** METHOD: sqlite3
|
7165
7407
|
**
|
7166
|
-
** ^The
|
7167
|
-
**
|
7168
|
-
** empty string, then a checkpoint is run on all databases of
|
7169
|
-
** connection D. ^If the database connection D is not in
|
7170
|
-
** [WAL | write-ahead log mode] then this interface is a harmless no-op.
|
7171
|
-
** ^The [sqlite3_wal_checkpoint(D,X)] interface initiates a
|
7172
|
-
** [sqlite3_wal_checkpoint_v2|PASSIVE] checkpoint.
|
7173
|
-
** Use the [sqlite3_wal_checkpoint_v2()] interface to get a FULL
|
7174
|
-
** or RESET checkpoint.
|
7408
|
+
** ^(The sqlite3_wal_checkpoint(D,X) is equivalent to
|
7409
|
+
** [sqlite3_wal_checkpoint_v2](D,X,[SQLITE_CHECKPOINT_PASSIVE],0,0).)^
|
7175
7410
|
**
|
7176
|
-
**
|
7177
|
-
**
|
7178
|
-
**
|
7179
|
-
**
|
7411
|
+
** In brief, sqlite3_wal_checkpoint(D,X) causes the content in the
|
7412
|
+
** [write-ahead log] for database X on [database connection] D to be
|
7413
|
+
** transferred into the database file and for the write-ahead log to
|
7414
|
+
** be reset. See the [checkpointing] documentation for addition
|
7415
|
+
** information.
|
7180
7416
|
**
|
7181
|
-
**
|
7417
|
+
** This interface used to be the only way to cause a checkpoint to
|
7418
|
+
** occur. But then the newer and more powerful [sqlite3_wal_checkpoint_v2()]
|
7419
|
+
** interface was added. This interface is retained for backwards
|
7420
|
+
** compatibility and as a convenience for applications that need to manually
|
7421
|
+
** start a callback but which do not need the full power (and corresponding
|
7422
|
+
** complication) of [sqlite3_wal_checkpoint_v2()].
|
7182
7423
|
*/
|
7183
|
-
SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
|
7424
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
|
7184
7425
|
|
7185
7426
|
/*
|
7186
7427
|
** CAPI3REF: Checkpoint a database
|
7428
|
+
** METHOD: sqlite3
|
7187
7429
|
**
|
7188
|
-
**
|
7189
|
-
**
|
7190
|
-
**
|
7430
|
+
** ^(The sqlite3_wal_checkpoint_v2(D,X,M,L,C) interface runs a checkpoint
|
7431
|
+
** operation on database X of [database connection] D in mode M. Status
|
7432
|
+
** information is written back into integers pointed to by L and C.)^
|
7433
|
+
** ^(The M parameter must be a valid [checkpoint mode]:)^
|
7191
7434
|
**
|
7192
7435
|
** <dl>
|
7193
7436
|
** <dt>SQLITE_CHECKPOINT_PASSIVE<dd>
|
7194
|
-
** Checkpoint as many frames as possible without waiting for any database
|
7195
|
-
** readers or writers to finish
|
7196
|
-
**
|
7197
|
-
**
|
7198
|
-
**
|
7437
|
+
** ^Checkpoint as many frames as possible without waiting for any database
|
7438
|
+
** readers or writers to finish, then sync the database file if all frames
|
7439
|
+
** in the log were checkpointed. ^The [busy-handler callback]
|
7440
|
+
** is never invoked in the SQLITE_CHECKPOINT_PASSIVE mode.
|
7441
|
+
** ^On the other hand, passive mode might leave the checkpoint unfinished
|
7442
|
+
** if there are concurrent readers or writers.
|
7199
7443
|
**
|
7200
7444
|
** <dt>SQLITE_CHECKPOINT_FULL<dd>
|
7201
|
-
** This mode blocks (it invokes the
|
7445
|
+
** ^This mode blocks (it invokes the
|
7202
7446
|
** [sqlite3_busy_handler|busy-handler callback]) until there is no
|
7203
7447
|
** database writer and all readers are reading from the most recent database
|
7204
|
-
** snapshot. It then checkpoints all frames in the log file and syncs the
|
7205
|
-
** database file. This
|
7206
|
-
** but
|
7448
|
+
** snapshot. ^It then checkpoints all frames in the log file and syncs the
|
7449
|
+
** database file. ^This mode blocks new database writers while it is pending,
|
7450
|
+
** but new database readers are allowed to continue unimpeded.
|
7207
7451
|
**
|
7208
7452
|
** <dt>SQLITE_CHECKPOINT_RESTART<dd>
|
7209
|
-
** This mode works the same way as SQLITE_CHECKPOINT_FULL
|
7210
|
-
** checkpointing the log file it blocks (calls the
|
7211
|
-
** [
|
7212
|
-
** until all readers are reading from the database file only. This ensures
|
7213
|
-
** that the next
|
7214
|
-
**
|
7215
|
-
** but not
|
7453
|
+
** ^This mode works the same way as SQLITE_CHECKPOINT_FULL with the addition
|
7454
|
+
** that after checkpointing the log file it blocks (calls the
|
7455
|
+
** [busy-handler callback])
|
7456
|
+
** until all readers are reading from the database file only. ^This ensures
|
7457
|
+
** that the next writer will restart the log file from the beginning.
|
7458
|
+
** ^Like SQLITE_CHECKPOINT_FULL, this mode blocks new
|
7459
|
+
** database writer attempts while it is pending, but does not impede readers.
|
7460
|
+
**
|
7461
|
+
** <dt>SQLITE_CHECKPOINT_TRUNCATE<dd>
|
7462
|
+
** ^This mode works the same way as SQLITE_CHECKPOINT_RESTART with the
|
7463
|
+
** addition that it also truncates the log file to zero bytes just prior
|
7464
|
+
** to a successful return.
|
7216
7465
|
** </dl>
|
7217
7466
|
**
|
7218
|
-
** If pnLog is not NULL, then *pnLog is set to the total number of frames in
|
7219
|
-
** the log file
|
7220
|
-
** the
|
7221
|
-
**
|
7222
|
-
**
|
7223
|
-
**
|
7224
|
-
**
|
7225
|
-
**
|
7226
|
-
**
|
7467
|
+
** ^If pnLog is not NULL, then *pnLog is set to the total number of frames in
|
7468
|
+
** the log file or to -1 if the checkpoint could not run because
|
7469
|
+
** of an error or because the database is not in [WAL mode]. ^If pnCkpt is not
|
7470
|
+
** NULL,then *pnCkpt is set to the total number of checkpointed frames in the
|
7471
|
+
** log file (including any that were already checkpointed before the function
|
7472
|
+
** was called) or to -1 if the checkpoint could not run due to an error or
|
7473
|
+
** because the database is not in WAL mode. ^Note that upon successful
|
7474
|
+
** completion of an SQLITE_CHECKPOINT_TRUNCATE, the log file will have been
|
7475
|
+
** truncated to zero bytes and so both *pnLog and *pnCkpt will be set to zero.
|
7476
|
+
**
|
7477
|
+
** ^All calls obtain an exclusive "checkpoint" lock on the database file. ^If
|
7227
7478
|
** any other process is running a checkpoint operation at the same time, the
|
7228
|
-
** lock cannot be obtained and SQLITE_BUSY is returned. Even if there is a
|
7479
|
+
** lock cannot be obtained and SQLITE_BUSY is returned. ^Even if there is a
|
7229
7480
|
** busy-handler configured, it will not be invoked in this case.
|
7230
7481
|
**
|
7231
|
-
** The SQLITE_CHECKPOINT_FULL and
|
7232
|
-
** "writer" lock on the database file. If the writer lock cannot be
|
7233
|
-
** immediately, and a busy-handler is configured, it is invoked and
|
7234
|
-
** lock retried until either the busy-handler returns 0 or the lock
|
7235
|
-
** successfully obtained. The busy-handler is also invoked while waiting for
|
7236
|
-
** database readers as described above. If the busy-handler returns 0 before
|
7482
|
+
** ^The SQLITE_CHECKPOINT_FULL, RESTART and TRUNCATE modes also obtain the
|
7483
|
+
** exclusive "writer" lock on the database file. ^If the writer lock cannot be
|
7484
|
+
** obtained immediately, and a busy-handler is configured, it is invoked and
|
7485
|
+
** the writer lock retried until either the busy-handler returns 0 or the lock
|
7486
|
+
** is successfully obtained. ^The busy-handler is also invoked while waiting for
|
7487
|
+
** database readers as described above. ^If the busy-handler returns 0 before
|
7237
7488
|
** the writer lock is obtained or while waiting for database readers, the
|
7238
7489
|
** checkpoint operation proceeds from that point in the same way as
|
7239
7490
|
** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible
|
7240
|
-
** without blocking any further. SQLITE_BUSY is returned in this case.
|
7491
|
+
** without blocking any further. ^SQLITE_BUSY is returned in this case.
|
7241
7492
|
**
|
7242
|
-
** If parameter zDb is NULL or points to a zero length string, then the
|
7243
|
-
** specified operation is attempted on all WAL databases
|
7244
|
-
**
|
7493
|
+
** ^If parameter zDb is NULL or points to a zero length string, then the
|
7494
|
+
** specified operation is attempted on all WAL databases [attached] to
|
7495
|
+
** [database connection] db. In this case the
|
7496
|
+
** values written to output parameters *pnLog and *pnCkpt are undefined. ^If
|
7245
7497
|
** an SQLITE_BUSY error is encountered when processing one or more of the
|
7246
7498
|
** attached WAL databases, the operation is still attempted on any remaining
|
7247
|
-
** attached databases and SQLITE_BUSY is returned
|
7499
|
+
** attached databases and SQLITE_BUSY is returned at the end. ^If any other
|
7248
7500
|
** error occurs while processing an attached database, processing is abandoned
|
7249
|
-
** and the error code returned to the caller immediately. If no error
|
7501
|
+
** and the error code is returned to the caller immediately. ^If no error
|
7250
7502
|
** (SQLITE_BUSY or otherwise) is encountered while processing the attached
|
7251
7503
|
** databases, SQLITE_OK is returned.
|
7252
7504
|
**
|
7253
|
-
** If database zDb is the name of an attached database that is not in WAL
|
7254
|
-
** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If
|
7505
|
+
** ^If database zDb is the name of an attached database that is not in WAL
|
7506
|
+
** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. ^If
|
7255
7507
|
** zDb is not NULL (or a zero length string) and is not the name of any
|
7256
7508
|
** attached database, SQLITE_ERROR is returned to the caller.
|
7509
|
+
**
|
7510
|
+
** ^Unless it returns SQLITE_MISUSE,
|
7511
|
+
** the sqlite3_wal_checkpoint_v2() interface
|
7512
|
+
** sets the error information that is queried by
|
7513
|
+
** [sqlite3_errcode()] and [sqlite3_errmsg()].
|
7514
|
+
**
|
7515
|
+
** ^The [PRAGMA wal_checkpoint] command can be used to invoke this interface
|
7516
|
+
** from SQL.
|
7257
7517
|
*/
|
7258
|
-
SQLITE_API int sqlite3_wal_checkpoint_v2(
|
7518
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_wal_checkpoint_v2(
|
7259
7519
|
sqlite3 *db, /* Database handle */
|
7260
7520
|
const char *zDb, /* Name of attached database (or NULL) */
|
7261
7521
|
int eMode, /* SQLITE_CHECKPOINT_* value */
|
@@ -7264,16 +7524,18 @@ SQLITE_API int sqlite3_wal_checkpoint_v2(
|
|
7264
7524
|
);
|
7265
7525
|
|
7266
7526
|
/*
|
7267
|
-
** CAPI3REF: Checkpoint
|
7527
|
+
** CAPI3REF: Checkpoint Mode Values
|
7528
|
+
** KEYWORDS: {checkpoint mode}
|
7268
7529
|
**
|
7269
|
-
** These constants
|
7270
|
-
**
|
7271
|
-
** documentation for
|
7272
|
-
** each of these
|
7530
|
+
** These constants define all valid values for the "checkpoint mode" passed
|
7531
|
+
** as the third parameter to the [sqlite3_wal_checkpoint_v2()] interface.
|
7532
|
+
** See the [sqlite3_wal_checkpoint_v2()] documentation for details on the
|
7533
|
+
** meaning of each of these checkpoint modes.
|
7273
7534
|
*/
|
7274
|
-
#define SQLITE_CHECKPOINT_PASSIVE
|
7275
|
-
#define SQLITE_CHECKPOINT_FULL
|
7276
|
-
#define SQLITE_CHECKPOINT_RESTART
|
7535
|
+
#define SQLITE_CHECKPOINT_PASSIVE 0 /* Do as much as possible w/o blocking */
|
7536
|
+
#define SQLITE_CHECKPOINT_FULL 1 /* Wait for writers, then checkpoint */
|
7537
|
+
#define SQLITE_CHECKPOINT_RESTART 2 /* Like FULL but wait for for readers */
|
7538
|
+
#define SQLITE_CHECKPOINT_TRUNCATE 3 /* Like RESTART but also truncate WAL */
|
7277
7539
|
|
7278
7540
|
/*
|
7279
7541
|
** CAPI3REF: Virtual Table Interface Configuration
|
@@ -7289,7 +7551,7 @@ SQLITE_API int sqlite3_wal_checkpoint_v2(
|
|
7289
7551
|
** this function. (See [SQLITE_VTAB_CONSTRAINT_SUPPORT].) Further options
|
7290
7552
|
** may be added in the future.
|
7291
7553
|
*/
|
7292
|
-
SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);
|
7554
|
+
SQLITE_API int SQLITE_CDECL sqlite3_vtab_config(sqlite3*, int op, ...);
|
7293
7555
|
|
7294
7556
|
/*
|
7295
7557
|
** CAPI3REF: Virtual Table Configuration Options
|
@@ -7342,7 +7604,7 @@ SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);
|
|
7342
7604
|
** of the SQL statement that triggered the call to the [xUpdate] method of the
|
7343
7605
|
** [virtual table].
|
7344
7606
|
*/
|
7345
|
-
SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
|
7607
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_vtab_on_conflict(sqlite3 *);
|
7346
7608
|
|
7347
7609
|
/*
|
7348
7610
|
** CAPI3REF: Conflict resolution modes
|
@@ -7362,6 +7624,108 @@ SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
|
|
7362
7624
|
/* #define SQLITE_ABORT 4 // Also an error code */
|
7363
7625
|
#define SQLITE_REPLACE 5
|
7364
7626
|
|
7627
|
+
/*
|
7628
|
+
** CAPI3REF: Prepared Statement Scan Status Opcodes
|
7629
|
+
** KEYWORDS: {scanstatus options}
|
7630
|
+
**
|
7631
|
+
** The following constants can be used for the T parameter to the
|
7632
|
+
** [sqlite3_stmt_scanstatus(S,X,T,V)] interface. Each constant designates a
|
7633
|
+
** different metric for sqlite3_stmt_scanstatus() to return.
|
7634
|
+
**
|
7635
|
+
** When the value returned to V is a string, space to hold that string is
|
7636
|
+
** managed by the prepared statement S and will be automatically freed when
|
7637
|
+
** S is finalized.
|
7638
|
+
**
|
7639
|
+
** <dl>
|
7640
|
+
** [[SQLITE_SCANSTAT_NLOOP]] <dt>SQLITE_SCANSTAT_NLOOP</dt>
|
7641
|
+
** <dd>^The [sqlite3_int64] variable pointed to by the T parameter will be
|
7642
|
+
** set to the total number of times that the X-th loop has run.</dd>
|
7643
|
+
**
|
7644
|
+
** [[SQLITE_SCANSTAT_NVISIT]] <dt>SQLITE_SCANSTAT_NVISIT</dt>
|
7645
|
+
** <dd>^The [sqlite3_int64] variable pointed to by the T parameter will be set
|
7646
|
+
** to the total number of rows examined by all iterations of the X-th loop.</dd>
|
7647
|
+
**
|
7648
|
+
** [[SQLITE_SCANSTAT_EST]] <dt>SQLITE_SCANSTAT_EST</dt>
|
7649
|
+
** <dd>^The "double" variable pointed to by the T parameter will be set to the
|
7650
|
+
** query planner's estimate for the average number of rows output from each
|
7651
|
+
** iteration of the X-th loop. If the query planner's estimates was accurate,
|
7652
|
+
** then this value will approximate the quotient NVISIT/NLOOP and the
|
7653
|
+
** product of this value for all prior loops with the same SELECTID will
|
7654
|
+
** be the NLOOP value for the current loop.
|
7655
|
+
**
|
7656
|
+
** [[SQLITE_SCANSTAT_NAME]] <dt>SQLITE_SCANSTAT_NAME</dt>
|
7657
|
+
** <dd>^The "const char *" variable pointed to by the T parameter will be set
|
7658
|
+
** to a zero-terminated UTF-8 string containing the name of the index or table
|
7659
|
+
** used for the X-th loop.
|
7660
|
+
**
|
7661
|
+
** [[SQLITE_SCANSTAT_EXPLAIN]] <dt>SQLITE_SCANSTAT_EXPLAIN</dt>
|
7662
|
+
** <dd>^The "const char *" variable pointed to by the T parameter will be set
|
7663
|
+
** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN]
|
7664
|
+
** description for the X-th loop.
|
7665
|
+
**
|
7666
|
+
** [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECT</dt>
|
7667
|
+
** <dd>^The "int" variable pointed to by the T parameter will be set to the
|
7668
|
+
** "select-id" for the X-th loop. The select-id identifies which query or
|
7669
|
+
** subquery the loop is part of. The main query has a select-id of zero.
|
7670
|
+
** The select-id is the same value as is output in the first column
|
7671
|
+
** of an [EXPLAIN QUERY PLAN] query.
|
7672
|
+
** </dl>
|
7673
|
+
*/
|
7674
|
+
#define SQLITE_SCANSTAT_NLOOP 0
|
7675
|
+
#define SQLITE_SCANSTAT_NVISIT 1
|
7676
|
+
#define SQLITE_SCANSTAT_EST 2
|
7677
|
+
#define SQLITE_SCANSTAT_NAME 3
|
7678
|
+
#define SQLITE_SCANSTAT_EXPLAIN 4
|
7679
|
+
#define SQLITE_SCANSTAT_SELECTID 5
|
7680
|
+
|
7681
|
+
/*
|
7682
|
+
** CAPI3REF: Prepared Statement Scan Status
|
7683
|
+
** METHOD: sqlite3_stmt
|
7684
|
+
**
|
7685
|
+
** This interface returns information about the predicted and measured
|
7686
|
+
** performance for pStmt. Advanced applications can use this
|
7687
|
+
** interface to compare the predicted and the measured performance and
|
7688
|
+
** issue warnings and/or rerun [ANALYZE] if discrepancies are found.
|
7689
|
+
**
|
7690
|
+
** Since this interface is expected to be rarely used, it is only
|
7691
|
+
** available if SQLite is compiled using the [SQLITE_ENABLE_STMT_SCANSTATUS]
|
7692
|
+
** compile-time option.
|
7693
|
+
**
|
7694
|
+
** The "iScanStatusOp" parameter determines which status information to return.
|
7695
|
+
** The "iScanStatusOp" must be one of the [scanstatus options] or the behavior
|
7696
|
+
** of this interface is undefined.
|
7697
|
+
** ^The requested measurement is written into a variable pointed to by
|
7698
|
+
** the "pOut" parameter.
|
7699
|
+
** Parameter "idx" identifies the specific loop to retrieve statistics for.
|
7700
|
+
** Loops are numbered starting from zero. ^If idx is out of range - less than
|
7701
|
+
** zero or greater than or equal to the total number of loops used to implement
|
7702
|
+
** the statement - a non-zero value is returned and the variable that pOut
|
7703
|
+
** points to is unchanged.
|
7704
|
+
**
|
7705
|
+
** ^Statistics might not be available for all loops in all statements. ^In cases
|
7706
|
+
** where there exist loops with no available statistics, this function behaves
|
7707
|
+
** as if the loop did not exist - it returns non-zero and leave the variable
|
7708
|
+
** that pOut points to unchanged.
|
7709
|
+
**
|
7710
|
+
** See also: [sqlite3_stmt_scanstatus_reset()]
|
7711
|
+
*/
|
7712
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_stmt_scanstatus(
|
7713
|
+
sqlite3_stmt *pStmt, /* Prepared statement for which info desired */
|
7714
|
+
int idx, /* Index of loop to report on */
|
7715
|
+
int iScanStatusOp, /* Information desired. SQLITE_SCANSTAT_* */
|
7716
|
+
void *pOut /* Result written here */
|
7717
|
+
);
|
7718
|
+
|
7719
|
+
/*
|
7720
|
+
** CAPI3REF: Zero Scan-Status Counters
|
7721
|
+
** METHOD: sqlite3_stmt
|
7722
|
+
**
|
7723
|
+
** ^Zero all [sqlite3_stmt_scanstatus()] related event counters.
|
7724
|
+
**
|
7725
|
+
** This API is only available if the library is built with pre-processor
|
7726
|
+
** symbol [SQLITE_ENABLE_STMT_SCANSTATUS] defined.
|
7727
|
+
*/
|
7728
|
+
SQLITE_API void SQLITE_STDCALL sqlite3_stmt_scanstatus_reset(sqlite3_stmt*);
|
7365
7729
|
|
7366
7730
|
|
7367
7731
|
/*
|
@@ -7416,7 +7780,7 @@ typedef struct sqlite3_rtree_query_info sqlite3_rtree_query_info;
|
|
7416
7780
|
**
|
7417
7781
|
** SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zGeom(... params ...)
|
7418
7782
|
*/
|
7419
|
-
SQLITE_API int sqlite3_rtree_geometry_callback(
|
7783
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_rtree_geometry_callback(
|
7420
7784
|
sqlite3 *db,
|
7421
7785
|
const char *zGeom,
|
7422
7786
|
int (*xGeom)(sqlite3_rtree_geometry*, int, sqlite3_rtree_dbl*,int*),
|
@@ -7442,7 +7806,7 @@ struct sqlite3_rtree_geometry {
|
|
7442
7806
|
**
|
7443
7807
|
** SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zQueryFunc(... params ...)
|
7444
7808
|
*/
|
7445
|
-
SQLITE_API int sqlite3_rtree_query_callback(
|
7809
|
+
SQLITE_API int SQLITE_STDCALL sqlite3_rtree_query_callback(
|
7446
7810
|
sqlite3 *db,
|
7447
7811
|
const char *zQueryFunc,
|
7448
7812
|
int (*xQueryFunc)(sqlite3_rtree_query_info*),
|
@@ -7476,6 +7840,8 @@ struct sqlite3_rtree_query_info {
|
|
7476
7840
|
int eParentWithin; /* Visibility of parent node */
|
7477
7841
|
int eWithin; /* OUT: Visiblity */
|
7478
7842
|
sqlite3_rtree_dbl rScore; /* OUT: Write the score here */
|
7843
|
+
/* The following fields are only available in 3.8.11 and later */
|
7844
|
+
sqlite3_value **apSqlParam; /* Original SQL values of parameters */
|
7479
7845
|
};
|
7480
7846
|
|
7481
7847
|
/*
|