Many hyperlinks are disabled.
Use anonymous login
to enable hyperlinks.
Overview
Comment: | Begin adding requirements numbers to the C/C++ interface documentation. (CVS 4593) |
---|---|
Downloads: | Tarball | ZIP archive |
Timelines: | family | ancestors | descendants | both | trunk |
Files: | files | file ages | folders |
SHA1: |
ae1936aadf00bec91750d41be7507cf1 |
User & Date: | drh 2007-12-05 18:05:16.000 |
Context
2007-12-06
| ||
02:42 | Continuing work on the C/C++ interface requirements that appears as comments in sqlite.h.in. (CVS 4594) (check-in: 2130e71251 user: drh tags: trunk) | |
2007-12-05
| ||
18:05 | Begin adding requirements numbers to the C/C++ interface documentation. (CVS 4593) (check-in: ae1936aadf user: drh tags: trunk) | |
01:38 | Add the ability to change the autovacuum status of an existing database by setting the auto_vacuum pragma then running the VACUUM command. (CVS 4592) (check-in: bdfc19e838 user: drh tags: trunk) | |
Changes
Changes to src/sqlite.h.in.
︙ | ︙ | |||
26 27 28 29 30 31 32 | ** on how SQLite interfaces are suppose to operate. ** ** The name of this file under configuration management is "sqlite.h.in". ** The makefile makes some minor changes to this file (such as inserting ** the version number) and changes its name to "sqlite3.h" as ** part of the build process. ** | < < < < < < < < < < < < < | | 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | ** on how SQLite interfaces are suppose to operate. ** ** The name of this file under configuration management is "sqlite.h.in". ** The makefile makes some minor changes to this file (such as inserting ** the version number) and changes its name to "sqlite3.h" as ** part of the build process. ** ** @(#) $Id: sqlite.h.in,v 1.275 2007/12/05 18:05:16 drh Exp $ */ #ifndef _SQLITE3_H_ #define _SQLITE3_H_ #include <stdarg.h> /* Needed for the definition of va_list */ /* ** Make sure we can call this stuff from C++. |
︙ | ︙ | |||
72 73 74 75 76 77 78 | # undef SQLITE_VERSION #endif #ifdef SQLITE_VERSION_NUMBER # undef SQLITE_VERSION_NUMBER #endif /* | | > | | > | | | | | < < < | | > | < | | | > > | | | < | | | | < | | | | | > | | | | | | | | | | | | | < < < | | | | 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 | # undef SQLITE_VERSION #endif #ifdef SQLITE_VERSION_NUMBER # undef SQLITE_VERSION_NUMBER #endif /* ** CAPI3REF: Compile-Time Library Version Numbers {F10010} ** ** {F10011} The version of the SQLite library is contained in the sqlite3.h ** header file in a #define named SQLITE_VERSION. {F10012} The SQLITE_VERSION ** macro resolves to a string constant. ** ** {F10013} The format of the version string is "X.Y.Z", where ** X is the major version number, Y is the minor version number and Z ** is the release number. The X.Y.Z might be followed by "alpha" or "beta". ** For example "3.1.1beta". {END} ** ** The X value is always 3 in SQLite. The X value only changes when ** backwards compatibility is broken and we intend to never break ** backwards compatibility. The Y value only changes when ** there are major feature enhancements that are forwards compatible ** but not backwards compatible. The Z value is incremented with ** each release but resets back to 0 when Y is incremented. ** ** {F10014} The SQLITE_VERSION_NUMBER is an integer with the value ** (X*1000000 + Y*1000 + Z). For example, for version "3.1.1beta", ** SQLITE_VERSION_NUMBER is set to 3001001. To detect if they are using ** version 3.1.1 or greater at compile time, programs may use the test ** (SQLITE_VERSION_NUMBER>=3001001). {END} ** ** See also: [sqlite3_libversion()] and [sqlite3_libversion_number()]. */ #define SQLITE_VERSION "--VERS--" #define SQLITE_VERSION_NUMBER --VERSION-NUMBER-- /* ** CAPI3REF: Run-Time Library Version Numbers {F10020} ** ** {F10021} These routines return values equivalent to the header constants ** [SQLITE_VERSION] and [SQLITE_VERSION_NUMBER]. {END} The values returned ** by this routines should only be different from the header values ** if the application is compiled using an sqlite3.h header from a ** different version of SQLite than library. Cautious programmers might ** include a check in their application to verify that ** sqlite3_libversion_number() always returns the value ** [SQLITE_VERSION_NUMBER]. ** ** {F10022} The sqlite3_version[] string constant contains the text of the ** [SQLITE_VERSION] string. {F10023} The sqlite3_libversion() function returns ** a poiner to the sqlite3_version[] string constant. {END} The function ** is provided for DLL users who can only access functions and not ** constants within the DLL. */ SQLITE_EXTERN const char sqlite3_version[]; const char *sqlite3_libversion(void); int sqlite3_libversion_number(void); /* ** CAPI3REF: Test To See If The Library Is Threadsafe {F10100} ** ** {F10101} This routine returns TRUE (nonzero) if SQLite was compiled with ** all of its mutexes enabled and is thus threadsafe. {F10102} It returns ** zero if the particular build is for single-threaded operation ** only. {END} ** ** {F10103} Really all this routine does is return true if SQLite was ** compiled with the -DSQLITE_THREADSAFE=1 option and false if ** compiled with -DSQLITE_THREADSAFE=0. {U10104} If SQLite uses an ** application-defined mutex subsystem, malloc subsystem, collating ** sequence, VFS, SQL function, progress callback, commit hook, ** extension, or other accessories and these add-ons are not ** threadsafe, then clearly the combination will not be threadsafe ** either. {END} Hence, this routine never reports that the library ** is guaranteed to be threadsafe, only when it is guaranteed not ** to be. */ int sqlite3_threadsafe(void); /* ** CAPI3REF: Database Connection Handle {F12000} ** ** Each open SQLite database is represented by pointer to an instance of the ** opaque structure named "sqlite3". It is useful to think of an sqlite3 ** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and ** [sqlite3_open_v2()] interfaces are its constructors ** and [sqlite3_close()] is its destructor. There are many other interfaces ** (such as [sqlite3_prepare_v2()], [sqlite3_create_function()], and ** [sqlite3_busy_timeout()] to name but three) that are methods on this ** object. */ typedef struct sqlite3 sqlite3; /* ** CAPI3REF: 64-Bit Integer Types {F10200} ** ** Because there is no cross-platform way to specify such types ** SQLite includes typedefs for 64-bit signed and unsigned integers. ** {F10201} The sqlite_int64 and sqlite3_int64 types specify a ** 64-bit signed integer. {F10202} The sqlite_uint64 and ** sqlite3_uint64 types specify a 64-bit unsigned integer. {END} ** ** The sqlite3_int64 and sqlite3_uint64 are the preferred type ** definitions. The sqlite_int64 and sqlite_uint64 types are ** supported for backwards compatibility only. */ #ifdef SQLITE_INT64_TYPE typedef SQLITE_INT64_TYPE sqlite_int64; typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; #elif defined(_MSC_VER) || defined(__BORLANDC__) typedef __int64 sqlite_int64; typedef unsigned __int64 sqlite_uint64; |
︙ | ︙ | |||
197 198 199 200 201 202 203 | ** substitute integer for floating-point */ #ifdef SQLITE_OMIT_FLOATING_POINT # define double sqlite3_int64 #endif /* | | | < < < < | | < | | < < | | | | | | | | | < < < < < < < | | | < > | > | | < < | < < | > | | | < < | | < | | | < | | < | | | > | < | > | | | | < | | | | < < < < < | | | | | | | | | 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 | ** substitute integer for floating-point */ #ifdef SQLITE_OMIT_FLOATING_POINT # define double sqlite3_int64 #endif /* ** CAPI3REF: Closing A Database Connection {F12010} ** ** {F12010} Call this function with a pointer to a structure that was ** previously returned from [sqlite3_open()], [sqlite3_open16()], or ** [sqlite3_open_v2()] and the corresponding database will by ** closed. {END} ** ** {F12011} All SQL statements prepared using [sqlite3_prepare_v2()] or ** [sqlite3_prepare16_v2()] must be destroyed using [sqlite3_finalize()] ** before this routine is called. Otherwise, SQLITE_BUSY is returned and the ** database connection remains open. {END} ** ** {U12012} Passing this routine a database connection that has already been ** closed results in undefined behavior. {U12013} If other interfaces that ** reference the same database connection are pending (either in the ** same thread or in different threads) when this routine is called, ** then the behavior is undefined and is almost certainly undesirable. */ int sqlite3_close(sqlite3 *); /* ** The type for a callback function. ** This is legacy and deprecated. It is included for historical ** compatibility and is not documented. */ typedef int (*sqlite3_callback)(void*,int,char**, char**); /* ** CAPI3REF: One-Step Query Execution Interface {F12100} ** ** {F12101} The sqlite3_exec() interface evaluates zero or more ** UTF-8 encoded, semicolon-separated SQL ** statements provided as its second argument. {F12102} The SQL ** statements are evaluated in the context of the database connection ** provided in the first argument. ** {F12103} SQL statements are prepared one by one using ** [sqlite3_prepare()] or the equivalent, evaluated ** using one or more calls to [sqlite3_step()], then destroyed ** using [sqlite3_finalize()]. {F12104} The return value of ** sqlite3_exec() is SQLITE_OK if all SQL statement run ** successfully. ** ** {F12105} If one or more of the SQL statements handed to ** sqlite3_exec() are queries, then ** the callback function specified by the 3rd parameter is ** invoked once for each row of the query result. {F12106} ** If the callback returns a non-zero value then the query ** is aborted, all subsequent SQL statements ** are skipped and the sqlite3_exec() function returns the [SQLITE_ABORT]. ** ** {F12107} The 4th parameter to sqlite3_exec() is an arbitrary pointer ** that is passed through to the callback function as its first parameter. ** ** {F12108} The 2nd parameter to the callback function is the number of ** columns in the query result. {F12109} The 3rd parameter to the callback ** is an array of pointers to strings holding the values for each column ** as extracted using [sqlite3_column_text()]. NULL values in the result ** set result in a NULL pointer. All other value are in their UTF-8 ** string representation. {F12110} ** The 4th parameter to the callback is an array of strings ** obtained using [sqlite3_column_name()] and holding ** the names of each column, also in UTF-8. ** ** {F12110} The callback function may be NULL, even for queries. A NULL ** callback is not an error. It just means that no callback ** will be invoked. ** ** {F12112} If an error occurs while parsing or evaluating the SQL ** then an appropriate error message is written into memory obtained ** from [sqlite3_malloc()] and *errmsg is made to point to that message ** assuming errmsg is not NULL. {U12113} The calling function ** is responsible for freeing the memory using [sqlite3_free()]. ** {F12114} If errmsg==NULL, then no error message is ever written. ** ** {F12115} The return value is is SQLITE_OK if there are no errors and ** some other [SQLITE_OK | return code] if there is an error. ** The particular return value depends on the type of error. {END} */ int sqlite3_exec( sqlite3*, /* An open database */ const char *sql, /* SQL to be evaluted */ int (*callback)(void*,int,char**,char**), /* Callback function */ void *, /* 1st argument to callback */ char **errmsg /* Error msg written here */ ); /* ** CAPI3REF: Result Codes {F10210} ** KEYWORDS: SQLITE_OK ** ** Many SQLite functions return an integer result code from the set shown ** above in order to indicates success or failure. ** ** {F10211} The result codes above are the only ones returned by SQLite in its ** default configuration. {F10212} However, the ** [sqlite3_extended_result_codes()] API can be used to set a database ** connectoin to return more detailed result codes. {END} ** ** See also: [SQLITE_IOERR_READ | extended result codes] ** */ #define SQLITE_OK 0 /* Successful result */ /* beginning-of-error-codes */ #define SQLITE_ERROR 1 /* SQL error or missing database */ |
︙ | ︙ | |||
357 358 359 360 361 362 363 | #define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ #define SQLITE_NOTADB 26 /* File opened that is not a database file */ #define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ #define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ /* end-of-error-codes */ /* | | | | < | > | | | | | > | | | | | < | | | | | | | | | | | | | | | | | | | | | < | < < | < | > | | | < < | 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 | #define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ #define SQLITE_NOTADB 26 /* File opened that is not a database file */ #define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ #define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ /* end-of-error-codes */ /* ** CAPI3REF: Extended Result Codes {F10220} ** ** In its default configuration, SQLite API routines return one of 26 integer ** [result codes]. However, experience has shown that ** many of these result codes are too course-grained. They do not provide as ** much information about problems as users might like. In an effort to ** address this, newer versions of SQLite (version 3.3.8 and later) include ** support for additional result codes that provide more detailed information ** about errors. {F10221} The extended result codes are enabled or disabled ** for each database connection using the [sqlite3_extended_result_codes()] ** API. {END} ** ** Some of the available extended result codes are listed above. ** We expect the number of extended result codes will be expand ** over time. {U10422} Software that uses extended result codes should expect ** to see new result codes in future releases of SQLite. {END} ** ** {F10223} The symbolic name for an extended result code always contains ** a related primary result code as a prefix. {F10224} Primary result ** codes contain a single "_" character. {F10225} Extended result codes ** contain two or more "_" characters. {F10226} The numeric value of an ** extended result code can be converted to its ** corresponding primary result code by masking off the lower 8 bytes. {END} ** ** The SQLITE_OK result code will never be extended. It will always ** be exactly zero. */ #define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) #define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) #define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) #define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) #define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) #define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) #define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) #define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) #define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) #define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) #define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) #define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) /* ** CAPI3REF: Flags For File Open Operations {F10230} ** ** {F10231} Some combination of the these bit values are used as the ** third argument to the [sqlite3_open_v2()] interface and ** as fourth argument to the xOpen method of the ** [sqlite3_vfs] object. */ #define SQLITE_OPEN_READONLY 0x00000001 #define SQLITE_OPEN_READWRITE 0x00000002 #define SQLITE_OPEN_CREATE 0x00000004 #define SQLITE_OPEN_DELETEONCLOSE 0x00000008 #define SQLITE_OPEN_EXCLUSIVE 0x00000010 #define SQLITE_OPEN_MAIN_DB 0x00000100 #define SQLITE_OPEN_TEMP_DB 0x00000200 #define SQLITE_OPEN_TRANSIENT_DB 0x00000400 #define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 #define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 #define SQLITE_OPEN_SUBJOURNAL 0x00002000 #define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* ** CAPI3REF: Device Characteristics {F10240} ** ** {F10241} The xDeviceCapabilities method of the [sqlite3_io_methods] ** object returns an integer which is a vector of the these ** bit values expressing I/O characteristics of the mass storage ** device that holds the file that the [sqlite3_io_methods] ** refers to. {END} ** ** {F10242} The SQLITE_IOCAP_ATOMIC property means that all writes of ** any size are atomic. {F10243} The SQLITE_IOCAP_ATOMICnnn values ** mean that writes of blocks that are nnn bytes in size and ** are aligned to an address which is an integer multiple of ** nnn are atomic. {F10244} The SQLITE_IOCAP_SAFE_APPEND value means ** that when data is appended to a file, the data is appended ** first then the size of the file is extended, never the other ** way around. {F10245} The SQLITE_IOCAP_SEQUENTIAL property means that ** information is written to disk in the same order as calls ** to xWrite(). */ #define SQLITE_IOCAP_ATOMIC 0x00000001 #define SQLITE_IOCAP_ATOMIC512 0x00000002 #define SQLITE_IOCAP_ATOMIC1K 0x00000004 #define SQLITE_IOCAP_ATOMIC2K 0x00000008 #define SQLITE_IOCAP_ATOMIC4K 0x00000010 #define SQLITE_IOCAP_ATOMIC8K 0x00000020 #define SQLITE_IOCAP_ATOMIC16K 0x00000040 #define SQLITE_IOCAP_ATOMIC32K 0x00000080 #define SQLITE_IOCAP_ATOMIC64K 0x00000100 #define SQLITE_IOCAP_SAFE_APPEND 0x00000200 #define SQLITE_IOCAP_SEQUENTIAL 0x00000400 /* ** CAPI3REF: File Locking Levels {F10250} ** ** {F10251} SQLite uses one of the following integer values as the second ** argument to calls it makes to the xLock() and xUnlock() methods ** of an [sqlite3_io_methods] object. {END} */ #define SQLITE_LOCK_NONE 0 #define SQLITE_LOCK_SHARED 1 #define SQLITE_LOCK_RESERVED 2 #define SQLITE_LOCK_PENDING 3 #define SQLITE_LOCK_EXCLUSIVE 4 /* ** CAPI3REF: Synchronization Type Flags {F10260} ** ** {F10261} When SQLite invokes the xSync() method of an ** [sqlite3_io_methods] object it uses a combination of the ** these integer values as the second argument. ** ** {F10262} When the SQLITE_SYNC_DATAONLY flag is used, it means that the ** sync operation only needs to flush data to mass storage. Inode ** information need not be flushed. {F10263} The SQLITE_SYNC_NORMAL means ** to use normal fsync() semantics. {F10264} The SQLITE_SYNC_FULL flag means ** to use Mac OS-X style fullsync instead of fsync(). */ #define SQLITE_SYNC_NORMAL 0x00002 #define SQLITE_SYNC_FULL 0x00003 #define SQLITE_SYNC_DATAONLY 0x00010 /* ** CAPI3REF: OS Interface Open File Handle {F11110} ** ** An [sqlite3_file] object represents an open file in the OS ** interface layer. Individual OS interface implementations will ** want to subclass this object by appending additional fields ** for their own use. The pMethods entry is a pointer to an ** [sqlite3_io_methods] object that defines methods for performing ** I/O operations on the open file. */ typedef struct sqlite3_file sqlite3_file; struct sqlite3_file { const struct sqlite3_io_methods *pMethods; /* Methods for an open file */ }; /* ** CAPI3REF: OS Interface File Virtual Methods Object {F11120} ** ** Every file opened by the [sqlite3_vfs] xOpen method contains a pointer to ** an instance of the this object. This object defines the ** methods used to perform various operations against the open file. ** ** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or ** [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). * The second choice is an ** OS-X style fullsync. The SQLITE_SYNC_DATA flag may be ORed in to ** indicate that only the data of the file and not its inode needs to be ** synced. ** ** The integer values to xLock() and xUnlock() are one of ** <ul> ** <li> [SQLITE_LOCK_NONE], ** <li> [SQLITE_LOCK_SHARED], ** <li> [SQLITE_LOCK_RESERVED], ** <li> [SQLITE_LOCK_PENDING], or |
︙ | ︙ | |||
596 597 598 599 600 601 602 | int (*xFileControl)(sqlite3_file*, int op, void *pArg); int (*xSectorSize)(sqlite3_file*); int (*xDeviceCharacteristics)(sqlite3_file*); /* Additional methods may be added in future releases */ }; /* | | | | | | | 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 | int (*xFileControl)(sqlite3_file*, int op, void *pArg); int (*xSectorSize)(sqlite3_file*); int (*xDeviceCharacteristics)(sqlite3_file*); /* Additional methods may be added in future releases */ }; /* ** CAPI3REF: Standard File Control Opcodes {F11310} ** ** These integer constants are opcodes for the xFileControl method ** of the [sqlite3_io_methods] object and to the [sqlite3_file_control()] ** interface. ** ** {F11311} The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This ** opcode cases the xFileControl method to write the current state of ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED], ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE]) ** into an integer that the pArg argument points to. {F11312} This capability ** is used during testing and only needs to be supported when SQLITE_TEST ** is defined. */ #define SQLITE_FCNTL_LOCKSTATE 1 /* ** CAPI3REF: Mutex Handle {F17110} ** ** The mutex module within SQLite defines [sqlite3_mutex] to be an ** abstract type for a mutex object. The SQLite core never looks ** at the internal representation of an [sqlite3_mutex]. It only ** deals with pointers to the [sqlite3_mutex] object. ** ** Mutexes are created using [sqlite3_mutex_alloc()]. */ typedef struct sqlite3_mutex sqlite3_mutex; /* ** CAPI3REF: OS Interface Object {F11140} ** ** An instance of this object defines the interface between the ** SQLite core and the underlying operating system. The "vfs" ** in the name of the object stands for "virtual file system". ** ** The iVersion field is initially 1 but may be larger for future ** versions of SQLite. Additional fields may be appended to this |
︙ | ︙ | |||
761 762 763 764 765 766 767 | int (*xSleep)(sqlite3_vfs*, int microseconds); int (*xCurrentTime)(sqlite3_vfs*, double*); /* New fields may be appended in figure versions. The iVersion ** value will increment whenever this happens. */ }; /* | | | | | | | > | | | | | < | | | | | | > | | | | | | | | | | | | | | | | > | | | | | | | | | | | | > | | | | | | | > | | | | | | | | | | | | | < < < < < < | > | < | > > > | > > > > > > > > > | | | | | | | | | | | | | > | | | | | | | | | | | | | | | | | | | | | | | | | | | 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 | int (*xSleep)(sqlite3_vfs*, int microseconds); int (*xCurrentTime)(sqlite3_vfs*, double*); /* New fields may be appended in figure versions. The iVersion ** value will increment whenever this happens. */ }; /* ** CAPI3REF: Flags for the xAccess VFS method {F11150} ** ** {F11151} These integer constants can be used as the third parameter to ** the xAccess method of an [sqlite3_vfs] object. {END} They determine ** the kind of what kind of permissions the xAccess method is ** looking for. {F11152} With SQLITE_ACCESS_EXISTS, the xAccess method ** simply checks to see if the file exists. {F11153} With ** SQLITE_ACCESS_READWRITE, the xAccess method checks to see ** if the file is both readable and writable. {F11154} With ** SQLITE_ACCESS_READ the xAccess method ** checks to see if the file is readable. */ #define SQLITE_ACCESS_EXISTS 0 #define SQLITE_ACCESS_READWRITE 1 #define SQLITE_ACCESS_READ 2 /* ** CAPI3REF: Enable Or Disable Extended Result Codes {F12200} ** ** {F12201} This routine enables or disables the ** [SQLITE_IOERR_READ | extended result codes] feature. {F12202} ** By default, SQLite API routines return one of only 26 integer ** [SQLITE_OK | result codes]. {F12203} When extended result codes ** are enabled by this routine, the repetoire of result codes can be ** much larger and can (hopefully) provide more detailed information ** about the cause of an error. ** ** {F12204} The second argument is a boolean value that turns extended result ** codes on and off. {F12205} Extended result codes are off by default for ** backwards compatibility with older versions of SQLite. */ int sqlite3_extended_result_codes(sqlite3*, int onoff); /* ** CAPI3REF: Last Insert Rowid {F12220} ** ** {F12221} Each entry in an SQLite table has a unique 64-bit signed ** integer key called the "rowid". {F12222} The rowid is always available ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those ** names are not also used by explicitly declared columns. {F12223} If ** the table has a column of type INTEGER PRIMARY KEY then that column ** is another an alias for the rowid. ** ** {F12224} This routine returns the rowid of the most recent ** successful INSERT into the database from the database connection ** shown in the first argument. {F12225} If no successful inserts ** have ever occurred on this database connection, zero is returned. ** ** {F12226} If an INSERT occurs within a trigger, then the rowid of the ** inserted row is returned by this routine as long as the trigger ** is running. {F12227} But once the trigger terminates, the value returned ** by this routine reverts to the last value inserted before the ** trigger fired. ** ** {F12228} An INSERT that fails due to a constraint violation is not a ** successful insert and does not change the value returned by this ** routine. {F12229} Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK, ** and INSERT OR ABORT make no changes to the return value of this ** routine when their insertion fails. {F12231} When INSERT OR REPLACE ** encounters a constraint violation, it does not fail. The ** INSERT continues to completion after deleting rows that caused ** the constraint problem so INSERT OR REPLACE will always change ** the return value of this interface. ** ** {UF12232} If another thread does a new insert on the same database connection ** while this routine is running and thus changes the last insert rowid, ** then the return value of this routine is undefined. */ sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*); /* ** CAPI3REF: Count The Number Of Rows Modified {F12240} ** ** {F12241} This function returns the number of database rows that were changed ** or inserted or deleted by the most recently completed SQL statement ** on the connection specified by the first parameter. {F12242} Only ** changes that are directly specified by the INSERT, UPDATE, or ** DELETE statement are counted. Auxiliary changes caused by ** triggers are not counted. {F12243} Use the [sqlite3_total_changes()] function ** to find the total number of changes including changes caused by triggers. ** ** {F12244} Within the body of a trigger, the sqlite3_changes() interface can be ** called to find the number of ** changes in the most recently completed INSERT, UPDATE, or DELETE ** statement within the body of the trigger. ** ** {F12245} All changes are counted, even if they were later undone by a ** ROLLBACK or ABORT. {F12246} Except, changes associated with creating and ** dropping tables are not counted. ** ** {F12247} If a callback invokes [sqlite3_exec()] or [sqlite3_step()] ** recursively, then the changes in the inner, recursive call are ** counted together with the changes in the outer call. ** ** {F12248} SQLite implements the command "DELETE FROM table" without ** a WHERE clause by dropping and recreating the table. (This is much ** faster than going through and deleting individual elements from the ** table.) Because of this optimization, the change count for ** "DELETE FROM table" will be zero regardless of the number of elements ** that were originally in the table. {F12251} To get an accurate count ** of the number of rows deleted, use ** "DELETE FROM table WHERE 1" instead. ** ** {UF12252} If another thread makes changes on the same database connection ** while this routine is running then the return value of this routine ** is undefined. */ int sqlite3_changes(sqlite3*); /* ** CAPI3REF: Total Number Of Rows Modified {F12260} *** ** {F12261} This function returns the number of database rows that have been ** modified by INSERT, UPDATE or DELETE statements since the database handle ** was opened. {F12262} The count includes UPDATE, INSERT and DELETE ** statements executed as part of trigger programs. {F12263} All changes ** are counted as soon as the statement that makes them is completed ** (when the statement handle is passed to [sqlite3_reset()] or ** [sqlite3_finalize()]). {END} ** ** See also the [sqlite3_change()] interface. ** ** SQLite implements the command "DELETE FROM table" without a WHERE clause ** by dropping and recreating the table. (This is much faster than going ** through and deleting individual elements form the table.) Because of ** this optimization, the change count for "DELETE FROM table" will be ** zero regardless of the number of elements that were originally in the ** table. To get an accurate count of the number of rows deleted, use ** "DELETE FROM table WHERE 1" instead. ** ** {U12264} If another thread makes changes on the same database connection ** while this routine is running then the return value of this routine ** is undefined. {END} */ int sqlite3_total_changes(sqlite3*); /* ** CAPI3REF: Interrupt A Long-Running Query {F12270} ** ** {F12271} This function causes any pending database operation to abort and ** return at its earliest opportunity. {END} This routine is typically ** called in response to a user action such as pressing "Cancel" ** or Ctrl-C where the user wants a long query operation to halt ** immediately. ** ** {F12272} It is safe to call this routine from a thread different from the ** thread that is currently running the database operation. {U12273} But it ** is not safe to call this routine with a database connection that ** is closed or might close before sqlite3_interrupt() returns. ** ** {F12274} The SQL operation that is interrupted will return ** [SQLITE_INTERRUPT]. {F12275} If an interrupted operation was an ** update that is inside an explicit transaction, then the entire ** transaction will be rolled back automatically. */ void sqlite3_interrupt(sqlite3*); /* ** CAPI3REF: Determine If An SQL Statement Is Complete {F10510} ** ** These routines are useful for command-line input to determine if the ** currently entered text forms one or more complete SQL statements or ** if additional input is needed before sending the statements into ** SQLite for parsing. These routines return true if the input string ** appears to be a complete SQL statement. A statement is judged to be ** complete if it ends with a semicolon and is not a fragment of a ** CREATE TRIGGER statement. These routines do not parse the SQL and ** will not detect syntactically incorrect SQL. ** ** {F10511} These functions return true if the given input string ** ends with a semicolon optionally followed by whitespace or ** comments. {F10512} For sqlite3_complete(), ** the parameter must be a zero-terminated UTF-8 string. {F10513} For ** sqlite3_complete16(), a zero-terminated machine byte order UTF-16 string ** is required. {F10514} These routines return false if the terminal ** semicolon is within a comment, a string literal or a quoted identifier ** (in other words if the final semicolon is not really a separate token ** but part of a larger token) or if the final semicolon is ** in between the BEGIN and END keywords of a CREATE TRIGGER statement. ** {END} */ int sqlite3_complete(const char *sql); int sqlite3_complete16(const void *sql); /* ** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors {F12310} ** ** {F12311} This routine identifies a callback function that might be ** invoked whenever an attempt is made to open a database table ** that another thread or process has locked. ** {F12312} If the busy callback is NULL, then [SQLITE_BUSY] ** (or sometimes [SQLITE_IOERR_BLOCKED]) ** is returned immediately upon encountering the lock. ** {F12313} If the busy callback is not NULL, then the ** callback will be invoked with two arguments. {F12314} The ** first argument to the handler is a copy of the void* pointer which ** is the third argument to this routine. {F12315} The second argument to ** the handler is the number of times that the busy handler has ** been invoked for this locking event. {F12316} If the ** busy callback returns 0, then no additional attempts are made to ** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned. ** {F12317} If the callback returns non-zero, then another attempt ** is made to open the database for reading and the cycle repeats. ** ** {U12318} The presence of a busy handler does not guarantee that ** it will be invoked when there is lock contention. ** If SQLite determines that invoking the busy handler could result in ** a deadlock, it will return [SQLITE_BUSY] instead. {END} ** Consider a scenario where one process is holding a read lock that ** it is trying to promote to a reserved lock and ** a second process is holding a reserved lock that it is trying ** to promote to an exclusive lock. The first process cannot proceed ** because it is blocked by the second and the second process cannot ** proceed because it is blocked by the first. If both processes ** invoke the busy handlers, neither will make any progress. ** {F12319} Therefore, ** SQLite returns [SQLITE_BUSY] for the first process, hoping that this ** will induce the first process to release its read lock and allow ** the second process to proceed. ** ** {F12321} The default busy callback is NULL. ** ** {F12322} The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED] ** when SQLite is in the middle of a large transaction where all the ** changes will not fit into the in-memory cache. {F12323} SQLite will ** already hold a RESERVED lock on the database file, but it needs ** to promote this lock to EXCLUSIVE so that it can spill cache ** pages into the database file without harm to concurrent ** readers. {F12324} If it is unable to promote the lock, then the in-memory ** cache will be left in an inconsistent state and so the error ** code is promoted from the relatively benign [SQLITE_BUSY] to ** the more severe [SQLITE_IOERR_BLOCKED]. {F12325} This error code promotion ** forces an automatic rollback of the changes. {END} See the ** <a href="http://www.sqlite.org/cvstrac/wiki?p=CorruptionFollowingBusyError"> ** CorruptionFollowingBusyError</a> wiki page for a discussion of why ** this is important. ** ** {F12326} Sqlite is re-entrant, so the busy handler may start a new ** query. {END} (It is not clear why anyone would every want to do this, ** but it is allowed, in theory.) {U12327} But the busy handler may not ** close the database. Closing the database from a busy handler will delete ** data structures out from under the executing query and will ** probably result in a segmentation fault or other runtime error. {END} ** ** {F12328} There can only be a single busy handler defined for each database ** connection. Setting a new busy handler clears any previous one. ** {F12329} Note that calling [sqlite3_busy_timeout()] will also set or clear ** the busy handler. ** ** {F12331} When operating in [sqlite3_enable_shared_cache | shared cache mode], ** only a single busy handler can be defined for each database file. ** So if two database connections share a single cache, then changing ** the busy handler on one connection will also change the busy ** handler in the other connection. {F12332} The busy handler is invoked ** in the thread that was running when the SQLITE_BUSY was hit. */ int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); /* ** CAPI3REF: Set A Busy Timeout {F12340} ** ** {F12341} This routine sets a busy handler that sleeps for a while when a ** table is locked. {F12342} The handler will sleep multiple times until ** at least "ms" milliseconds of sleeping have been done. {F12343} After ** "ms" milliseconds of sleeping, the handler returns 0 which ** causes [sqlite3_step()] to return [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]. ** ** {F12344} Calling this routine with an argument less than or equal to zero ** turns off all busy handlers. ** ** {F12345} There can only be a single busy handler for a particular database ** connection. If another busy handler was defined ** (using [sqlite3_busy_handler()]) prior to calling ** this routine, that other busy handler is cleared. */ int sqlite3_busy_timeout(sqlite3*, int ms); /* ** CAPI3REF: Convenience Routines For Running Queries {F12370} ** ** This next routine is a convenience wrapper around [sqlite3_exec()]. ** {F12371} Instead of invoking a user-supplied callback for each row of the ** result, this routine remembers each row of the result in memory ** obtained from [sqlite3_malloc()], then returns all of the result after the ** query has finished. {F12372} ** ** As an example, suppose the query result where this table: ** ** <blockquote><pre> ** Name | Age ** ----------------------- ** Alice | 43 |
︙ | ︙ | |||
1065 1066 1067 1068 1069 1070 1071 | ** </pre></blockquote> ** ** Notice that there is an extra row of data containing the column ** headers. But the *nrow return value is still 3. *ncolumn is ** set to 2. In general, the number of values inserted into azResult ** will be ((*nrow) + 1)*(*ncolumn). ** | | | | > | | | | | | | | | | | | | | 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 | ** </pre></blockquote> ** ** Notice that there is an extra row of data containing the column ** headers. But the *nrow return value is still 3. *ncolumn is ** set to 2. In general, the number of values inserted into azResult ** will be ((*nrow) + 1)*(*ncolumn). ** ** {U12374} After the calling function has finished using the result, it should ** pass the result data pointer to sqlite3_free_table() in order to ** release the memory that was malloc-ed. Because of the way the ** [sqlite3_malloc()] happens, the calling function must not try to call ** [sqlite3_free()] directly. Only [sqlite3_free_table()] is able to release ** the memory properly and safely. {END} ** ** {F12373} The return value of this routine is the same as ** from [sqlite3_exec()]. */ int sqlite3_get_table( sqlite3*, /* An open database */ const char *sql, /* SQL to be executed */ char ***resultp, /* Result written to a char *[] that this points to */ int *nrow, /* Number of result rows written here */ int *ncolumn, /* Number of result columns written here */ char **errmsg /* Error msg written here */ ); void sqlite3_free_table(char **result); /* ** CAPI3REF: Formatted String Printing Functions {F17400} ** ** These routines are workalikes of the "printf()" family of functions ** from the standard C library. ** ** {F17401} The sqlite3_mprintf() and sqlite3_vmprintf() routines write their ** results into memory obtained from [sqlite3_malloc()]. ** {U17402} The strings returned by these two routines should be ** released by [sqlite3_free()]. {F17403} Both routines return a ** NULL pointer if [sqlite3_malloc()] is unable to allocate enough ** memory to hold the resulting string. ** ** {F17404} In sqlite3_snprintf() routine is similar to "snprintf()" from ** the standard C library. The result is written into the ** buffer supplied as the second parameter whose size is given by ** the first parameter. {END} Note that the order of the ** first two parameters is reversed from snprintf(). This is an ** historical accident that cannot be fixed without breaking ** backwards compatibility. {F17405} Note also that sqlite3_snprintf() ** returns a pointer to its buffer instead of the number of ** characters actually written into the buffer. {END} We admit that ** the number of characters written would be a more useful return ** value but we cannot change the implementation of sqlite3_snprintf() ** now without breaking compatibility. ** ** {F17406} As long as the buffer size is greater than zero, sqlite3_snprintf() ** guarantees that the buffer is always zero-terminated. {F17407} The first ** parameter "n" is the total size of the buffer, including space for ** the zero terminator. {END} So the longest string that can be completely ** written will be n-1 characters. ** ** These routines all implement some additional formatting ** options that are useful for constructing SQL statements. ** All of the usual printf formatting options apply. In addition, there ** is are "%q", "%Q", and "%z" options. ** ** {F17410} The %q option works like %s in that it substitutes a null-terminated ** string from the argument list. But %q also doubles every '\'' character. ** %q is designed for use inside a string literal. {END} By doubling each '\'' ** character it escapes that character and allows it to be inserted into ** the string. ** ** For example, so some string variable contains text as follows: ** ** <blockquote><pre> ** char *zText = "It's a happy day!"; |
︙ | ︙ | |||
1159 1160 1161 1162 1163 1164 1165 | ** INSERT INTO table1 VALUES('It's a happy day!'); ** </pre></blockquote> ** ** This second example is an SQL syntax error. As a general rule you ** should always use %q instead of %s when inserting text into a string ** literal. ** | | | | | | > | | > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > | | | > | | | | | > > > > > > > > | > | > | < < < | | | > | | | | | | | | | | | | | | | | 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 | ** INSERT INTO table1 VALUES('It's a happy day!'); ** </pre></blockquote> ** ** This second example is an SQL syntax error. As a general rule you ** should always use %q instead of %s when inserting text into a string ** literal. ** ** {F17411} The %Q option works like %q except it also adds single quotes around ** the outside of the total string. Or if the parameter in the argument ** list is a NULL pointer, %Q substitutes the text "NULL" (without single ** quotes) in place of the %Q option. {END} So, for example, one could say: ** ** <blockquote><pre> ** char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText); ** sqlite3_exec(db, zSQL, 0, 0, 0); ** sqlite3_free(zSQL); ** </pre></blockquote> ** ** The code above will render a correct SQL statement in the zSQL ** variable even if the zText variable is a NULL pointer. ** ** {F17412} The "%z" formatting option works exactly like "%s" with the ** addition that after the string has been read and copied into ** the result, [sqlite3_free()] is called on the input string. {END} */ char *sqlite3_mprintf(const char*,...); char *sqlite3_vmprintf(const char*, va_list); char *sqlite3_snprintf(int,char*,const char*, ...); /* ** CAPI3REF: Memory Allocation Subsystem {F17300} ** ** {F17301} The SQLite core (not counting operating-system specific VFS ** implementations) uses these three routines for all of its own ** internal memory allocation needs. {END} ** ** {F17302} The sqlite3_malloc() routine returns a pointer to a block ** of memory at least N bytes in length, where N is the parameter. ** {F17303} If sqlite3_malloc() is unable to obtain sufficient free ** memory, it returns a NULL pointer. {F17304} If the parameter N to ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns ** a NULL pointer. ** ** {F17305} Calling sqlite3_free() with a pointer previously returned ** by sqlite3_malloc() or sqlite3_realloc() releases that memory so ** that it might be reused. {F17306} The sqlite3_free() routine is ** a no-op if is called with a NULL pointer. Passing a NULL pointer ** to sqlite3_free() is harmless. {U17307} After being freed, memory ** should neither be read nor written. Even reading previously freed ** memory might result in a segmentation fault or other severe error. ** {U17309} Memory corruption, a segmentation fault, or other severe error ** might result if sqlite3_free() is called with a non-NULL pointer that ** was not obtained from sqlite3_malloc() or sqlite3_free(). ** ** {F17310} The sqlite3_realloc() interface attempts to resize a ** prior memory allocation to be at least N bytes, where N is the ** second parameter. The memory allocation to be resized is the first ** parameter. {F17311} If the first parameter to sqlite3_realloc() ** is a NULL pointer then its behavior is identical to calling ** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc(). ** {F17312} If the second parameter to sqlite3_realloc() is zero or ** negative then the behavior is exactly the same as calling ** sqlite3_free(P) where P is the first parameter to sqlite3_realloc(). ** {F17313} Sqlite3_realloc() returns a pointer to a memory allocation ** of at least N bytes in size or NULL if sufficient memory is unavailable. ** {F17314} If M is the size of the prior allocation, then min(N,M) bytes ** of the prior allocation are copied into the beginning of buffer returned ** by sqlite3_realloc() and the prior allocation is freed. ** {F17315} If sqlite3_realloc() returns NULL, then the prior allocation ** is not freed. ** ** {F17381} The default implementation ** of the memory allocation subsystem uses the malloc(), realloc() ** and free() provided by the standard C library. {F17382} However, if ** SQLite is compiled with the following C preprocessor macro ** ** <blockquote> SQLITE_MEMORY_SIZE=<i>NNN</i> </blockquote> ** ** where <i>NNN</i> is an integer, then SQLite create a static ** array of at least <i>NNN</i> bytes in size and use that array ** for all of its dynamic memory allocation needs. {END} Additional ** memory allocator options may be added in future releases. ** ** In SQLite version 3.5.0 and 3.5.1, it was possible to define ** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in ** implementation of these routines to be omitted. That capability ** is no longer provided. Only built-in memory allocators can be ** used. ** ** <b>Exception:</b> The windows OS interface layer calls ** the system malloc() and free() directly when converting ** filenames between the UTF-8 encoding used by SQLite ** and whatever filename encoding is used by the particular windows ** installation. Memory allocation errors are detected, but ** they are reported back as [SQLITE_CANTOPEN] or ** [SQLITE_IOERR] rather than [SQLITE_NOMEM]. */ void *sqlite3_malloc(int); void *sqlite3_realloc(void*, int); void sqlite3_free(void*); /* ** CAPI3REF: Memory Allocator Statistics {F17370} ** ** In addition to the basic three allocation routines ** [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()], ** the memory allocation subsystem included with the SQLite ** sources provides the interfaces shown here. ** ** {F17371} The sqlite3_memory_used() routine returns the ** number of bytes of memory currently outstanding (malloced but not freed). ** {F17372} The value returned by sqlite3_memory_used() includes ** any overhead added by SQLite, but not overhead added by the ** library malloc() that backs the sqlite3_malloc() implementation. ** {F17373} The sqlite3_memory_highwater() routines returns the ** maximum number of bytes that have been outstanding since the ** highwater mark was last reset. ** {F17374} The byte count returned by sqlite3_memory_highwater() ** uses the same byte counting rules as sqlite3_memory_used(). ** {F17375} If the parameter to sqlite3_memory_highwater() is true, ** then the highwater mark is reset to the current value of ** sqlite3_memory_used() and the prior highwater mark (before the ** reset) is returned. {F17376} If the parameter to ** sqlite3_memory_highwater() is zero, then the highwater mark is ** unchanged. */ sqlite3_int64 sqlite3_memory_used(void); sqlite3_int64 sqlite3_memory_highwater(int resetFlag); /* ** CAPI3REF: Compile-Time Authorization Callbacks {F12500} ** ** {F12501} This routine registers a authorizer callback with a particular ** database connection, supplied in the first argument. {F12502} ** The authorizer callback is invoked as SQL statements are being compiled ** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()], ** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. {F12503} At various ** points during the compilation process, as logic is being created ** to perform various actions, the authorizer callback is invoked to ** see if those actions are allowed. {X12504} The authorizer callback should ** return SQLITE_OK to allow the action, [SQLITE_IGNORE] to disallow the ** specific action but allow the SQL statement to continue to be ** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be ** rejected with an error. {END} ** ** Depending on the action, the [SQLITE_IGNORE] and [SQLITE_DENY] return ** codes might mean something different or they might mean the same ** thing. If the action is, for example, to perform a delete opertion, ** then [SQLITE_IGNORE] and [SQLITE_DENY] both cause the statement compilation ** to fail with an error. But if the action is to read a specific column ** from a specific table, then [SQLITE_DENY] will cause the entire ** statement to fail but [SQLITE_IGNORE] will cause a NULL value to be ** read instead of the actual column value. ** ** {F12510} The first parameter to the authorizer callback is a copy of ** the third parameter to the sqlite3_set_authorizer() interface. ** {F12511} The second parameter to the callback is an integer ** [SQLITE_COPY | action code] that specifies the particular action ** to be authorized. {END} The available action codes are ** [SQLITE_COPY | documented separately]. {F12512} The third through sixth ** parameters to the callback are zero-terminated strings that contain ** additional details about the action to be authorized. {END} ** ** An authorizer is used when preparing SQL statements from an untrusted ** source, to ensure that the SQL statements do not try to access data ** that they are not allowed to see, or that they do not try to ** execute malicious statements that damage the database. For ** example, an application may allow a user to enter arbitrary ** SQL queries for evaluation by a database. But the application does ** not want the user to be able to make arbitrary changes to the ** database. An authorizer could then be put in place while the ** user-entered SQL is being prepared that disallows everything ** except SELECT statements. ** ** {F12520} Only a single authorizer can be in place on a database connection ** at a time. Each call to sqlite3_set_authorizer overrides the ** previous call. {F12521} A NULL authorizer means that no authorization ** callback is invoked. {F12522} The default authorizer is NULL. {END} ** ** Note that the authorizer callback is invoked only during ** [sqlite3_prepare()] or its variants. {F12523} Authorization is not ** performed during statement evaluation in [sqlite3_step()]. {END} */ int sqlite3_set_authorizer( sqlite3*, int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), void *pUserData ); /* ** CAPI3REF: Authorizer Return Codes {F12505} ** ** The [sqlite3_set_authorizer | authorizer callback function] must ** return either [SQLITE_OK] or one of these two constants in order ** to signal SQLite whether or not the action is permitted. See the ** [sqlite3_set_authorizer | authorizer documentation] for additional ** information. */ |
︙ | ︙ | |||
1362 1363 1364 1365 1366 1367 1368 | #define SQLITE_ANALYZE 28 /* Table Name NULL */ #define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ #define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ #define SQLITE_FUNCTION 31 /* Function Name NULL */ #define SQLITE_COPY 0 /* No longer used */ /* | | > | > > > > | | > | | > | | | | | > | | | | | | | | | | > | | | > > | | > > > | > | | | | | | | | | > | | > | | | > | | | | | | | | | 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 | #define SQLITE_ANALYZE 28 /* Table Name NULL */ #define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ #define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ #define SQLITE_FUNCTION 31 /* Function Name NULL */ #define SQLITE_COPY 0 /* No longer used */ /* ** CAPI3REF: Tracing And Profiling Functions {F12290} ** ** These routines register callback functions that can be used for ** tracing and profiling the execution of SQL statements. ** ** {F12291} The callback function registered by sqlite3_trace() is invoked ** at the first [sqlite3_step()] for the evaluation of an SQL statement. ** {F12292} Only a single trace callback can be registered at a time. ** Each call to sqlite3_trace() overrides the previous. {F12293} A ** NULL callback for sqlite3_trace() disables tracing. ** ** {F12295} The callback function registered by sqlite3_profile() is invoked ** as each SQL statement finishes and includes ** information on how long that statement ran.{END} ** ** ** The sqlite3_profile() API is currently considered experimental and ** is subject to change. */ void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); void *sqlite3_profile(sqlite3*, void(*xProfile)(void*,const char*,sqlite3_uint64), void*); /* ** CAPI3REF: Query Progress Callbacks {F12910} ** ** {F12911} This routine configures a callback function - the ** progress callback - that is invoked periodically during long ** running calls to [sqlite3_exec()], [sqlite3_step()] and ** [sqlite3_get_table()]. {END} An example use for this ** interface is to keep a GUI updated during a large query. ** ** {F12912} The progress callback is invoked once for every N virtual ** machine opcodes, where N is the second argument to this function. ** {F12913} The progress callback itself is identified by the third ** argument to this function. {F12914} The fourth argument to this ** function is a void pointer passed to the progress callback ** function each time it is invoked. {END} ** ** {F12915} If a call to [sqlite3_exec()], [sqlite3_step()], or ** [sqlite3_get_table()] results in fewer than N opcodes being executed, ** then the progress callback is never invoked. {END} ** ** {F12916} Only a single progress callback function may be registered for each ** open database connection. Every call to sqlite3_progress_handler() ** overwrites the results of the previous call. {F12917} ** To remove the progress callback altogether, pass NULL as the third ** argument to this function. {END} ** ** {F12918} If the progress callback returns a result other than 0, then ** the current query is immediately terminated and any database changes ** rolled back. {F12919} ** The containing [sqlite3_exec()], [sqlite3_step()], or ** [sqlite3_get_table()] call returns SQLITE_INTERRUPT. {END} This feature ** can be used, for example, to implement the "Cancel" button on a ** progress dialog box in a GUI. */ void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); /* ** CAPI3REF: Opening A New Database Connection {F12700} ** ** {F12701} These routines open an SQLite database file whose name ** is given by the filename argument. ** {F12702} The filename argument is interpreted as UTF-8 ** for [sqlite3_open()] and [sqlite3_open_v2()] and as UTF-16 ** in the native byte order for [sqlite3_open16()]. ** {F12703} An [sqlite3*] handle is returned in *ppDb, even ** if an error occurs. {F12723} (Exception: if SQLite is unable ** to allocate memory to hold the [sqlite3] object, a NULL will ** be written into *ppDb instead of a pointer to the [sqlite3] object.) ** {F12704} If the database is opened (and/or created) ** successfully, then [SQLITE_OK] is returned. {F12705} Otherwise an ** error code is returned. {F12706} The ** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain ** an English language description of the error. ** ** {F12707} The default encoding for the database will be UTF-8 if ** [sqlite3_open()] or [sqlite3_open_v2()] is called and ** UTF-16 in the native byte order if [sqlite3_open16()] is used. ** ** {F12708} Whether or not an error occurs when it is opened, resources ** associated with the [sqlite3*] handle should be released by passing it ** to [sqlite3_close()] when it is no longer required. ** ** {F12709} The [sqlite3_open_v2()] interface works like [sqlite3_open()] ** except that provides two additional parameters for additional control ** over the new database connection. {F12710} The flags parameter can be ** one of: ** ** <ol> ** <li> [SQLITE_OPEN_READONLY] ** <li> [SQLITE_OPEN_READWRITE] ** <li> [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE] ** </ol> ** ** {F12711} The first value opens the database read-only. ** {F12712} If the database does not previously exist, an error is returned. ** {F12713} The second option opens ** the database for reading and writing if possible, or reading only if ** if the file is write protected. {F12714} In either case the database ** must already exist or an error is returned. {F12715} The third option ** opens the database for reading and writing and creates it if it does ** not already exist. {F12716} ** The third options is behavior that is always used for [sqlite3_open()] ** and [sqlite3_open16()]. ** ** {F12717} If the filename is ":memory:", then an private ** in-memory database is created for the connection. {F12718} This in-memory ** database will vanish when the database connection is closed. {END} Future ** version of SQLite might make use of additional special filenames ** that begin with the ":" character. It is recommended that ** when a database filename really does begin with ** ":" that you prefix the filename with a pathname like "./" to ** avoid ambiguity. ** ** {F12719} If the filename is an empty string, then a private temporary ** on-disk database will be created. {F12720} This private database will be ** automatically deleted as soon as the database connection is closed. ** ** {F12721} The fourth parameter to sqlite3_open_v2() is the name of the ** [sqlite3_vfs] object that defines the operating system ** interface that the new database connection should use. {F12722} If the ** fourth parameter is a NULL pointer then the default [sqlite3_vfs] ** object is used. {END} ** ** <b>Note to windows users:</b> The encoding used for the filename argument ** of [sqlite3_open()] and [sqlite3_open_v2()] must be UTF-8, not whatever ** codepage is currently defined. Filenames containing international ** characters must be converted to UTF-8 prior to passing them into ** [sqlite3_open()] or [sqlite3_open_v2()]. */ |
︙ | ︙ | |||
1492 1493 1494 1495 1496 1497 1498 | const char *filename, /* Database filename (UTF-8) */ sqlite3 **ppDb, /* OUT: SQLite db handle */ int flags, /* Flags */ const char *zVfs /* Name of VFS module to use */ ); /* | | | | | | | > | | | > | | | | | | | | | | | 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 | const char *filename, /* Database filename (UTF-8) */ sqlite3 **ppDb, /* OUT: SQLite db handle */ int flags, /* Flags */ const char *zVfs /* Name of VFS module to use */ ); /* ** CAPI3REF: Error Codes And Messages {F12800} ** ** {F12801} The sqlite3_errcode() interface returns the numeric ** [SQLITE_OK | result code] or [SQLITE_IOERR_READ | extended result code] ** for the most recent failed sqlite3_* API call associated ** with [sqlite3] handle 'db'. {U12802} If a prior API call failed but the ** most recent API call succeeded, the return value from sqlite3_errcode() ** is undefined. {END} ** ** {F12803} The sqlite3_errmsg() and sqlite3_errmsg16() return English-language ** text that describes the error, as either UTF8 or UTF16 respectively. ** {F12804} Memory to hold the error message string is managed internally. ** {U12805} The ** string may be overwritten or deallocated by subsequent calls to SQLite ** interface functions. {END} ** ** {F12806} Calls to many sqlite3_* functions set the error code and ** string returned by [sqlite3_errcode()], [sqlite3_errmsg()], and ** [sqlite3_errmsg16()] overwriting the previous values. {F12807} ** Except, calls to [sqlite3_errcode()], ** [sqlite3_errmsg()], and [sqlite3_errmsg16()] themselves do not affect the ** results of future invocations. {F12808} Calls to API routines that ** do not return an error code (example: [sqlite3_data_count()]) do not ** change the error code returned by this routine. {F12809} Interfaces that ** are not associated with a specific database connection (examples: ** [sqlite3_mprintf()] or [sqlite3_enable_shared_cache()] do not change ** the return code. {END} ** ** {F12810} Assuming no other intervening sqlite3_* API calls are made, ** the error code returned by this function is associated with the same ** error as the strings returned by [sqlite3_errmsg()] and [sqlite3_errmsg16()]. */ int sqlite3_errcode(sqlite3 *db); const char *sqlite3_errmsg(sqlite3*); const void *sqlite3_errmsg16(sqlite3*); /* ** CAPI3REF: SQL Statement Object {F13000} ** ** Instance of this object represent single SQL statements. This ** is variously known as a "prepared statement" or a ** "compiled SQL statement" or simply as a "statement". ** ** The life of a statement object goes something like this: ** |
︙ | ︙ | |||
1552 1553 1554 1555 1556 1557 1558 | ** ** Refer to documentation on individual methods above for additional ** information. */ typedef struct sqlite3_stmt sqlite3_stmt; /* | | | | | | | | | | | | | | | | > | | | | | | | | > | | | | | > | | 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 | ** ** Refer to documentation on individual methods above for additional ** information. */ typedef struct sqlite3_stmt sqlite3_stmt; /* ** CAPI3REF: Compiling An SQL Statement {F13010} ** ** To execute an SQL query, it must first be compiled into a byte-code ** program using one of these routines. ** ** {F13011} The first argument "db" is an [sqlite3 | SQLite database handle] ** obtained from a prior call to [sqlite3_open()], [sqlite3_open_v2()] ** or [sqlite3_open16()]. {F13012} ** The second argument "zSql" is the statement to be compiled, encoded ** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2() ** interfaces uses UTF-8 and sqlite3_prepare16() and sqlite3_prepare16_v2() ** use UTF-16. {END} ** ** {F13013} If the nByte argument is less ** than zero, then zSql is read up to the first zero terminator. ** {F13014} If nByte is non-negative, then it is the maximum number of ** bytes read from zSql. When nByte is non-negative, the ** zSql string ends at either the first '\000' character or ** until the nByte-th byte, whichever comes first. {END} ** ** {F13015} *pzTail is made to point to the first byte past the end of the ** first SQL statement in zSql. This routine only compiles the first statement ** in zSql, so *pzTail is left pointing to what remains uncompiled. {END} ** ** {F13016} *ppStmt is left pointing to a compiled ** [sqlite3_stmt | SQL statement structure] that can be ** executed using [sqlite3_step()]. Or if there is an error, *ppStmt may be ** set to NULL. {F13017} If the input text contained no SQL (if the input ** is and empty string or a comment) then *ppStmt is set to NULL. ** {U13018} The calling procedure is responsible for deleting the ** compiled SQL statement ** using [sqlite3_finalize()] after it has finished with it. ** ** {F13019} On success, [SQLITE_OK] is returned. Otherwise an ** [SQLITE_ERROR | error code] is returned. {END} ** ** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are ** recommended for all new programs. The two older interfaces are retained ** for backwards compatibility, but their use is discouraged. ** {F13020} In the "v2" interfaces, the prepared statement ** that is returned (the [sqlite3_stmt] object) contains a copy of the ** original SQL text. {END} This causes the [sqlite3_step()] interface to ** behave a differently in two ways: ** ** <ol> ** <li>{F13022} ** If the database schema changes, instead of returning [SQLITE_SCHEMA] as it ** always used to do, [sqlite3_step()] will automatically recompile the SQL ** statement and try to run it again. {F12023} If the schema has changed in ** a way that makes the statement no longer valid, [sqlite3_step()] will still ** return [SQLITE_SCHEMA]. {END} But unlike the legacy behavior, ** [SQLITE_SCHEMA] is now a fatal error. {F12024} Calling ** [sqlite3_prepare_v2()] again will not make the ** error go away. {F12025} Note: use [sqlite3_errmsg()] to find the text ** of the parsing error that results in an [SQLITE_SCHEMA] return. {END} ** </li> ** ** <li> ** {F13030} When an error occurs, ** [sqlite3_step()] will return one of the detailed ** [SQLITE_ERROR | result codes] or ** [SQLITE_IOERR_READ | extended result codes]. {F13031} ** The legacy behavior was that [sqlite3_step()] would only return a generic ** [SQLITE_ERROR] result code and you would have to make a second call to ** [sqlite3_reset()] in order to find the underlying cause of the problem. ** {F13032} ** With the "v2" prepare interfaces, the underlying reason for the error is ** returned immediately. {END} ** </li> ** </ol> */ int sqlite3_prepare( sqlite3 *db, /* Database handle */ const char *zSql, /* SQL statement, UTF-8 encoded */ int nByte, /* Maximum length of zSql in bytes. */ |
︙ | ︙ | |||
1650 1651 1652 1653 1654 1655 1656 | const void *zSql, /* SQL statement, UTF-16 encoded */ int nByte, /* Maximum length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const void **pzTail /* OUT: Pointer to unused portion of zSql */ ); /* | | < | > | | | > > | > | < < | | | | | | | | | | | > | < | | | | | | | | | > | > | | | | | | | | | | | | | | | | | | | | | > | | | > | | | | | | | | | | | | | | | > | | | > | | | | | | | | | | | | | | | | | | | | | | | | | | > | | | | | | 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 | const void *zSql, /* SQL statement, UTF-16 encoded */ int nByte, /* Maximum length of zSql in bytes. */ sqlite3_stmt **ppStmt, /* OUT: Statement handle */ const void **pzTail /* OUT: Pointer to unused portion of zSql */ ); /* ** CAPIREF: Retrieving Statement SQL {F13100} ** ** {F13101} If the compiled SQL statement passed as an argument was ** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()], ** then this function returns a pointer to a zero-terminated string ** containing a copy of the original SQL statement. {F13102} The ** pointer is valid until the statement ** is deleted using sqlite3_finalize(). ** {F13103} The string returned by sqlite3_sql() is always UTF8 even ** if a UTF16 string was originally entered using [sqlite3_prepare16_v2()]. ** ** {F13104} If the statement was compiled using either of the legacy ** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this ** function returns NULL. */ const char *sqlite3_sql(sqlite3_stmt *pStmt); /* ** CAPI3REF: Dynamically Typed Value Object {F15000} ** ** SQLite uses dynamic typing for the values it stores. Values can ** be integers, floating point values, strings, BLOBs, or NULL. When ** passing around values internally, each value is represented as ** an instance of the sqlite3_value object. */ typedef struct Mem sqlite3_value; /* ** CAPI3REF: SQL Function Context Object {F16001} ** ** The context in which an SQL function executes is stored in an ** sqlite3_context object. A pointer to such an object is the ** first parameter to user-defined SQL functions. */ typedef struct sqlite3_context sqlite3_context; /* ** CAPI3REF: Binding Values To Prepared Statements {F13500} ** ** {F13501} In the SQL strings input to [sqlite3_prepare_v2()] and its ** variants, one or more literals can be replace by a parameter in one ** of these forms: ** ** <ul> ** <li> ? ** <li> ?NNN ** <li> :AAA ** <li> @AAA ** <li> $VVV ** </ul> ** ** In the parameter forms shown above NNN is an integer literal, ** AAA is an alphanumeric identifier and VVV is a variable name according ** to the syntax rules of the TCL programming language. {END} ** The values of these parameters (also called "host parameter names") ** can be set using the sqlite3_bind_*() routines defined here. ** ** {F13502} The first argument to the sqlite3_bind_*() routines always ** is a pointer to the [sqlite3_stmt] object returned from ** [sqlite3_prepare_v2()] or its variants. {F13503} The second ** argument is the index of the parameter to be set. {F13504} The ** first parameter has an index of 1. {F13505} When the same named ** parameter is used more than once, second and subsequent ** occurrences have the same index as the first occurrence. ** {F13506} The index for named parameters can be looked up using the ** [sqlite3_bind_parameter_name()] API if desired. {F13507} The index ** for "?NNN" parametes is the value of NNN. ** {F13508} The NNN value must be between 1 and the compile-time ** parameter SQLITE_MAX_VARIABLE_NUMBER (default value: 999). {END} ** See <a href="limits.html">limits.html</a> for additional information. ** ** {F13509} The third argument is the value to bind to the parameter. {END} ** ** {F13510} In those ** routines that have a fourth argument, its value is the number of bytes ** in the parameter. To be clear: the value is the number of bytes in the ** string, not the number of characters. {F13511} The number ** of bytes does not include the zero-terminator at the end of strings. ** {F13512} ** If the fourth parameter is negative, the length of the string is ** number of bytes up to the first zero terminator. {END} ** ** {F13513} ** The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and ** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or ** text after SQLite has finished with it. {F13514} If the fifth argument is ** the special value [SQLITE_STATIC], then the library assumes that the ** information is in static, unmanaged space and does not need to be freed. ** {F13515} If the fifth argument has the value [SQLITE_TRANSIENT], then ** SQLite makes its own private copy of the data immediately, before ** the sqlite3_bind_*() routine returns. {END} ** ** {F13520} The sqlite3_bind_zeroblob() routine binds a BLOB of length N that ** is filled with zeros. {F13521} A zeroblob uses a fixed amount of memory ** (just an integer to hold it size) while it is being processed. {END} ** Zeroblobs are intended to serve as place-holders for BLOBs whose ** content is later written using ** [sqlite3_blob_open | increment BLOB I/O] routines. {F13522} A negative ** value for the zeroblob results in a zero-length BLOB. {END} ** ** {F13530} The sqlite3_bind_*() routines must be called after ** [sqlite3_prepare_v2()] (and its variants) or [sqlite3_reset()] and ** before [sqlite3_step()]. {F13531} ** Bindings are not cleared by the [sqlite3_reset()] routine. ** {F13532} Unbound parameters are interpreted as NULL. {END} ** ** {F13540} These routines return [SQLITE_OK] on success or an error code if ** anything goes wrong. {F13541} [SQLITE_RANGE] is returned if the parameter ** index is out of range. {F13542} [SQLITE_NOMEM] is returned if malloc fails. ** {F13543} [SQLITE_MISUSE] is returned if these routines are called on a ** virtual machine that is the wrong state or which has already been finalized. */ int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); int sqlite3_bind_double(sqlite3_stmt*, int, double); int sqlite3_bind_int(sqlite3_stmt*, int, int); int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64); int sqlite3_bind_null(sqlite3_stmt*, int); int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n); /* ** CAPI3REF: Number Of Host Parameters {F13600} ** ** {F13601} Return the largest host parameter index in the precompiled ** statement given as the argument. {F13602} When the host parameters ** are of the forms like ":AAA" or "?", ** then they are assigned sequential increasing numbers beginning ** with one, so the value returned is the number of parameters. ** {F13603} However ** if the same host parameter name is used multiple times, each occurrance ** is given the same number, so the value returned in that case is the number ** of unique host parameter names. {F13604} If host parameters of the ** form "?NNN" are used (where NNN is an integer) then there might be ** gaps in the numbering and the value returned by this interface is ** the index of the host parameter with the largest index value. {END} ** ** {U13605} The prepared statement must not be [sqlite3_finalize | finalized] ** prior to this routine returning. Otherwise the results are undefined ** and probably undesirable. */ int sqlite3_bind_parameter_count(sqlite3_stmt*); /* ** CAPI3REF: Name Of A Host Parameter {F13620} ** ** {F13621} This routine returns a pointer to the name of the n-th ** parameter in a [sqlite3_stmt | prepared statement]. {F13622} ** Host parameters of the form ":AAA" or "@AAA" or "$VVV" have a name ** which is the string ":AAA" or "@AAA" or "$VVV". ** In other words, the initial ":" or "$" or "@" ** is included as part of the name. {F13623} ** Parameters of the form "?" or "?NNN" have no name. ** ** {F13623} The first bound parameter has an index of 1, not 0. ** ** {F13624} If the value n is out of range or if the n-th parameter is ** nameless, then NULL is returned. {F13625} The returned string is ** always in the UTF-8 encoding even if the named parameter was ** originally specified as UTF-16 in [sqlite3_prepare16()] or ** [sqlite3_prepare16_v2()]. */ const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); /* ** CAPI3REF: Index Of A Parameter With A Given Name {F13640} ** ** {F13641} This routine returns the index of a host parameter with the ** given name. {F13642} The name must match exactly. {F13643} ** If no parameter with the given name is found, return 0. ** {F13644} Parameter names must be UTF8. */ int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); /* ** CAPI3REF: Reset All Bindings On A Prepared Statement {F13660} ** ** {F13661} Contrary to the intuition of many, [sqlite3_reset()] does not ** reset the [sqlite3_bind_blob | bindings] on a ** [sqlite3_stmt | prepared statement]. {F13662} Use this routine to ** reset all host parameters to NULL. */ int sqlite3_clear_bindings(sqlite3_stmt*); /* ** CAPI3REF: Number Of Columns In A Result Set {F13710} ** ** {F13711} Return the number of columns in the result set returned by the ** [sqlite3_stmt | compiled SQL statement]. {F13712} This routine returns 0 ** if pStmt is an SQL statement that does not return data (for ** example an UPDATE). */ int sqlite3_column_count(sqlite3_stmt *pStmt); /* ** CAPI3REF: Column Names In A Result Set {F13720} ** ** {F13721} These routines return the name assigned to a particular column ** in the result set of a SELECT statement. {F13722} The sqlite3_column_name() ** interface returns a pointer to a UTF8 string and sqlite3_column_name16() ** returns a pointer to a UTF16 string. {F13723} The first parameter is the ** [sqlite3_stmt | prepared statement] that implements the SELECT statement. ** The second parameter is the column number. The left-most column is ** number 0. ** ** {F13724} The returned string pointer is valid until either the ** [sqlite3_stmt | prepared statement] is destroyed by [sqlite3_finalize()] ** or until the next call sqlite3_column_name() or sqlite3_column_name16() ** on the same column. ** ** {F13725} If sqlite3_malloc() fails during the processing of either routine ** (for example during a conversion from UTF-8 to UTF-16) then a ** NULL pointer is returned. */ const char *sqlite3_column_name(sqlite3_stmt*, int N); const void *sqlite3_column_name16(sqlite3_stmt*, int N); /* ** CAPI3REF: Source Of Data In A Query Result {F13740} ** ** {F13741} These routines provide a means to determine what column of what ** table in which database a result of a SELECT statement comes from. ** {F13742} The name of the database or table or column can be returned as ** either a UTF8 or UTF16 string. {F13743} The _database_ routines return ** the database name, the _table_ routines return the table name, and ** the origin_ routines return the column name. {F13744} ** The returned string is valid until ** the [sqlite3_stmt | prepared statement] is destroyed using ** [sqlite3_finalize()] or until the same information is requested ** again in a different encoding. ** ** {F13745} The names returned are the original un-aliased names of the ** database, table, and column. ** ** {F13746} The first argument to the following calls is a ** [sqlite3_stmt | compiled SQL statement]. ** {F13747} These functions return information about the Nth column returned by ** the statement, where N is the second function argument. ** ** {F13748} If the Nth column returned by the statement is an expression ** or subquery and is not a column value, then all of these functions ** return NULL. {F13749} Otherwise, they return the ** name of the attached database, table and column that query result ** column was extracted from. ** ** {F13750} As with all other SQLite APIs, those postfixed with "16" return ** UTF-16 encoded strings, the other functions return UTF-8. {END} ** ** These APIs are only available if the library was compiled with the ** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. ** ** {U13751} ** If two or more threads call one or more of these routines against the same ** prepared statement and column at the same time then the results are ** undefined. */ const char *sqlite3_column_database_name(sqlite3_stmt*,int); const void *sqlite3_column_database_name16(sqlite3_stmt*,int); const char *sqlite3_column_table_name(sqlite3_stmt*,int); const void *sqlite3_column_table_name16(sqlite3_stmt*,int); const char *sqlite3_column_origin_name(sqlite3_stmt*,int); const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); /* ** CAPI3REF: Declared Datatype Of A Query Result {F13760} ** ** The first parameter is a [sqlite3_stmt | compiled SQL statement]. ** {F13761} If this statement is a SELECT statement and the Nth column of the ** returned result set of that SELECT is a table column (not an ** expression or subquery) then the declared type of the table ** column is returned. {F13762} If the Nth column of the result set is an ** expression or subquery, then a NULL pointer is returned. ** {F13763} The returned string is always UTF-8 encoded. {END} ** For example, in the database schema: ** ** CREATE TABLE t1(c1 VARIANT); ** ** And the following statement compiled: ** ** SELECT c1 + 1, c1 FROM t1; ** |
︙ | ︙ | |||
1939 1940 1941 1942 1943 1944 1945 | ** is associated with individual values, not with the containers ** used to hold those values. */ const char *sqlite3_column_decltype(sqlite3_stmt *, int i); const void *sqlite3_column_decltype16(sqlite3_stmt*,int); /* | | | 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 | ** is associated with individual values, not with the containers ** used to hold those values. */ const char *sqlite3_column_decltype(sqlite3_stmt *, int i); const void *sqlite3_column_decltype16(sqlite3_stmt*,int); /* ** CAPI3REF: Evaluate An SQL Statement {F13200} ** ** After an [sqlite3_stmt | SQL statement] has been prepared with a call ** to either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or to one of ** the legacy interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], ** then this function must be called one or more times to evaluate the ** statement. ** |
︙ | ︙ | |||
2011 2012 2013 2014 2015 2016 2017 | ** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()], then the ** more specific [SQLITE_ERROR | result codes] are returned directly ** by sqlite3_step(). The use of the "v2" interface is recommended. */ int sqlite3_step(sqlite3_stmt*); /* | | | > > | | | | | 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 | ** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()], then the ** more specific [SQLITE_ERROR | result codes] are returned directly ** by sqlite3_step(). The use of the "v2" interface is recommended. */ int sqlite3_step(sqlite3_stmt*); /* ** CAPI3REF: Number of columns in a result set {F13770} ** ** Return the number of values in the current row of the result set. ** ** {F13771} After a call to [sqlite3_step()] that returns [SQLITE_ROW], ** this routine ** will return the same value as the [sqlite3_column_count()] function. ** {F13772} ** After [sqlite3_step()] has returned an [SQLITE_DONE], [SQLITE_BUSY], or ** a [SQLITE_ERROR | error code], or before [sqlite3_step()] has been ** called on the [sqlite3_stmt | prepared statement] for the first time, ** this routine returns zero. */ int sqlite3_data_count(sqlite3_stmt *pStmt); /* ** CAPI3REF: Fundamental Datatypes {F10260} ** ** {F10261}Every value in SQLite has one of five fundamental datatypes: ** ** <ul> ** <li> 64-bit signed integer ** <li> 64-bit IEEE floating point number ** <li> string ** <li> BLOB ** <li> NULL ** </ul> {END} ** ** These constants are codes for each of those types. ** ** Note that the SQLITE_TEXT constant was also used in SQLite version 2 ** for a completely different meaning. Software that links against both ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT not ** SQLITE_TEXT. */ #define SQLITE_INTEGER 1 #define SQLITE_FLOAT 2 #define SQLITE_BLOB 4 #define SQLITE_NULL 5 #ifdef SQLITE_TEXT # undef SQLITE_TEXT #else # define SQLITE_TEXT 3 #endif #define SQLITE3_TEXT 3 /* ** CAPI3REF: Results Values From A Query {F13800} ** ** These routines return information about ** a single column of the current result row of a query. In every ** case the first argument is a pointer to the ** [sqlite3_stmt | SQL statement] that is being ** evaluated (the [sqlite3_stmt*] that was returned from ** [sqlite3_prepare_v2()] or one of its variants) and |
︙ | ︙ | |||
2212 2213 2214 2215 2216 2217 2218 | sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); int sqlite3_column_type(sqlite3_stmt*, int iCol); sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); /* | | | | | 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 | sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); int sqlite3_column_type(sqlite3_stmt*, int iCol); sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); /* ** CAPI3REF: Destroy A Prepared Statement Object {F13300} ** ** The sqlite3_finalize() function is called to delete a ** [sqlite3_stmt | compiled SQL statement]. If the statement was ** executed successfully, or not executed at all, then SQLITE_OK is returned. ** If execution of the statement failed then an ** [SQLITE_ERROR | error code] or [SQLITE_IOERR_READ | extended error code] ** is returned. ** ** This routine can be called at any point during the execution of the ** [sqlite3_stmt | virtual machine]. If the virtual machine has not ** completed execution when this routine is called, that is like ** encountering an error or an interrupt. (See [sqlite3_interrupt()].) ** Incomplete updates may be rolled back and transactions cancelled, ** depending on the circumstances, and the ** [SQLITE_ERROR | result code] returned will be [SQLITE_ABORT]. */ int sqlite3_finalize(sqlite3_stmt *pStmt); /* ** CAPI3REF: Reset A Prepared Statement Object {F13330} ** ** The sqlite3_reset() function is called to reset a ** [sqlite3_stmt | compiled SQL statement] object. ** back to it's initial state, ready to be re-executed. ** Any SQL statement variables that had values bound to them using ** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values. ** Use [sqlite3_clear_bindings()] to reset the bindings. */ int sqlite3_reset(sqlite3_stmt *pStmt); /* ** CAPI3REF: Create Or Redefine SQL Functions {F16100} ** ** The following two functions are used to add SQL functions or aggregates ** or to redefine the behavior of existing SQL functions or aggregates. The ** difference only between the two is that the second parameter, the ** name of the (scalar) function or aggregate, is encoded in UTF-8 for ** sqlite3_create_function() and UTF-16 for sqlite3_create_function16(). ** |
︙ | ︙ | |||
2323 2324 2325 2326 2327 2328 2329 | void*, void (*xFunc)(sqlite3_context*,int,sqlite3_value**), void (*xStep)(sqlite3_context*,int,sqlite3_value**), void (*xFinal)(sqlite3_context*) ); /* | | | 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 | void*, void (*xFunc)(sqlite3_context*,int,sqlite3_value**), void (*xStep)(sqlite3_context*,int,sqlite3_value**), void (*xFinal)(sqlite3_context*) ); /* ** CAPI3REF: Text Encodings {F10260} ** ** These constant define integer codes that represent the various ** text encodings supported by SQLite. */ #define SQLITE_UTF8 1 #define SQLITE_UTF16LE 2 #define SQLITE_UTF16BE 3 |
︙ | ︙ | |||
2352 2353 2354 2355 2356 2357 2358 | int sqlite3_expired(sqlite3_stmt*); int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); int sqlite3_global_recover(void); void sqlite3_thread_cleanup(void); int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64); /* | | | 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 | int sqlite3_expired(sqlite3_stmt*); int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); int sqlite3_global_recover(void); void sqlite3_thread_cleanup(void); int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64); /* ** CAPI3REF: Obtaining SQL Function Parameter Values {F15100} ** ** The C-language implementation of SQL functions and aggregates uses ** this set of interface routines to access the parameter values on ** the function or aggregate. ** ** The xFunc (for scalar functions) or xStep (for aggregates) parameters ** to [sqlite3_create_function()] and [sqlite3_create_function16()] |
︙ | ︙ | |||
2410 2411 2412 2413 2414 2415 2416 | const void *sqlite3_value_text16(sqlite3_value*); const void *sqlite3_value_text16le(sqlite3_value*); const void *sqlite3_value_text16be(sqlite3_value*); int sqlite3_value_type(sqlite3_value*); int sqlite3_value_numeric_type(sqlite3_value*); /* | | | 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 | const void *sqlite3_value_text16(sqlite3_value*); const void *sqlite3_value_text16le(sqlite3_value*); const void *sqlite3_value_text16be(sqlite3_value*); int sqlite3_value_type(sqlite3_value*); int sqlite3_value_numeric_type(sqlite3_value*); /* ** CAPI3REF: Obtain Aggregate Function Context {F16210} ** ** The implementation of aggregate SQL functions use this routine to allocate ** a structure for storing their state. The first time this routine ** is called for a particular aggregate, a new structure of size nBytes ** is allocated, zeroed, and returned. On subsequent calls (for the ** same aggregate instance) the same buffer is returned. The implementation ** of the aggregate can use the returned buffer to accumulate data. |
︙ | ︙ | |||
2433 2434 2435 2436 2437 2438 2439 | ** ** This routine must be called from the same thread in which ** the aggregate SQL function is running. */ void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); /* | | | | 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 | ** ** This routine must be called from the same thread in which ** the aggregate SQL function is running. */ void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); /* ** CAPI3REF: User Data For Functions {F16240} ** ** The pUserData parameter to the [sqlite3_create_function()] ** and [sqlite3_create_function16()] routines ** used to register user functions is available to ** the implementation of the function using this call. ** ** This routine must be called from the same thread in which ** the SQL function is running. */ void *sqlite3_user_data(sqlite3_context*); /* ** CAPI3REF: Function Auxiliary Data {F16270} ** ** The following two functions may be used by scalar SQL functions to ** associate meta-data with argument values. If the same value is passed to ** multiple invocations of the same SQL function during query execution, under ** some circumstances the associated meta-data may be preserved. This may ** be used, for example, to add a regular-expression matching scalar ** function. The compiled version of the regular expression is stored as |
︙ | ︙ | |||
2483 2484 2485 2486 2487 2488 2489 | ** the SQL function is running. */ void *sqlite3_get_auxdata(sqlite3_context*, int); void sqlite3_set_auxdata(sqlite3_context*, int, void*, void (*)(void*)); /* | | | | 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 | ** the SQL function is running. */ void *sqlite3_get_auxdata(sqlite3_context*, int); void sqlite3_set_auxdata(sqlite3_context*, int, void*, void (*)(void*)); /* ** CAPI3REF: Constants Defining Special Destructor Behavior {F10280} ** ** These are special value for the destructor that is passed in as the ** final argument to routines like [sqlite3_result_blob()]. If the destructor ** argument is SQLITE_STATIC, it means that the content pointer is constant ** and will never change. It does not need to be destroyed. The ** SQLITE_TRANSIENT value means that the content will likely change in ** the near future and that SQLite should make its own private copy of ** the content before returning. ** ** The typedef is necessary to work around problems in certain ** C++ compilers. See ticket #2191. */ typedef void (*sqlite3_destructor_type)(void*); #define SQLITE_STATIC ((sqlite3_destructor_type)0) #define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) /* ** CAPI3REF: Setting The Result Of An SQL Function {F16400} ** ** These routines are used by the xFunc or xFinal callbacks that ** implement SQL functions and aggregates. See ** [sqlite3_create_function()] and [sqlite3_create_function16()] ** for additional information. ** ** These functions work very much like the |
︙ | ︙ | |||
2544 2545 2546 2547 2548 2549 2550 | void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); void sqlite3_result_value(sqlite3_context*, sqlite3_value*); void sqlite3_result_zeroblob(sqlite3_context*, int n); /* | | | 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 | void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); void sqlite3_result_value(sqlite3_context*, sqlite3_value*); void sqlite3_result_zeroblob(sqlite3_context*, int n); /* ** CAPI3REF: Define New Collating Sequences {F16600} ** ** These functions are used to add new collation sequences to the ** [sqlite3*] handle specified as the first argument. ** ** The name of the new collation sequence is specified as a UTF-8 string ** for sqlite3_create_collation() and sqlite3_create_collation_v2() ** and a UTF-16 string for sqlite3_create_collation16(). In all cases |
︙ | ︙ | |||
2612 2613 2614 2615 2616 2617 2618 | const char *zName, int eTextRep, void*, int(*xCompare)(void*,int,const void*,int,const void*) ); /* | | | 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 | const char *zName, int eTextRep, void*, int(*xCompare)(void*,int,const void*,int,const void*) ); /* ** CAPI3REF: Collation Needed Callbacks {F16700} ** ** To avoid having to register all collation sequences before a database ** can be used, a single callback function may be registered with the ** database handle to be called whenever an undefined collation sequence is ** required. ** ** If the function is registered using the sqlite3_collation_needed() API, |
︙ | ︙ | |||
2674 2675 2676 2677 2678 2679 2680 | */ int sqlite3_rekey( sqlite3 *db, /* Database to be rekeyed */ const void *pKey, int nKey /* The new key */ ); /* | | | | | | | | 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 | */ int sqlite3_rekey( sqlite3 *db, /* Database to be rekeyed */ const void *pKey, int nKey /* The new key */ ); /* ** CAPI3REF: Suspend Execution For A Short Time {F10530} ** ** This function causes the current thread to suspend execution ** for at least a number of milliseconds specified in its parameter. ** ** If the operating system does not support sleep requests with ** millisecond time resolution, then the time will be rounded up to ** the nearest second. The number of milliseconds of sleep actually ** requested from the operating system is returned. ** ** SQLite implements this interface by calling the xSleep() ** method of the default [sqlite3_vfs] object. */ int sqlite3_sleep(int); /* ** CAPI3REF: Name Of The Folder Holding Temporary Files {F10310} ** ** If this global variable is made to point to a string which is ** the name of a folder (a.ka. directory), then all temporary files ** created by SQLite will be placed in that directory. If this variable ** is NULL pointer, then SQLite does a search for an appropriate temporary ** file directory. ** ** It is not safe to modify this variable once a database connection ** has been opened. It is intended that this variable be set once ** as part of process initialization and before any SQLite interface ** routines have been call and remain unchanged thereafter. */ SQLITE_EXTERN char *sqlite3_temp_directory; /* ** CAPI3REF: Test To See If The Database Is In Auto-Commit Mode {F12930} ** ** Test to see whether or not the database connection is in autocommit ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on ** by default. Autocommit is disabled by a BEGIN statement and reenabled ** by the next COMMIT or ROLLBACK. ** ** If certain kinds of errors occur on a statement within a multi-statement ** transactions (errors including [SQLITE_FULL], [SQLITE_IOERR], ** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the ** transaction might be rolled back automatically. The only way to ** find out if SQLite automatically rolled back the transaction after ** an error is to use this function. ** ** If another thread changes the autocommit status of the database ** connection while this routine is running, then the return value ** is undefined. */ int sqlite3_get_autocommit(sqlite3*); /* ** CAPI3REF: Find The Database Handle Of A Prepared Statement {F13120} ** ** Return the [sqlite3*] database handle to which a ** [sqlite3_stmt | prepared statement] belongs. ** This is the same database handle that was ** the first argument to the [sqlite3_prepare_v2()] or its variants ** that was used to create the statement in the first place. */ sqlite3 *sqlite3_db_handle(sqlite3_stmt*); /* ** CAPI3REF: Commit And Rollback Notification Callbacks {F12950} ** ** These routines ** register callback functions to be invoked whenever a transaction ** is committed or rolled back. The pArg argument is passed through ** to the callback. If the callback on a commit hook function ** returns non-zero, then the commit is converted into a rollback. ** |
︙ | ︙ | |||
2764 2765 2766 2767 2768 2769 2770 | ** ** These are experimental interfaces and are subject to change. */ void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); /* | | | 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 | ** ** These are experimental interfaces and are subject to change. */ void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); /* ** CAPI3REF: Data Change Notification Callbacks {F12970} ** ** Register a callback function with the database connection identified by the ** first argument to be invoked whenever a row is updated, inserted or deleted. ** Any callback set by a previous call to this function for the same ** database connection is overridden. ** ** The second argument is a pointer to the function to invoke when a |
︙ | ︙ | |||
2794 2795 2796 2797 2798 2799 2800 | void *sqlite3_update_hook( sqlite3*, void(*)(void *,int ,char const *,char const *,sqlite3_int64), void* ); /* | | | 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 | void *sqlite3_update_hook( sqlite3*, void(*)(void *,int ,char const *,char const *,sqlite3_int64), void* ); /* ** CAPI3REF: Enable Or Disable Shared Pager Cache {F10330} ** ** This routine enables or disables the sharing of the database cache ** and schema data structures between connections to the same database. ** Sharing is enabled if the argument is true and disabled if the argument ** is false. ** ** Beginning in SQLite version 3.5.0, cache sharing is enabled and disabled |
︙ | ︙ | |||
2825 2826 2827 2828 2829 2830 2831 | ** Shared cache is disabled by default. But this might change in ** future releases of SQLite. Applications that care about shared ** cache setting should set it explicitly. */ int sqlite3_enable_shared_cache(int); /* | | | | 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 | ** Shared cache is disabled by default. But this might change in ** future releases of SQLite. Applications that care about shared ** cache setting should set it explicitly. */ int sqlite3_enable_shared_cache(int); /* ** CAPI3REF: Attempt To Free Heap Memory {F17340} ** ** Attempt to free N bytes of heap memory by deallocating non-essential ** memory allocations held by the database library (example: memory ** used to cache database pages to improve performance). */ int sqlite3_release_memory(int); /* ** CAPI3REF: Impose A Limit On Heap Size {F17350} ** ** Place a "soft" limit on the amount of heap memory that may be allocated ** by SQLite. If an internal allocation is requested ** that would exceed the specified limit, [sqlite3_release_memory()] is ** invoked one or more times to free up some space before the allocation ** is made. ** |
︙ | ︙ | |||
2866 2867 2868 2869 2870 2871 2872 | ** is an upper bound on the total memory allocation for all threads. In ** version 3.5.0 there is no mechanism for limiting the heap usage for ** individual threads. */ void sqlite3_soft_heap_limit(int); /* | | | 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 | ** is an upper bound on the total memory allocation for all threads. In ** version 3.5.0 there is no mechanism for limiting the heap usage for ** individual threads. */ void sqlite3_soft_heap_limit(int); /* ** CAPI3REF: Extract Metadata About A Column Of A Table {F12850} ** ** This routine ** returns meta-data about a specific column of a specific database ** table accessible using the connection handle passed as the first function ** argument. ** ** The column is identified by the second, third and fourth parameters to |
︙ | ︙ | |||
2942 2943 2944 2945 2946 2947 2948 | char const **pzCollSeq, /* OUTPUT: Collation sequence name */ int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ int *pPrimaryKey, /* OUTPUT: True if column part of PK */ int *pAutoinc /* OUTPUT: True if column is auto-increment */ ); /* | | | 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 | char const **pzCollSeq, /* OUTPUT: Collation sequence name */ int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ int *pPrimaryKey, /* OUTPUT: True if column part of PK */ int *pAutoinc /* OUTPUT: True if column is auto-increment */ ); /* ** CAPI3REF: Load An Extension {F12600} ** ** Attempt to load an SQLite extension library contained in the file ** zFile. The entry point is zProc. zProc may be 0 in which case the ** name of the entry point defaults to "sqlite3_extension_init". ** ** Return [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong. ** |
︙ | ︙ | |||
2965 2966 2967 2968 2969 2970 2971 | sqlite3 *db, /* Load the extension into this database connection */ const char *zFile, /* Name of the shared library containing extension */ const char *zProc, /* Entry point. Derived from zFile if 0 */ char **pzErrMsg /* Put error message here if not 0 */ ); /* | | | | 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 | sqlite3 *db, /* Load the extension into this database connection */ const char *zFile, /* Name of the shared library containing extension */ const char *zProc, /* Entry point. Derived from zFile if 0 */ char **pzErrMsg /* Put error message here if not 0 */ ); /* ** CAPI3REF: Enable Or Disable Extension Loading {F12620} ** ** So as not to open security holes in older applications that are ** unprepared to deal with extension loading, and as a means of disabling ** extension loading while evaluating user-entered SQL, the following ** API is provided to turn the [sqlite3_load_extension()] mechanism on and ** off. It is off by default. See ticket #1863. ** ** Call this routine with onoff==1 to turn extension loading on ** and call it with onoff==0 to turn it back off again. */ int sqlite3_enable_load_extension(sqlite3 *db, int onoff); /* ** CAPI3REF: Make Arrangements To Automatically Load An Extension {F12640} ** ** Register an extension entry point that is automatically invoked ** whenever a new database connection is opened using ** [sqlite3_open()], [sqlite3_open16()], or [sqlite3_open_v2()]. ** ** This API can be invoked at program startup in order to register ** one or more statically linked extensions that will be available |
︙ | ︙ | |||
3007 3008 3009 3010 3011 3012 3013 | ** This interface is experimental and is subject to change or ** removal in future releases of SQLite. */ int sqlite3_auto_extension(void *xEntryPoint); /* | | | 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 | ** This interface is experimental and is subject to change or ** removal in future releases of SQLite. */ int sqlite3_auto_extension(void *xEntryPoint); /* ** CAPI3REF: Reset Automatic Extension Loading {F12660} ** ** Disable all previously registered automatic extensions. This ** routine undoes the effect of all prior [sqlite3_automatic_extension()] ** calls. ** ** This call disabled automatic extensions in all threads. ** |
︙ | ︙ | |||
3088 3089 3090 3091 3092 3093 3094 | ** results into the **Outputs** fields. ** ** The aConstraint[] array records WHERE clause constraints of the ** form: ** ** column OP expr ** | > | | 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 | ** results into the **Outputs** fields. ** ** The aConstraint[] array records WHERE clause constraints of the ** form: ** ** column OP expr ** ** Where OP is =, <, <=, >, or >=. ** The particular operator is stored ** in aConstraint[].op. The index of the column is stored in ** aConstraint[].iColumn. aConstraint[].usable is TRUE if the ** expr on the right-hand side can be evaluated (and thus the constraint ** is usable) and false if it cannot. ** ** The optimizer automatically inverts terms of the form "expr OP column" ** and makes other simplifications to the WHERE clause in an attempt to |
︙ | ︙ | |||
3257 3258 3259 3260 3261 3262 3263 | ** When the virtual-table mechanism stabilizes, we will declare the ** interface fixed, support it indefinitely, and remove this comment. ** ****** EXPERIMENTAL - subject to change without notice ************** */ /* | | | | 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 | ** When the virtual-table mechanism stabilizes, we will declare the ** interface fixed, support it indefinitely, and remove this comment. ** ****** EXPERIMENTAL - subject to change without notice ************** */ /* ** CAPI3REF: A Handle To An Open BLOB {F17800} ** ** An instance of the following opaque structure is used to ** represent an blob-handle. A blob-handle is created by ** [sqlite3_blob_open()] and destroyed by [sqlite3_blob_close()]. ** The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces ** can be used to read or write small subsections of the blob. ** The [sqlite3_blob_bytes()] interface returns the size of the ** blob in bytes. */ typedef struct sqlite3_blob sqlite3_blob; /* ** CAPI3REF: Open A BLOB For Incremental I/O {F17810} ** ** Open a handle to the blob located in row iRow,, column zColumn, ** table zTable in database zDb. i.e. the same blob that would ** be selected by: ** ** <pre> ** SELECT zColumn FROM zDb.zTable WHERE rowid = iRow; |
︙ | ︙ | |||
3302 3303 3304 3305 3306 3307 3308 | const char *zColumn, sqlite3_int64 iRow, int flags, sqlite3_blob **ppBlob ); /* | | | | | | | 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 | const char *zColumn, sqlite3_int64 iRow, int flags, sqlite3_blob **ppBlob ); /* ** CAPI3REF: Close A BLOB Handle {F17830} ** ** Close an open [sqlite3_blob | blob handle]. ** ** Closing a BLOB might cause the current transaction to commit. ** If any writes were made to the BLOB, they might be held in cache ** until the close operation. Closing the BLOB forces the changes ** out to disk and so if any I/O errors occur, they will likely occur ** at the time when the BLOB is closed. Any errors that occur during ** closing are reported as a non-zero return value. ** ** The BLOB is closed unconditionally. Even if this routine returns ** an error code, the BLOB is still closed. */ int sqlite3_blob_close(sqlite3_blob *); /* ** CAPI3REF: Return The Size Of An Open BLOB {F17805} ** ** {F16806} Return the size in bytes of the blob accessible via the open ** [sqlite3_blob | blob-handle] passed as an argument. */ int sqlite3_blob_bytes(sqlite3_blob *); /* ** CAPI3REF: Read Data From A BLOB Incrementally {F17850} ** ** This function is used to read data from an open ** [sqlite3_blob | blob-handle] into a caller supplied buffer. ** n bytes of data are copied into buffer ** z from the open blob, starting at offset iOffset. ** ** On success, SQLITE_OK is returned. Otherwise, an ** [SQLITE_ERROR | SQLite error code] or an ** [SQLITE_IOERR_READ | extended error code] is returned. */ int sqlite3_blob_read(sqlite3_blob *, void *z, int n, int iOffset); /* ** CAPI3REF: Write Data Into A BLOB Incrementally {F17870} ** ** This function is used to write data into an open ** [sqlite3_blob | blob-handle] from a user supplied buffer. ** n bytes of data are copied from the buffer ** pointed to by z into the open blob, starting at offset iOffset. ** ** If the [sqlite3_blob | blob-handle] passed as the first argument |
︙ | ︙ | |||
3364 3365 3366 3367 3368 3369 3370 | ** On success, SQLITE_OK is returned. Otherwise, an ** [SQLITE_ERROR | SQLite error code] or an ** [SQLITE_IOERR_READ | extended error code] is returned. */ int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); /* | | | 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 | ** On success, SQLITE_OK is returned. Otherwise, an ** [SQLITE_ERROR | SQLite error code] or an ** [SQLITE_IOERR_READ | extended error code] is returned. */ int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset); /* ** CAPI3REF: Virtual File System Objects {F11200} ** ** A virtual filesystem (VFS) is an [sqlite3_vfs] object ** that SQLite uses to interact ** with the underlying operating system. Most builds come with a ** single default VFS that is appropriate for the host computer. ** New VFSes can be registered and existing VFSes can be unregistered. ** The following interfaces are provided. |
︙ | ︙ | |||
3396 3397 3398 3399 3400 3401 3402 | ** the default. The choice for the new VFS is arbitrary. */ sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); int sqlite3_vfs_unregister(sqlite3_vfs*); /* | | | 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 | ** the default. The choice for the new VFS is arbitrary. */ sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName); int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt); int sqlite3_vfs_unregister(sqlite3_vfs*); /* ** CAPI3REF: Mutexes {F17000} ** ** The SQLite core uses these routines for thread ** synchronization. Though they are intended for internal ** use by SQLite, code that links against SQLite is ** permitted to use any of these routines. ** ** The SQLite source code contains multiple implementations |
︙ | ︙ | |||
3508 3509 3510 3511 3512 3513 3514 | sqlite3_mutex *sqlite3_mutex_alloc(int); void sqlite3_mutex_free(sqlite3_mutex*); void sqlite3_mutex_enter(sqlite3_mutex*); int sqlite3_mutex_try(sqlite3_mutex*); void sqlite3_mutex_leave(sqlite3_mutex*); /* | | | | | | | | | | | | | | | | | | | | | | | | | | | 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 | sqlite3_mutex *sqlite3_mutex_alloc(int); void sqlite3_mutex_free(sqlite3_mutex*); void sqlite3_mutex_enter(sqlite3_mutex*); int sqlite3_mutex_try(sqlite3_mutex*); void sqlite3_mutex_leave(sqlite3_mutex*); /* ** CAPI3REF: Mutex Verifcation Routines {F17080} ** ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines ** are intended for use inside assert() statements. {F17081} The SQLite core ** never uses these routines except inside an assert() and applications ** are advised to follow the lead of the core. {F17082} The core only ** provides implementations for these routines when it is compiled ** with the SQLITE_DEBUG flag. {U17083} External mutex implementations ** are only required to provide these routines if SQLITE_DEBUG is ** defined and if NDEBUG is not defined. ** ** {F17083} These routines should return true if the mutex in their argument ** is held or not held, respectively, by the calling thread. {END} ** ** {X17084} The implementation is not required to provided versions of these ** routines that actually work. ** If the implementation does not provide working ** versions of these routines, it should at least provide stubs ** that always return true so that one does not get spurious ** assertion failures. {END} ** ** {F17085} If the argument to sqlite3_mutex_held() is a NULL pointer then ** the routine should return 1. {END} This seems counter-intuitive since ** clearly the mutex cannot be held if it does not exist. But the ** the reason the mutex does not exist is because the build is not ** using mutexes. And we do not want the assert() containing the ** call to sqlite3_mutex_held() to fail, so a non-zero return is ** the appropriate thing to do. {F17086} The sqlite3_mutex_notheld() ** interface should also return 1 when given a NULL pointer. */ int sqlite3_mutex_held(sqlite3_mutex*); int sqlite3_mutex_notheld(sqlite3_mutex*); /* ** CAPI3REF: Mutex Types {F17001} ** ** {F17002} The [sqlite3_mutex_alloc()] interface takes a single argument ** which is one of these integer constants. {END} */ #define SQLITE_MUTEX_FAST 0 #define SQLITE_MUTEX_RECURSIVE 1 #define SQLITE_MUTEX_STATIC_MASTER 2 #define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */ #define SQLITE_MUTEX_STATIC_MEM2 4 /* sqlite3_release_memory() */ #define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */ #define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */ /* ** CAPI3REF: Low-Level Control Of Database Files {F11300} ** ** {F11301} The [sqlite3_file_control()] interface makes a direct call to the ** xFileControl method for the [sqlite3_io_methods] object associated ** with a particular database identified by the second argument. {F11302} The ** name of the database is the name assigned to the database by the ** <a href="lang_attach.html">ATTACH</a> SQL command that opened the ** database. {F11303} To control the main database file, use the name "main" ** or a NULL pointer. {F11304} The third and fourth parameters to this routine ** are passed directly through to the second and third parameters of ** the xFileControl method. {F11305} The return value of the xFileControl ** method becomes the return value of this routine. ** ** {F11306} If the second parameter (zDbName) does not match the name of any ** open database file, then SQLITE_ERROR is returned. {F11307} This error ** code is not remembered and will not be recalled by [sqlite3_errcode()] ** or [sqlite3_errmsg()]. {U11307} The underlying xFileControl method might ** also return SQLITE_ERROR. {U11308} There is no way to distinguish between ** an incorrect zDbName and an SQLITE_ERROR return from the underlying ** xFileControl method. {END} ** ** See also: [SQLITE_FCNTL_LOCKSTATE] */ int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*); /* ** Undo the hack that converts floating point types to integer for |
︙ | ︙ |