1: /******************************************************************************
2: ** This file is an amalgamation of many separate C source files from SQLite
3: ** version 3.7.10. By combining all the individual C code files into this
4: ** single large file, the entire code can be compiled as a single translation
5: ** unit. This allows many compilers to do optimizations that would not be
6: ** possible if the files were compiled separately. Performance improvements
7: ** of 5% or more are commonly seen when SQLite is compiled as a single
8: ** translation unit.
9: **
10: ** This file is all you need to compile SQLite. To use SQLite in other
11: ** programs, you need this file and the "sqlite3.h" header file that defines
12: ** the programming interface to the SQLite library. (If you do not have
13: ** the "sqlite3.h" header file at hand, you will find a copy embedded within
14: ** the text of this file. Search for "Begin file sqlite3.h" to find the start
15: ** of the embedded sqlite3.h header file.) Additional code files may be needed
16: ** if you want a wrapper to interface SQLite with your choice of programming
17: ** language. The code for the "sqlite3" command-line shell is also in a
18: ** separate file. This file contains only code for the core SQLite library.
19: */
20: #define SQLITE_CORE 1
21: #define SQLITE_AMALGAMATION 1
22: #ifndef SQLITE_PRIVATE
23: # define SQLITE_PRIVATE static
24: #endif
25: #ifndef SQLITE_API
26: # define SQLITE_API
27: #endif
28: /************** Begin file sqliteInt.h ***************************************/
29: /*
30: ** 2001 September 15
31: **
32: ** The author disclaims copyright to this source code. In place of
33: ** a legal notice, here is a blessing:
34: **
35: ** May you do good and not evil.
36: ** May you find forgiveness for yourself and forgive others.
37: ** May you share freely, never taking more than you give.
38: **
39: *************************************************************************
40: ** Internal interface definitions for SQLite.
41: **
42: */
43: #ifndef _SQLITEINT_H_
44: #define _SQLITEINT_H_
45:
46: /*
47: ** These #defines should enable >2GB file support on POSIX if the
48: ** underlying operating system supports it. If the OS lacks
49: ** large file support, or if the OS is windows, these should be no-ops.
50: **
51: ** Ticket #2739: The _LARGEFILE_SOURCE macro must appear before any
52: ** system #includes. Hence, this block of code must be the very first
53: ** code in all source files.
54: **
55: ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
56: ** on the compiler command line. This is necessary if you are compiling
57: ** on a recent machine (ex: Red Hat 7.2) but you want your code to work
58: ** on an older machine (ex: Red Hat 6.0). If you compile on Red Hat 7.2
59: ** without this option, LFS is enable. But LFS does not exist in the kernel
60: ** in Red Hat 6.0, so the code won't work. Hence, for maximum binary
61: ** portability you should omit LFS.
62: **
63: ** Similar is true for Mac OS X. LFS is only supported on Mac OS X 9 and later.
64: */
65: #ifndef SQLITE_DISABLE_LFS
66: # define _LARGE_FILE 1
67: # ifndef _FILE_OFFSET_BITS
68: # define _FILE_OFFSET_BITS 64
69: # endif
70: # define _LARGEFILE_SOURCE 1
71: #endif
72:
73: /*
74: ** Include the configuration header output by 'configure' if we're using the
75: ** autoconf-based build
76: */
77: #ifdef _HAVE_SQLITE_CONFIG_H
78: #include "config.h"
79: #endif
80:
81: /************** Include sqliteLimit.h in the middle of sqliteInt.h ***********/
82: /************** Begin file sqliteLimit.h *************************************/
83: /*
84: ** 2007 May 7
85: **
86: ** The author disclaims copyright to this source code. In place of
87: ** a legal notice, here is a blessing:
88: **
89: ** May you do good and not evil.
90: ** May you find forgiveness for yourself and forgive others.
91: ** May you share freely, never taking more than you give.
92: **
93: *************************************************************************
94: **
95: ** This file defines various limits of what SQLite can process.
96: */
97:
98: /*
99: ** The maximum length of a TEXT or BLOB in bytes. This also
100: ** limits the size of a row in a table or index.
101: **
102: ** The hard limit is the ability of a 32-bit signed integer
103: ** to count the size: 2^31-1 or 2147483647.
104: */
105: #ifndef SQLITE_MAX_LENGTH
106: # define SQLITE_MAX_LENGTH 1000000000
107: #endif
108:
109: /*
110: ** This is the maximum number of
111: **
112: ** * Columns in a table
113: ** * Columns in an index
114: ** * Columns in a view
115: ** * Terms in the SET clause of an UPDATE statement
116: ** * Terms in the result set of a SELECT statement
117: ** * Terms in the GROUP BY or ORDER BY clauses of a SELECT statement.
118: ** * Terms in the VALUES clause of an INSERT statement
119: **
120: ** The hard upper limit here is 32676. Most database people will
121: ** tell you that in a well-normalized database, you usually should
122: ** not have more than a dozen or so columns in any table. And if
123: ** that is the case, there is no point in having more than a few
124: ** dozen values in any of the other situations described above.
125: */
126: #ifndef SQLITE_MAX_COLUMN
127: # define SQLITE_MAX_COLUMN 2000
128: #endif
129:
130: /*
131: ** The maximum length of a single SQL statement in bytes.
132: **
133: ** It used to be the case that setting this value to zero would
134: ** turn the limit off. That is no longer true. It is not possible
135: ** to turn this limit off.
136: */
137: #ifndef SQLITE_MAX_SQL_LENGTH
138: # define SQLITE_MAX_SQL_LENGTH 1000000000
139: #endif
140:
141: /*
142: ** The maximum depth of an expression tree. This is limited to
143: ** some extent by SQLITE_MAX_SQL_LENGTH. But sometime you might
144: ** want to place more severe limits on the complexity of an
145: ** expression.
146: **
147: ** A value of 0 used to mean that the limit was not enforced.
148: ** But that is no longer true. The limit is now strictly enforced
149: ** at all times.
150: */
151: #ifndef SQLITE_MAX_EXPR_DEPTH
152: # define SQLITE_MAX_EXPR_DEPTH 1000
153: #endif
154:
155: /*
156: ** The maximum number of terms in a compound SELECT statement.
157: ** The code generator for compound SELECT statements does one
158: ** level of recursion for each term. A stack overflow can result
159: ** if the number of terms is too large. In practice, most SQL
160: ** never has more than 3 or 4 terms. Use a value of 0 to disable
161: ** any limit on the number of terms in a compount SELECT.
162: */
163: #ifndef SQLITE_MAX_COMPOUND_SELECT
164: # define SQLITE_MAX_COMPOUND_SELECT 500
165: #endif
166:
167: /*
168: ** The maximum number of opcodes in a VDBE program.
169: ** Not currently enforced.
170: */
171: #ifndef SQLITE_MAX_VDBE_OP
172: # define SQLITE_MAX_VDBE_OP 25000
173: #endif
174:
175: /*
176: ** The maximum number of arguments to an SQL function.
177: */
178: #ifndef SQLITE_MAX_FUNCTION_ARG
179: # define SQLITE_MAX_FUNCTION_ARG 127
180: #endif
181:
182: /*
183: ** The maximum number of in-memory pages to use for the main database
184: ** table and for temporary tables. The SQLITE_DEFAULT_CACHE_SIZE
185: */
186: #ifndef SQLITE_DEFAULT_CACHE_SIZE
187: # define SQLITE_DEFAULT_CACHE_SIZE 2000
188: #endif
189: #ifndef SQLITE_DEFAULT_TEMP_CACHE_SIZE
190: # define SQLITE_DEFAULT_TEMP_CACHE_SIZE 500
191: #endif
192:
193: /*
194: ** The default number of frames to accumulate in the log file before
195: ** checkpointing the database in WAL mode.
196: */
197: #ifndef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT
198: # define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000
199: #endif
200:
201: /*
202: ** The maximum number of attached databases. This must be between 0
203: ** and 62. The upper bound on 62 is because a 64-bit integer bitmap
204: ** is used internally to track attached databases.
205: */
206: #ifndef SQLITE_MAX_ATTACHED
207: # define SQLITE_MAX_ATTACHED 10
208: #endif
209:
210:
211: /*
212: ** The maximum value of a ?nnn wildcard that the parser will accept.
213: */
214: #ifndef SQLITE_MAX_VARIABLE_NUMBER
215: # define SQLITE_MAX_VARIABLE_NUMBER 999
216: #endif
217:
218: /* Maximum page size. The upper bound on this value is 65536. This a limit
219: ** imposed by the use of 16-bit offsets within each page.
220: **
221: ** Earlier versions of SQLite allowed the user to change this value at
222: ** compile time. This is no longer permitted, on the grounds that it creates
223: ** a library that is technically incompatible with an SQLite library
224: ** compiled with a different limit. If a process operating on a database
225: ** with a page-size of 65536 bytes crashes, then an instance of SQLite
226: ** compiled with the default page-size limit will not be able to rollback
227: ** the aborted transaction. This could lead to database corruption.
228: */
229: #ifdef SQLITE_MAX_PAGE_SIZE
230: # undef SQLITE_MAX_PAGE_SIZE
231: #endif
232: #define SQLITE_MAX_PAGE_SIZE 65536
233:
234:
235: /*
236: ** The default size of a database page.
237: */
238: #ifndef SQLITE_DEFAULT_PAGE_SIZE
239: # define SQLITE_DEFAULT_PAGE_SIZE 1024
240: #endif
241: #if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
242: # undef SQLITE_DEFAULT_PAGE_SIZE
243: # define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
244: #endif
245:
246: /*
247: ** Ordinarily, if no value is explicitly provided, SQLite creates databases
248: ** with page size SQLITE_DEFAULT_PAGE_SIZE. However, based on certain
249: ** device characteristics (sector-size and atomic write() support),
250: ** SQLite may choose a larger value. This constant is the maximum value
251: ** SQLite will choose on its own.
252: */
253: #ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE
254: # define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192
255: #endif
256: #if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE
257: # undef SQLITE_MAX_DEFAULT_PAGE_SIZE
258: # define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE
259: #endif
260:
261:
262: /*
263: ** Maximum number of pages in one database file.
264: **
265: ** This is really just the default value for the max_page_count pragma.
266: ** This value can be lowered (or raised) at run-time using that the
267: ** max_page_count macro.
268: */
269: #ifndef SQLITE_MAX_PAGE_COUNT
270: # define SQLITE_MAX_PAGE_COUNT 1073741823
271: #endif
272:
273: /*
274: ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
275: ** operator.
276: */
277: #ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
278: # define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
279: #endif
280:
281: /*
282: ** Maximum depth of recursion for triggers.
283: **
284: ** A value of 1 means that a trigger program will not be able to itself
285: ** fire any triggers. A value of 0 means that no trigger programs at all
286: ** may be executed.
287: */
288: #ifndef SQLITE_MAX_TRIGGER_DEPTH
289: # define SQLITE_MAX_TRIGGER_DEPTH 1000
290: #endif
291:
292: /************** End of sqliteLimit.h *****************************************/
293: /************** Continuing where we left off in sqliteInt.h ******************/
294:
295: /* Disable nuisance warnings on Borland compilers */
296: #if defined(__BORLANDC__)
297: #pragma warn -rch /* unreachable code */
298: #pragma warn -ccc /* Condition is always true or false */
299: #pragma warn -aus /* Assigned value is never used */
300: #pragma warn -csu /* Comparing signed and unsigned */
301: #pragma warn -spa /* Suspicious pointer arithmetic */
302: #endif
303:
304: /* Needed for various definitions... */
305: #ifndef _GNU_SOURCE
306: # define _GNU_SOURCE
307: #endif
308:
309: /*
310: ** Include standard header files as necessary
311: */
312: #ifdef HAVE_STDINT_H
313: #include <stdint.h>
314: #endif
315: #ifdef HAVE_INTTYPES_H
316: #include <inttypes.h>
317: #endif
318:
319: /*
320: ** The following macros are used to cast pointers to integers and
321: ** integers to pointers. The way you do this varies from one compiler
322: ** to the next, so we have developed the following set of #if statements
323: ** to generate appropriate macros for a wide range of compilers.
324: **
325: ** The correct "ANSI" way to do this is to use the intptr_t type.
326: ** Unfortunately, that typedef is not available on all compilers, or
327: ** if it is available, it requires an #include of specific headers
328: ** that vary from one machine to the next.
329: **
330: ** Ticket #3860: The llvm-gcc-4.2 compiler from Apple chokes on
331: ** the ((void*)&((char*)0)[X]) construct. But MSVC chokes on ((void*)(X)).
332: ** So we have to define the macros in different ways depending on the
333: ** compiler.
334: */
335: #if defined(__PTRDIFF_TYPE__) /* This case should work for GCC */
336: # define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X))
337: # define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X))
338: #elif !defined(__GNUC__) /* Works for compilers other than LLVM */
339: # define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X])
340: # define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0))
341: #elif defined(HAVE_STDINT_H) /* Use this case if we have ANSI headers */
342: # define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X))
343: # define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X))
344: #else /* Generates a warning - but it always works */
345: # define SQLITE_INT_TO_PTR(X) ((void*)(X))
346: # define SQLITE_PTR_TO_INT(X) ((int)(X))
347: #endif
348:
349: /*
350: ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
351: ** 0 means mutexes are permanently disable and the library is never
352: ** threadsafe. 1 means the library is serialized which is the highest
353: ** level of threadsafety. 2 means the libary is multithreaded - multiple
354: ** threads can use SQLite as long as no two threads try to use the same
355: ** database connection at the same time.
356: **
357: ** Older versions of SQLite used an optional THREADSAFE macro.
358: ** We support that for legacy.
359: */
360: #if !defined(SQLITE_THREADSAFE)
361: #if defined(THREADSAFE)
362: # define SQLITE_THREADSAFE THREADSAFE
363: #else
364: # define SQLITE_THREADSAFE 1 /* IMP: R-07272-22309 */
365: #endif
366: #endif
367:
368: /*
369: ** Powersafe overwrite is on by default. But can be turned off using
370: ** the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
371: */
372: #ifndef SQLITE_POWERSAFE_OVERWRITE
373: # define SQLITE_POWERSAFE_OVERWRITE 1
374: #endif
375:
376: /*
377: ** The SQLITE_DEFAULT_MEMSTATUS macro must be defined as either 0 or 1.
378: ** It determines whether or not the features related to
379: ** SQLITE_CONFIG_MEMSTATUS are available by default or not. This value can
380: ** be overridden at runtime using the sqlite3_config() API.
381: */
382: #if !defined(SQLITE_DEFAULT_MEMSTATUS)
383: # define SQLITE_DEFAULT_MEMSTATUS 1
384: #endif
385:
386: /*
387: ** Exactly one of the following macros must be defined in order to
388: ** specify which memory allocation subsystem to use.
389: **
390: ** SQLITE_SYSTEM_MALLOC // Use normal system malloc()
391: ** SQLITE_WIN32_MALLOC // Use Win32 native heap API
392: ** SQLITE_MEMDEBUG // Debugging version of system malloc()
393: **
394: ** On Windows, if the SQLITE_WIN32_MALLOC_VALIDATE macro is defined and the
395: ** assert() macro is enabled, each call into the Win32 native heap subsystem
396: ** will cause HeapValidate to be called. If heap validation should fail, an
397: ** assertion will be triggered.
398: **
399: ** (Historical note: There used to be several other options, but we've
400: ** pared it down to just these three.)
401: **
402: ** If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
403: ** the default.
404: */
405: #if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_WIN32_MALLOC)+defined(SQLITE_MEMDEBUG)>1
406: # error "At most one of the following compile-time configuration options\
407: is allows: SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG"
408: #endif
409: #if defined(SQLITE_SYSTEM_MALLOC)+defined(SQLITE_WIN32_MALLOC)+defined(SQLITE_MEMDEBUG)==0
410: # define SQLITE_SYSTEM_MALLOC 1
411: #endif
412:
413: /*
414: ** If SQLITE_MALLOC_SOFT_LIMIT is not zero, then try to keep the
415: ** sizes of memory allocations below this value where possible.
416: */
417: #if !defined(SQLITE_MALLOC_SOFT_LIMIT)
418: # define SQLITE_MALLOC_SOFT_LIMIT 1024
419: #endif
420:
421: /*
422: ** We need to define _XOPEN_SOURCE as follows in order to enable
423: ** recursive mutexes on most Unix systems. But Mac OS X is different.
424: ** The _XOPEN_SOURCE define causes problems for Mac OS X we are told,
425: ** so it is omitted there. See ticket #2673.
426: **
427: ** Later we learn that _XOPEN_SOURCE is poorly or incorrectly
428: ** implemented on some systems. So we avoid defining it at all
429: ** if it is already defined or if it is unneeded because we are
430: ** not doing a threadsafe build. Ticket #2681.
431: **
432: ** See also ticket #2741.
433: */
434: #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) && SQLITE_THREADSAFE
435: # define _XOPEN_SOURCE 500 /* Needed to enable pthread recursive mutexes */
436: #endif
437:
438: /*
439: ** The TCL headers are only needed when compiling the TCL bindings.
440: */
441: #if defined(SQLITE_TCL) || defined(TCLSH)
442: # include <tcl.h>
443: #endif
444:
445: /*
446: ** Many people are failing to set -DNDEBUG=1 when compiling SQLite.
447: ** Setting NDEBUG makes the code smaller and run faster. So the following
448: ** lines are added to automatically set NDEBUG unless the -DSQLITE_DEBUG=1
449: ** option is set. Thus NDEBUG becomes an opt-in rather than an opt-out
450: ** feature.
451: */
452: #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
453: # define NDEBUG 1
454: #endif
455:
456: /*
457: ** The testcase() macro is used to aid in coverage testing. When
458: ** doing coverage testing, the condition inside the argument to
459: ** testcase() must be evaluated both true and false in order to
460: ** get full branch coverage. The testcase() macro is inserted
461: ** to help ensure adequate test coverage in places where simple
462: ** condition/decision coverage is inadequate. For example, testcase()
463: ** can be used to make sure boundary values are tested. For
464: ** bitmask tests, testcase() can be used to make sure each bit
465: ** is significant and used at least once. On switch statements
466: ** where multiple cases go to the same block of code, testcase()
467: ** can insure that all cases are evaluated.
468: **
469: */
470: #ifdef SQLITE_COVERAGE_TEST
471: SQLITE_PRIVATE void sqlite3Coverage(int);
472: # define testcase(X) if( X ){ sqlite3Coverage(__LINE__); }
473: #else
474: # define testcase(X)
475: #endif
476:
477: /*
478: ** The TESTONLY macro is used to enclose variable declarations or
479: ** other bits of code that are needed to support the arguments
480: ** within testcase() and assert() macros.
481: */
482: #if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST)
483: # define TESTONLY(X) X
484: #else
485: # define TESTONLY(X)
486: #endif
487:
488: /*
489: ** Sometimes we need a small amount of code such as a variable initialization
490: ** to setup for a later assert() statement. We do not want this code to
491: ** appear when assert() is disabled. The following macro is therefore
492: ** used to contain that setup code. The "VVA" acronym stands for
493: ** "Verification, Validation, and Accreditation". In other words, the
494: ** code within VVA_ONLY() will only run during verification processes.
495: */
496: #ifndef NDEBUG
497: # define VVA_ONLY(X) X
498: #else
499: # define VVA_ONLY(X)
500: #endif
501:
502: /*
503: ** The ALWAYS and NEVER macros surround boolean expressions which
504: ** are intended to always be true or false, respectively. Such
505: ** expressions could be omitted from the code completely. But they
506: ** are included in a few cases in order to enhance the resilience
507: ** of SQLite to unexpected behavior - to make the code "self-healing"
508: ** or "ductile" rather than being "brittle" and crashing at the first
509: ** hint of unplanned behavior.
510: **
511: ** In other words, ALWAYS and NEVER are added for defensive code.
512: **
513: ** When doing coverage testing ALWAYS and NEVER are hard-coded to
514: ** be true and false so that the unreachable code then specify will
515: ** not be counted as untested code.
516: */
517: #if defined(SQLITE_COVERAGE_TEST)
518: # define ALWAYS(X) (1)
519: # define NEVER(X) (0)
520: #elif !defined(NDEBUG)
521: # define ALWAYS(X) ((X)?1:(assert(0),0))
522: # define NEVER(X) ((X)?(assert(0),1):0)
523: #else
524: # define ALWAYS(X) (X)
525: # define NEVER(X) (X)
526: #endif
527:
528: /*
529: ** Return true (non-zero) if the input is a integer that is too large
530: ** to fit in 32-bits. This macro is used inside of various testcase()
531: ** macros to verify that we have tested SQLite for large-file support.
532: */
533: #define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0)
534:
535: /*
536: ** The macro unlikely() is a hint that surrounds a boolean
537: ** expression that is usually false. Macro likely() surrounds
538: ** a boolean expression that is usually true. GCC is able to
539: ** use these hints to generate better code, sometimes.
540: */
541: #if defined(__GNUC__) && 0
542: # define likely(X) __builtin_expect((X),1)
543: # define unlikely(X) __builtin_expect((X),0)
544: #else
545: # define likely(X) !!(X)
546: # define unlikely(X) !!(X)
547: #endif
548:
549: /************** Include sqlite3.h in the middle of sqliteInt.h ***************/
550: /************** Begin file sqlite3.h *****************************************/
551: /*
552: ** 2001 September 15
553: **
554: ** The author disclaims copyright to this source code. In place of
555: ** a legal notice, here is a blessing:
556: **
557: ** May you do good and not evil.
558: ** May you find forgiveness for yourself and forgive others.
559: ** May you share freely, never taking more than you give.
560: **
561: *************************************************************************
562: ** This header file defines the interface that the SQLite library
563: ** presents to client programs. If a C-function, structure, datatype,
564: ** or constant definition does not appear in this file, then it is
565: ** not a published API of SQLite, is subject to change without
566: ** notice, and should not be referenced by programs that use SQLite.
567: **
568: ** Some of the definitions that are in this file are marked as
569: ** "experimental". Experimental interfaces are normally new
570: ** features recently added to SQLite. We do not anticipate changes
571: ** to experimental interfaces but reserve the right to make minor changes
572: ** if experience from use "in the wild" suggest such changes are prudent.
573: **
574: ** The official C-language API documentation for SQLite is derived
575: ** from comments in this file. This file is the authoritative source
576: ** on how SQLite interfaces are suppose to operate.
577: **
578: ** The name of this file under configuration management is "sqlite.h.in".
579: ** The makefile makes some minor changes to this file (such as inserting
580: ** the version number) and changes its name to "sqlite3.h" as
581: ** part of the build process.
582: */
583: #ifndef _SQLITE3_H_
584: #define _SQLITE3_H_
585: #include <stdarg.h> /* Needed for the definition of va_list */
586:
587: /*
588: ** Make sure we can call this stuff from C++.
589: */
590: #if 0
591: extern "C" {
592: #endif
593:
594:
595: /*
596: ** Add the ability to override 'extern'
597: */
598: #ifndef SQLITE_EXTERN
599: # define SQLITE_EXTERN extern
600: #endif
601:
602: #ifndef SQLITE_API
603: # define SQLITE_API
604: #endif
605:
606:
607: /*
608: ** These no-op macros are used in front of interfaces to mark those
609: ** interfaces as either deprecated or experimental. New applications
610: ** should not use deprecated interfaces - they are support for backwards
611: ** compatibility only. Application writers should be aware that
612: ** experimental interfaces are subject to change in point releases.
613: **
614: ** These macros used to resolve to various kinds of compiler magic that
615: ** would generate warning messages when they were used. But that
616: ** compiler magic ended up generating such a flurry of bug reports
617: ** that we have taken it all out and gone back to using simple
618: ** noop macros.
619: */
620: #define SQLITE_DEPRECATED
621: #define SQLITE_EXPERIMENTAL
622:
623: /*
624: ** Ensure these symbols were not defined by some previous header file.
625: */
626: #ifdef SQLITE_VERSION
627: # undef SQLITE_VERSION
628: #endif
629: #ifdef SQLITE_VERSION_NUMBER
630: # undef SQLITE_VERSION_NUMBER
631: #endif
632:
633: /*
634: ** CAPI3REF: Compile-Time Library Version Numbers
635: **
636: ** ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header
637: ** evaluates to a string literal that is the SQLite version in the
638: ** format "X.Y.Z" where X is the major version number (always 3 for
639: ** SQLite3) and Y is the minor version number and Z is the release number.)^
640: ** ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer
641: ** with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
642: ** numbers used in [SQLITE_VERSION].)^
643: ** The SQLITE_VERSION_NUMBER for any given release of SQLite will also
644: ** be larger than the release from which it is derived. Either Y will
645: ** be held constant and Z will be incremented or else Y will be incremented
646: ** and Z will be reset to zero.
647: **
648: ** Since version 3.6.18, SQLite source code has been stored in the
649: ** <a href="http://www.fossil-scm.org/">Fossil configuration management
650: ** system</a>. ^The SQLITE_SOURCE_ID macro evaluates to
651: ** a string which identifies a particular check-in of SQLite
652: ** within its configuration management system. ^The SQLITE_SOURCE_ID
653: ** string contains the date and time of the check-in (UTC) and an SHA1
654: ** hash of the entire source tree.
655: **
656: ** See also: [sqlite3_libversion()],
657: ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
658: ** [sqlite_version()] and [sqlite_source_id()].
659: */
660: #define SQLITE_VERSION "3.7.10"
661: #define SQLITE_VERSION_NUMBER 3007010
662: #define SQLITE_SOURCE_ID "2012-01-16 13:28:40 ebd01a8deffb5024a5d7494eef800d2366d97204"
663:
664: /*
665: ** CAPI3REF: Run-Time Library Version Numbers
666: ** KEYWORDS: sqlite3_version, sqlite3_sourceid
667: **
668: ** These interfaces provide the same information as the [SQLITE_VERSION],
669: ** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
670: ** but are associated with the library instead of the header file. ^(Cautious
671: ** programmers might include assert() statements in their application to
672: ** verify that values returned by these interfaces match the macros in
673: ** the header, and thus insure that the application is
674: ** compiled with matching library and header files.
675: **
676: ** <blockquote><pre>
677: ** assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
678: ** assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
679: ** assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
680: ** </pre></blockquote>)^
681: **
682: ** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION]
683: ** macro. ^The sqlite3_libversion() function returns a pointer to the
684: ** to the sqlite3_version[] string constant. The sqlite3_libversion()
685: ** function is provided for use in DLLs since DLL users usually do not have
686: ** direct access to string constants within the DLL. ^The
687: ** sqlite3_libversion_number() function returns an integer equal to
688: ** [SQLITE_VERSION_NUMBER]. ^The sqlite3_sourceid() function returns
689: ** a pointer to a string constant whose value is the same as the
690: ** [SQLITE_SOURCE_ID] C preprocessor macro.
691: **
692: ** See also: [sqlite_version()] and [sqlite_source_id()].
693: */
694: SQLITE_API const char sqlite3_version[] = SQLITE_VERSION;
695: SQLITE_API const char *sqlite3_libversion(void);
696: SQLITE_API const char *sqlite3_sourceid(void);
697: SQLITE_API int sqlite3_libversion_number(void);
698:
699: /*
700: ** CAPI3REF: Run-Time Library Compilation Options Diagnostics
701: **
702: ** ^The sqlite3_compileoption_used() function returns 0 or 1
703: ** indicating whether the specified option was defined at
704: ** compile time. ^The SQLITE_ prefix may be omitted from the
705: ** option name passed to sqlite3_compileoption_used().
706: **
707: ** ^The sqlite3_compileoption_get() function allows iterating
708: ** over the list of options that were defined at compile time by
709: ** returning the N-th compile time option string. ^If N is out of range,
710: ** sqlite3_compileoption_get() returns a NULL pointer. ^The SQLITE_
711: ** prefix is omitted from any strings returned by
712: ** sqlite3_compileoption_get().
713: **
714: ** ^Support for the diagnostic functions sqlite3_compileoption_used()
715: ** and sqlite3_compileoption_get() may be omitted by specifying the
716: ** [SQLITE_OMIT_COMPILEOPTION_DIAGS] option at compile time.
717: **
718: ** See also: SQL functions [sqlite_compileoption_used()] and
719: ** [sqlite_compileoption_get()] and the [compile_options pragma].
720: */
721: #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
722: SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
723: SQLITE_API const char *sqlite3_compileoption_get(int N);
724: #endif
725:
726: /*
727: ** CAPI3REF: Test To See If The Library Is Threadsafe
728: **
729: ** ^The sqlite3_threadsafe() function returns zero if and only if
730: ** SQLite was compiled with mutexing code omitted due to the
731: ** [SQLITE_THREADSAFE] compile-time option being set to 0.
732: **
733: ** SQLite can be compiled with or without mutexes. When
734: ** the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes
735: ** are enabled and SQLite is threadsafe. When the
736: ** [SQLITE_THREADSAFE] macro is 0,
737: ** the mutexes are omitted. Without the mutexes, it is not safe
738: ** to use SQLite concurrently from more than one thread.
739: **
740: ** Enabling mutexes incurs a measurable performance penalty.
741: ** So if speed is of utmost importance, it makes sense to disable
742: ** the mutexes. But for maximum safety, mutexes should be enabled.
743: ** ^The default behavior is for mutexes to be enabled.
744: **
745: ** This interface can be used by an application to make sure that the
746: ** version of SQLite that it is linking against was compiled with
747: ** the desired setting of the [SQLITE_THREADSAFE] macro.
748: **
749: ** This interface only reports on the compile-time mutex setting
750: ** of the [SQLITE_THREADSAFE] flag. If SQLite is compiled with
751: ** SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but
752: ** can be fully or partially disabled using a call to [sqlite3_config()]
753: ** with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD],
754: ** or [SQLITE_CONFIG_MUTEX]. ^(The return value of the
755: ** sqlite3_threadsafe() function shows only the compile-time setting of
756: ** thread safety, not any run-time changes to that setting made by
757: ** sqlite3_config(). In other words, the return value from sqlite3_threadsafe()
758: ** is unchanged by calls to sqlite3_config().)^
759: **
760: ** See the [threading mode] documentation for additional information.
761: */
762: SQLITE_API int sqlite3_threadsafe(void);
763:
764: /*
765: ** CAPI3REF: Database Connection Handle
766: ** KEYWORDS: {database connection} {database connections}
767: **
768: ** Each open SQLite database is represented by a pointer to an instance of
769: ** the opaque structure named "sqlite3". It is useful to think of an sqlite3
770: ** pointer as an object. The [sqlite3_open()], [sqlite3_open16()], and
771: ** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]
772: ** is its destructor. There are many other interfaces (such as
773: ** [sqlite3_prepare_v2()], [sqlite3_create_function()], and
774: ** [sqlite3_busy_timeout()] to name but three) that are methods on an
775: ** sqlite3 object.
776: */
777: typedef struct sqlite3 sqlite3;
778:
779: /*
780: ** CAPI3REF: 64-Bit Integer Types
781: ** KEYWORDS: sqlite_int64 sqlite_uint64
782: **
783: ** Because there is no cross-platform way to specify 64-bit integer types
784: ** SQLite includes typedefs for 64-bit signed and unsigned integers.
785: **
786: ** The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions.
787: ** The sqlite_int64 and sqlite_uint64 types are supported for backwards
788: ** compatibility only.
789: **
790: ** ^The sqlite3_int64 and sqlite_int64 types can store integer values
791: ** between -9223372036854775808 and +9223372036854775807 inclusive. ^The
792: ** sqlite3_uint64 and sqlite_uint64 types can store integer values
793: ** between 0 and +18446744073709551615 inclusive.
794: */
795: #ifdef SQLITE_INT64_TYPE
796: typedef SQLITE_INT64_TYPE sqlite_int64;
797: typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
798: #elif defined(_MSC_VER) || defined(__BORLANDC__)
799: typedef __int64 sqlite_int64;
800: typedef unsigned __int64 sqlite_uint64;
801: #else
802: typedef long long int sqlite_int64;
803: typedef unsigned long long int sqlite_uint64;
804: #endif
805: typedef sqlite_int64 sqlite3_int64;
806: typedef sqlite_uint64 sqlite3_uint64;
807:
808: /*
809: ** If compiling for a processor that lacks floating point support,
810: ** substitute integer for floating-point.
811: */
812: #ifdef SQLITE_OMIT_FLOATING_POINT
813: # define double sqlite3_int64
814: #endif
815:
816: /*
817: ** CAPI3REF: Closing A Database Connection
818: **
819: ** ^The sqlite3_close() routine is the destructor for the [sqlite3] object.
820: ** ^Calls to sqlite3_close() return SQLITE_OK if the [sqlite3] object is
821: ** successfully destroyed and all associated resources are deallocated.
822: **
823: ** Applications must [sqlite3_finalize | finalize] all [prepared statements]
824: ** and [sqlite3_blob_close | close] all [BLOB handles] associated with
825: ** the [sqlite3] object prior to attempting to close the object. ^If
826: ** sqlite3_close() is called on a [database connection] that still has
827: ** outstanding [prepared statements] or [BLOB handles], then it returns
828: ** SQLITE_BUSY.
829: **
830: ** ^If [sqlite3_close()] is invoked while a transaction is open,
831: ** the transaction is automatically rolled back.
832: **
833: ** The C parameter to [sqlite3_close(C)] must be either a NULL
834: ** pointer or an [sqlite3] object pointer obtained
835: ** from [sqlite3_open()], [sqlite3_open16()], or
836: ** [sqlite3_open_v2()], and not previously closed.
837: ** ^Calling sqlite3_close() with a NULL pointer argument is a
838: ** harmless no-op.
839: */
840: SQLITE_API int sqlite3_close(sqlite3 *);
841:
842: /*
843: ** The type for a callback function.
844: ** This is legacy and deprecated. It is included for historical
845: ** compatibility and is not documented.
846: */
847: typedef int (*sqlite3_callback)(void*,int,char**, char**);
848:
849: /*
850: ** CAPI3REF: One-Step Query Execution Interface
851: **
852: ** The sqlite3_exec() interface is a convenience wrapper around
853: ** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()],
854: ** that allows an application to run multiple statements of SQL
855: ** without having to use a lot of C code.
856: **
857: ** ^The sqlite3_exec() interface runs zero or more UTF-8 encoded,
858: ** semicolon-separate SQL statements passed into its 2nd argument,
859: ** in the context of the [database connection] passed in as its 1st
860: ** argument. ^If the callback function of the 3rd argument to
861: ** sqlite3_exec() is not NULL, then it is invoked for each result row
862: ** coming out of the evaluated SQL statements. ^The 4th argument to
863: ** sqlite3_exec() is relayed through to the 1st argument of each
864: ** callback invocation. ^If the callback pointer to sqlite3_exec()
865: ** is NULL, then no callback is ever invoked and result rows are
866: ** ignored.
867: **
868: ** ^If an error occurs while evaluating the SQL statements passed into
869: ** sqlite3_exec(), then execution of the current statement stops and
870: ** subsequent statements are skipped. ^If the 5th parameter to sqlite3_exec()
871: ** is not NULL then any error message is written into memory obtained
872: ** from [sqlite3_malloc()] and passed back through the 5th parameter.
873: ** To avoid memory leaks, the application should invoke [sqlite3_free()]
874: ** on error message strings returned through the 5th parameter of
875: ** of sqlite3_exec() after the error message string is no longer needed.
876: ** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
877: ** occur, then sqlite3_exec() sets the pointer in its 5th parameter to
878: ** NULL before returning.
879: **
880: ** ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec()
881: ** routine returns SQLITE_ABORT without invoking the callback again and
882: ** without running any subsequent SQL statements.
883: **
884: ** ^The 2nd argument to the sqlite3_exec() callback function is the
885: ** number of columns in the result. ^The 3rd argument to the sqlite3_exec()
886: ** callback is an array of pointers to strings obtained as if from
887: ** [sqlite3_column_text()], one for each column. ^If an element of a
888: ** result row is NULL then the corresponding string pointer for the
889: ** sqlite3_exec() callback is a NULL pointer. ^The 4th argument to the
890: ** sqlite3_exec() callback is an array of pointers to strings where each
891: ** entry represents the name of corresponding result column as obtained
892: ** from [sqlite3_column_name()].
893: **
894: ** ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer
895: ** to an empty string, or a pointer that contains only whitespace and/or
896: ** SQL comments, then no SQL statements are evaluated and the database
897: ** is not changed.
898: **
899: ** Restrictions:
900: **
901: ** <ul>
902: ** <li> The application must insure that the 1st parameter to sqlite3_exec()
903: ** is a valid and open [database connection].
904: ** <li> The application must not close [database connection] specified by
905: ** the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
906: ** <li> The application must not modify the SQL statement text passed into
907: ** the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
908: ** </ul>
909: */
910: SQLITE_API int sqlite3_exec(
911: sqlite3*, /* An open database */
912: const char *sql, /* SQL to be evaluated */
913: int (*callback)(void*,int,char**,char**), /* Callback function */
914: void *, /* 1st argument to callback */
915: char **errmsg /* Error msg written here */
916: );
917:
918: /*
919: ** CAPI3REF: Result Codes
920: ** KEYWORDS: SQLITE_OK {error code} {error codes}
921: ** KEYWORDS: {result code} {result codes}
922: **
923: ** Many SQLite functions return an integer result code from the set shown
924: ** here in order to indicate success or failure.
925: **
926: ** New error codes may be added in future versions of SQLite.
927: **
928: ** See also: [SQLITE_IOERR_READ | extended result codes],
929: ** [sqlite3_vtab_on_conflict()] [SQLITE_ROLLBACK | result codes].
930: */
931: #define SQLITE_OK 0 /* Successful result */
932: /* beginning-of-error-codes */
933: #define SQLITE_ERROR 1 /* SQL error or missing database */
934: #define SQLITE_INTERNAL 2 /* Internal logic error in SQLite */
935: #define SQLITE_PERM 3 /* Access permission denied */
936: #define SQLITE_ABORT 4 /* Callback routine requested an abort */
937: #define SQLITE_BUSY 5 /* The database file is locked */
938: #define SQLITE_LOCKED 6 /* A table in the database is locked */
939: #define SQLITE_NOMEM 7 /* A malloc() failed */
940: #define SQLITE_READONLY 8 /* Attempt to write a readonly database */
941: #define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/
942: #define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */
943: #define SQLITE_CORRUPT 11 /* The database disk image is malformed */
944: #define SQLITE_NOTFOUND 12 /* Unknown opcode in sqlite3_file_control() */
945: #define SQLITE_FULL 13 /* Insertion failed because database is full */
946: #define SQLITE_CANTOPEN 14 /* Unable to open the database file */
947: #define SQLITE_PROTOCOL 15 /* Database lock protocol error */
948: #define SQLITE_EMPTY 16 /* Database is empty */
949: #define SQLITE_SCHEMA 17 /* The database schema changed */
950: #define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */
951: #define SQLITE_CONSTRAINT 19 /* Abort due to constraint violation */
952: #define SQLITE_MISMATCH 20 /* Data type mismatch */
953: #define SQLITE_MISUSE 21 /* Library used incorrectly */
954: #define SQLITE_NOLFS 22 /* Uses OS features not supported on host */
955: #define SQLITE_AUTH 23 /* Authorization denied */
956: #define SQLITE_FORMAT 24 /* Auxiliary database format error */
957: #define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */
958: #define SQLITE_NOTADB 26 /* File opened that is not a database file */
959: #define SQLITE_ROW 100 /* sqlite3_step() has another row ready */
960: #define SQLITE_DONE 101 /* sqlite3_step() has finished executing */
961: /* end-of-error-codes */
962:
963: /*
964: ** CAPI3REF: Extended Result Codes
965: ** KEYWORDS: {extended error code} {extended error codes}
966: ** KEYWORDS: {extended result code} {extended result codes}
967: **
968: ** In its default configuration, SQLite API routines return one of 26 integer
969: ** [SQLITE_OK | result codes]. However, experience has shown that many of
970: ** these result codes are too coarse-grained. They do not provide as
971: ** much information about problems as programmers might like. In an effort to
972: ** address this, newer versions of SQLite (version 3.3.8 and later) include
973: ** support for additional result codes that provide more detailed information
974: ** about errors. The extended result codes are enabled or disabled
975: ** on a per database connection basis using the
976: ** [sqlite3_extended_result_codes()] API.
977: **
978: ** Some of the available extended result codes are listed here.
979: ** One may expect the number of extended result codes will be expand
980: ** over time. Software that uses extended result codes should expect
981: ** to see new result codes in future releases of SQLite.
982: **
983: ** The SQLITE_OK result code will never be extended. It will always
984: ** be exactly zero.
985: */
986: #define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8))
987: #define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8))
988: #define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8))
989: #define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8))
990: #define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8))
991: #define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8))
992: #define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8))
993: #define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8))
994: #define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8))
995: #define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8))
996: #define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8))
997: #define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8))
998: #define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8))
999: #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
1000: #define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8))
1001: #define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8))
1002: #define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8))
1003: #define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8))
1004: #define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8))
1005: #define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8))
1006: #define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8))
1007: #define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8))
1008: #define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8))
1009: #define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8))
1010: #define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8))
1011: #define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8))
1012: #define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8))
1013: #define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8))
1014:
1015: /*
1016: ** CAPI3REF: Flags For File Open Operations
1017: **
1018: ** These bit values are intended for use in the
1019: ** 3rd parameter to the [sqlite3_open_v2()] interface and
1020: ** in the 4th parameter to the [sqlite3_vfs.xOpen] method.
1021: */
1022: #define SQLITE_OPEN_READONLY 0x00000001 /* Ok for sqlite3_open_v2() */
1023: #define SQLITE_OPEN_READWRITE 0x00000002 /* Ok for sqlite3_open_v2() */
1024: #define SQLITE_OPEN_CREATE 0x00000004 /* Ok for sqlite3_open_v2() */
1025: #define SQLITE_OPEN_DELETEONCLOSE 0x00000008 /* VFS only */
1026: #define SQLITE_OPEN_EXCLUSIVE 0x00000010 /* VFS only */
1027: #define SQLITE_OPEN_AUTOPROXY 0x00000020 /* VFS only */
1028: #define SQLITE_OPEN_URI 0x00000040 /* Ok for sqlite3_open_v2() */
1029: #define SQLITE_OPEN_MAIN_DB 0x00000100 /* VFS only */
1030: #define SQLITE_OPEN_TEMP_DB 0x00000200 /* VFS only */
1031: #define SQLITE_OPEN_TRANSIENT_DB 0x00000400 /* VFS only */
1032: #define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 /* VFS only */
1033: #define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 /* VFS only */
1034: #define SQLITE_OPEN_SUBJOURNAL 0x00002000 /* VFS only */
1035: #define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 /* VFS only */
1036: #define SQLITE_OPEN_NOMUTEX 0x00008000 /* Ok for sqlite3_open_v2() */
1037: #define SQLITE_OPEN_FULLMUTEX 0x00010000 /* Ok for sqlite3_open_v2() */
1038: #define SQLITE_OPEN_SHAREDCACHE 0x00020000 /* Ok for sqlite3_open_v2() */
1039: #define SQLITE_OPEN_PRIVATECACHE 0x00040000 /* Ok for sqlite3_open_v2() */
1040: #define SQLITE_OPEN_WAL 0x00080000 /* VFS only */
1041:
1042: /* Reserved: 0x00F00000 */
1043:
1044: /*
1045: ** CAPI3REF: Device Characteristics
1046: **
1047: ** The xDeviceCharacteristics method of the [sqlite3_io_methods]
1048: ** object returns an integer which is a vector of the these
1049: ** bit values expressing I/O characteristics of the mass storage
1050: ** device that holds the file that the [sqlite3_io_methods]
1051: ** refers to.
1052: **
1053: ** The SQLITE_IOCAP_ATOMIC property means that all writes of
1054: ** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values
1055: ** mean that writes of blocks that are nnn bytes in size and
1056: ** are aligned to an address which is an integer multiple of
1057: ** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means
1058: ** that when data is appended to a file, the data is appended
1059: ** first then the size of the file is extended, never the other
1060: ** way around. The SQLITE_IOCAP_SEQUENTIAL property means that
1061: ** information is written to disk in the same order as calls
1062: ** to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that
1063: ** after reboot following a crash or power loss, the only bytes in a
1064: ** file that were written at the application level might have changed
1065: ** and that adjacent bytes, even bytes within the same sector are
1066: ** guaranteed to be unchanged.
1067: */
1068: #define SQLITE_IOCAP_ATOMIC 0x00000001
1069: #define SQLITE_IOCAP_ATOMIC512 0x00000002
1070: #define SQLITE_IOCAP_ATOMIC1K 0x00000004
1071: #define SQLITE_IOCAP_ATOMIC2K 0x00000008
1072: #define SQLITE_IOCAP_ATOMIC4K 0x00000010
1073: #define SQLITE_IOCAP_ATOMIC8K 0x00000020
1074: #define SQLITE_IOCAP_ATOMIC16K 0x00000040
1075: #define SQLITE_IOCAP_ATOMIC32K 0x00000080
1076: #define SQLITE_IOCAP_ATOMIC64K 0x00000100
1077: #define SQLITE_IOCAP_SAFE_APPEND 0x00000200
1078: #define SQLITE_IOCAP_SEQUENTIAL 0x00000400
1079: #define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800
1080: #define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000
1081:
1082: /*
1083: ** CAPI3REF: File Locking Levels
1084: **
1085: ** SQLite uses one of these integer values as the second
1086: ** argument to calls it makes to the xLock() and xUnlock() methods
1087: ** of an [sqlite3_io_methods] object.
1088: */
1089: #define SQLITE_LOCK_NONE 0
1090: #define SQLITE_LOCK_SHARED 1
1091: #define SQLITE_LOCK_RESERVED 2
1092: #define SQLITE_LOCK_PENDING 3
1093: #define SQLITE_LOCK_EXCLUSIVE 4
1094:
1095: /*
1096: ** CAPI3REF: Synchronization Type Flags
1097: **
1098: ** When SQLite invokes the xSync() method of an
1099: ** [sqlite3_io_methods] object it uses a combination of
1100: ** these integer values as the second argument.
1101: **
1102: ** When the SQLITE_SYNC_DATAONLY flag is used, it means that the
1103: ** sync operation only needs to flush data to mass storage. Inode
1104: ** information need not be flushed. If the lower four bits of the flag
1105: ** equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics.
1106: ** If the lower four bits equal SQLITE_SYNC_FULL, that means
1107: ** to use Mac OS X style fullsync instead of fsync().
1108: **
1109: ** Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags
1110: ** with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL
1111: ** settings. The [synchronous pragma] determines when calls to the
1112: ** xSync VFS method occur and applies uniformly across all platforms.
1113: ** The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how
1114: ** energetic or rigorous or forceful the sync operations are and
1115: ** only make a difference on Mac OSX for the default SQLite code.
1116: ** (Third-party VFS implementations might also make the distinction
1117: ** between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the
1118: ** operating systems natively supported by SQLite, only Mac OSX
1119: ** cares about the difference.)
1120: */
1121: #define SQLITE_SYNC_NORMAL 0x00002
1122: #define SQLITE_SYNC_FULL 0x00003
1123: #define SQLITE_SYNC_DATAONLY 0x00010
1124:
1125: /*
1126: ** CAPI3REF: OS Interface Open File Handle
1127: **
1128: ** An [sqlite3_file] object represents an open file in the
1129: ** [sqlite3_vfs | OS interface layer]. Individual OS interface
1130: ** implementations will
1131: ** want to subclass this object by appending additional fields
1132: ** for their own use. The pMethods entry is a pointer to an
1133: ** [sqlite3_io_methods] object that defines methods for performing
1134: ** I/O operations on the open file.
1135: */
1136: typedef struct sqlite3_file sqlite3_file;
1137: struct sqlite3_file {
1138: const struct sqlite3_io_methods *pMethods; /* Methods for an open file */
1139: };
1140:
1141: /*
1142: ** CAPI3REF: OS Interface File Virtual Methods Object
1143: **
1144: ** Every file opened by the [sqlite3_vfs.xOpen] method populates an
1145: ** [sqlite3_file] object (or, more commonly, a subclass of the
1146: ** [sqlite3_file] object) with a pointer to an instance of this object.
1147: ** This object defines the methods used to perform various operations
1148: ** against the open file represented by the [sqlite3_file] object.
1149: **
1150: ** If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element
1151: ** to a non-NULL pointer, then the sqlite3_io_methods.xClose method
1152: ** may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The
1153: ** only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen]
1154: ** is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element
1155: ** to NULL.
1156: **
1157: ** The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or
1158: ** [SQLITE_SYNC_FULL]. The first choice is the normal fsync().
1159: ** The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY]
1160: ** flag may be ORed in to indicate that only the data of the file
1161: ** and not its inode needs to be synced.
1162: **
1163: ** The integer values to xLock() and xUnlock() are one of
1164: ** <ul>
1165: ** <li> [SQLITE_LOCK_NONE],
1166: ** <li> [SQLITE_LOCK_SHARED],
1167: ** <li> [SQLITE_LOCK_RESERVED],
1168: ** <li> [SQLITE_LOCK_PENDING], or
1169: ** <li> [SQLITE_LOCK_EXCLUSIVE].
1170: ** </ul>
1171: ** xLock() increases the lock. xUnlock() decreases the lock.
1172: ** The xCheckReservedLock() method checks whether any database connection,
1173: ** either in this process or in some other process, is holding a RESERVED,
1174: ** PENDING, or EXCLUSIVE lock on the file. It returns true
1175: ** if such a lock exists and false otherwise.
1176: **
1177: ** The xFileControl() method is a generic interface that allows custom
1178: ** VFS implementations to directly control an open file using the
1179: ** [sqlite3_file_control()] interface. The second "op" argument is an
1180: ** integer opcode. The third argument is a generic pointer intended to
1181: ** point to a structure that may contain arguments or space in which to
1182: ** write return values. Potential uses for xFileControl() might be
1183: ** functions to enable blocking locks with timeouts, to change the
1184: ** locking strategy (for example to use dot-file locks), to inquire
1185: ** about the status of a lock, or to break stale locks. The SQLite
1186: ** core reserves all opcodes less than 100 for its own use.
1187: ** A [SQLITE_FCNTL_LOCKSTATE | list of opcodes] less than 100 is available.
1188: ** Applications that define a custom xFileControl method should use opcodes
1189: ** greater than 100 to avoid conflicts. VFS implementations should
1190: ** return [SQLITE_NOTFOUND] for file control opcodes that they do not
1191: ** recognize.
1192: **
1193: ** The xSectorSize() method returns the sector size of the
1194: ** device that underlies the file. The sector size is the
1195: ** minimum write that can be performed without disturbing
1196: ** other bytes in the file. The xDeviceCharacteristics()
1197: ** method returns a bit vector describing behaviors of the
1198: ** underlying device:
1199: **
1200: ** <ul>
1201: ** <li> [SQLITE_IOCAP_ATOMIC]
1202: ** <li> [SQLITE_IOCAP_ATOMIC512]
1203: ** <li> [SQLITE_IOCAP_ATOMIC1K]
1204: ** <li> [SQLITE_IOCAP_ATOMIC2K]
1205: ** <li> [SQLITE_IOCAP_ATOMIC4K]
1206: ** <li> [SQLITE_IOCAP_ATOMIC8K]
1207: ** <li> [SQLITE_IOCAP_ATOMIC16K]
1208: ** <li> [SQLITE_IOCAP_ATOMIC32K]
1209: ** <li> [SQLITE_IOCAP_ATOMIC64K]
1210: ** <li> [SQLITE_IOCAP_SAFE_APPEND]
1211: ** <li> [SQLITE_IOCAP_SEQUENTIAL]
1212: ** </ul>
1213: **
1214: ** The SQLITE_IOCAP_ATOMIC property means that all writes of
1215: ** any size are atomic. The SQLITE_IOCAP_ATOMICnnn values
1216: ** mean that writes of blocks that are nnn bytes in size and
1217: ** are aligned to an address which is an integer multiple of
1218: ** nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means
1219: ** that when data is appended to a file, the data is appended
1220: ** first then the size of the file is extended, never the other
1221: ** way around. The SQLITE_IOCAP_SEQUENTIAL property means that
1222: ** information is written to disk in the same order as calls
1223: ** to xWrite().
1224: **
1225: ** If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill
1226: ** in the unread portions of the buffer with zeros. A VFS that
1227: ** fails to zero-fill short reads might seem to work. However,
1228: ** failure to zero-fill short reads will eventually lead to
1229: ** database corruption.
1230: */
1231: typedef struct sqlite3_io_methods sqlite3_io_methods;
1232: struct sqlite3_io_methods {
1233: int iVersion;
1234: int (*xClose)(sqlite3_file*);
1235: int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
1236: int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
1237: int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
1238: int (*xSync)(sqlite3_file*, int flags);
1239: int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
1240: int (*xLock)(sqlite3_file*, int);
1241: int (*xUnlock)(sqlite3_file*, int);
1242: int (*xCheckReservedLock)(sqlite3_file*, int *pResOut);
1243: int (*xFileControl)(sqlite3_file*, int op, void *pArg);
1244: int (*xSectorSize)(sqlite3_file*);
1245: int (*xDeviceCharacteristics)(sqlite3_file*);
1246: /* Methods above are valid for version 1 */
1247: int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**);
1248: int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
1249: void (*xShmBarrier)(sqlite3_file*);
1250: int (*xShmUnmap)(sqlite3_file*, int deleteFlag);
1251: /* Methods above are valid for version 2 */
1252: /* Additional methods may be added in future releases */
1253: };
1254:
1255: /*
1256: ** CAPI3REF: Standard File Control Opcodes
1257: **
1258: ** These integer constants are opcodes for the xFileControl method
1259: ** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]
1260: ** interface.
1261: **
1262: ** The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging. This
1263: ** opcode causes the xFileControl method to write the current state of
1264: ** the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
1265: ** [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
1266: ** into an integer that the pArg argument points to. This capability
1267: ** is used during testing and only needs to be supported when SQLITE_TEST
1268: ** is defined.
1269: **
1270: ** The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
1271: ** layer a hint of how large the database file will grow to be during the
1272: ** current transaction. This hint is not guaranteed to be accurate but it
1273: ** is often close. The underlying VFS might choose to preallocate database
1274: ** file space based on this hint in order to help writes to the database
1275: ** file run faster.
1276: **
1277: ** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS
1278: ** extends and truncates the database file in chunks of a size specified
1279: ** by the user. The fourth argument to [sqlite3_file_control()] should
1280: ** point to an integer (type int) containing the new chunk-size to use
1281: ** for the nominated database. Allocating database file space in large
1282: ** chunks (say 1MB at a time), may reduce file-system fragmentation and
1283: ** improve performance on some systems.
1284: **
1285: ** The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer
1286: ** to the [sqlite3_file] object associated with a particular database
1287: ** connection. See the [sqlite3_file_control()] documentation for
1288: ** additional information.
1289: **
1290: ** ^(The [SQLITE_FCNTL_SYNC_OMITTED] opcode is generated internally by
1291: ** SQLite and sent to all VFSes in place of a call to the xSync method
1292: ** when the database connection has [PRAGMA synchronous] set to OFF.)^
1293: ** Some specialized VFSes need this signal in order to operate correctly
1294: ** when [PRAGMA synchronous | PRAGMA synchronous=OFF] is set, but most
1295: ** VFSes do not need this signal and should silently ignore this opcode.
1296: ** Applications should not call [sqlite3_file_control()] with this
1297: ** opcode as doing so may disrupt the operation of the specialized VFSes
1298: ** that do require it.
1299: **
1300: ** ^The [SQLITE_FCNTL_WIN32_AV_RETRY] opcode is used to configure automatic
1301: ** retry counts and intervals for certain disk I/O operations for the
1302: ** windows [VFS] in order to provide robustness in the presence of
1303: ** anti-virus programs. By default, the windows VFS will retry file read,
1304: ** file write, and file delete operations up to 10 times, with a delay
1305: ** of 25 milliseconds before the first retry and with the delay increasing
1306: ** by an additional 25 milliseconds with each subsequent retry. This
1307: ** opcode allows these two values (10 retries and 25 milliseconds of delay)
1308: ** to be adjusted. The values are changed for all database connections
1309: ** within the same process. The argument is a pointer to an array of two
1310: ** integers where the first integer i the new retry count and the second
1311: ** integer is the delay. If either integer is negative, then the setting
1312: ** is not changed but instead the prior value of that setting is written
1313: ** into the array entry, allowing the current retry settings to be
1314: ** interrogated. The zDbName parameter is ignored.
1315: **
1316: ** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the
1317: ** persistent [WAL | Write AHead Log] setting. By default, the auxiliary
1318: ** write ahead log and shared memory files used for transaction control
1319: ** are automatically deleted when the latest connection to the database
1320: ** closes. Setting persistent WAL mode causes those files to persist after
1321: ** close. Persisting the files is useful when other processes that do not
1322: ** have write permission on the directory containing the database file want
1323: ** to read the database file, as the WAL and shared memory files must exist
1324: ** in order for the database to be readable. The fourth parameter to
1325: ** [sqlite3_file_control()] for this opcode should be a pointer to an integer.
1326: ** That integer is 0 to disable persistent WAL mode or 1 to enable persistent
1327: ** WAL mode. If the integer is -1, then it is overwritten with the current
1328: ** WAL persistence setting.
1329: **
1330: ** ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the
1331: ** persistent "powersafe-overwrite" or "PSOW" setting. The PSOW setting
1332: ** determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the
1333: ** xDeviceCharacteristics methods. The fourth parameter to
1334: ** [sqlite3_file_control()] for this opcode should be a pointer to an integer.
1335: ** That integer is 0 to disable zero-damage mode or 1 to enable zero-damage
1336: ** mode. If the integer is -1, then it is overwritten with the current
1337: ** zero-damage mode setting.
1338: **
1339: ** ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening
1340: ** a write transaction to indicate that, unless it is rolled back for some
1341: ** reason, the entire database file will be overwritten by the current
1342: ** transaction. This is used by VACUUM operations.
1343: **
1344: ** ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of
1345: ** all [VFSes] in the VFS stack. The names are of all VFS shims and the
1346: ** final bottom-level VFS are written into memory obtained from
1347: ** [sqlite3_malloc()] and the result is stored in the char* variable
1348: ** that the fourth parameter of [sqlite3_file_control()] points to.
1349: ** The caller is responsible for freeing the memory when done. As with
1350: ** all file-control actions, there is no guarantee that this will actually
1351: ** do anything. Callers should initialize the char* variable to a NULL
1352: ** pointer in case this file-control is not implemented. This file-control
1353: ** is intended for diagnostic use only.
1354: */
1355: #define SQLITE_FCNTL_LOCKSTATE 1
1356: #define SQLITE_GET_LOCKPROXYFILE 2
1357: #define SQLITE_SET_LOCKPROXYFILE 3
1358: #define SQLITE_LAST_ERRNO 4
1359: #define SQLITE_FCNTL_SIZE_HINT 5
1360: #define SQLITE_FCNTL_CHUNK_SIZE 6
1361: #define SQLITE_FCNTL_FILE_POINTER 7
1362: #define SQLITE_FCNTL_SYNC_OMITTED 8
1363: #define SQLITE_FCNTL_WIN32_AV_RETRY 9
1364: #define SQLITE_FCNTL_PERSIST_WAL 10
1365: #define SQLITE_FCNTL_OVERWRITE 11
1366: #define SQLITE_FCNTL_VFSNAME 12
1367: #define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13
1368:
1369: /*
1370: ** CAPI3REF: Mutex Handle
1371: **
1372: ** The mutex module within SQLite defines [sqlite3_mutex] to be an
1373: ** abstract type for a mutex object. The SQLite core never looks
1374: ** at the internal representation of an [sqlite3_mutex]. It only
1375: ** deals with pointers to the [sqlite3_mutex] object.
1376: **
1377: ** Mutexes are created using [sqlite3_mutex_alloc()].
1378: */
1379: typedef struct sqlite3_mutex sqlite3_mutex;
1380:
1381: /*
1382: ** CAPI3REF: OS Interface Object
1383: **
1384: ** An instance of the sqlite3_vfs object defines the interface between
1385: ** the SQLite core and the underlying operating system. The "vfs"
1386: ** in the name of the object stands for "virtual file system". See
1387: ** the [VFS | VFS documentation] for further information.
1388: **
1389: ** The value of the iVersion field is initially 1 but may be larger in
1390: ** future versions of SQLite. Additional fields may be appended to this
1391: ** object when the iVersion value is increased. Note that the structure
1392: ** of the sqlite3_vfs object changes in the transaction between
1393: ** SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not
1394: ** modified.
1395: **
1396: ** The szOsFile field is the size of the subclassed [sqlite3_file]
1397: ** structure used by this VFS. mxPathname is the maximum length of
1398: ** a pathname in this VFS.
1399: **
1400: ** Registered sqlite3_vfs objects are kept on a linked list formed by
1401: ** the pNext pointer. The [sqlite3_vfs_register()]
1402: ** and [sqlite3_vfs_unregister()] interfaces manage this list
1403: ** in a thread-safe way. The [sqlite3_vfs_find()] interface
1404: ** searches the list. Neither the application code nor the VFS
1405: ** implementation should use the pNext pointer.
1406: **
1407: ** The pNext field is the only field in the sqlite3_vfs
1408: ** structure that SQLite will ever modify. SQLite will only access
1409: ** or modify this field while holding a particular static mutex.
1410: ** The application should never modify anything within the sqlite3_vfs
1411: ** object once the object has been registered.
1412: **
1413: ** The zName field holds the name of the VFS module. The name must
1414: ** be unique across all VFS modules.
1415: **
1416: ** [[sqlite3_vfs.xOpen]]
1417: ** ^SQLite guarantees that the zFilename parameter to xOpen
1418: ** is either a NULL pointer or string obtained
1419: ** from xFullPathname() with an optional suffix added.
1420: ** ^If a suffix is added to the zFilename parameter, it will
1421: ** consist of a single "-" character followed by no more than
1422: ** 11 alphanumeric and/or "-" characters.
1423: ** ^SQLite further guarantees that
1424: ** the string will be valid and unchanged until xClose() is
1425: ** called. Because of the previous sentence,
1426: ** the [sqlite3_file] can safely store a pointer to the
1427: ** filename if it needs to remember the filename for some reason.
1428: ** If the zFilename parameter to xOpen is a NULL pointer then xOpen
1429: ** must invent its own temporary name for the file. ^Whenever the
1430: ** xFilename parameter is NULL it will also be the case that the
1431: ** flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
1432: **
1433: ** The flags argument to xOpen() includes all bits set in
1434: ** the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()]
1435: ** or [sqlite3_open16()] is used, then flags includes at least
1436: ** [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].
1437: ** If xOpen() opens a file read-only then it sets *pOutFlags to
1438: ** include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set.
1439: **
1440: ** ^(SQLite will also add one of the following flags to the xOpen()
1441: ** call, depending on the object being opened:
1442: **
1443: ** <ul>
1444: ** <li> [SQLITE_OPEN_MAIN_DB]
1445: ** <li> [SQLITE_OPEN_MAIN_JOURNAL]
1446: ** <li> [SQLITE_OPEN_TEMP_DB]
1447: ** <li> [SQLITE_OPEN_TEMP_JOURNAL]
1448: ** <li> [SQLITE_OPEN_TRANSIENT_DB]
1449: ** <li> [SQLITE_OPEN_SUBJOURNAL]
1450: ** <li> [SQLITE_OPEN_MASTER_JOURNAL]
1451: ** <li> [SQLITE_OPEN_WAL]
1452: ** </ul>)^
1453: **
1454: ** The file I/O implementation can use the object type flags to
1455: ** change the way it deals with files. For example, an application
1456: ** that does not care about crash recovery or rollback might make
1457: ** the open of a journal file a no-op. Writes to this journal would
1458: ** also be no-ops, and any attempt to read the journal would return
1459: ** SQLITE_IOERR. Or the implementation might recognize that a database
1460: ** file will be doing page-aligned sector reads and writes in a random
1461: ** order and set up its I/O subsystem accordingly.
1462: **
1463: ** SQLite might also add one of the following flags to the xOpen method:
1464: **
1465: ** <ul>
1466: ** <li> [SQLITE_OPEN_DELETEONCLOSE]
1467: ** <li> [SQLITE_OPEN_EXCLUSIVE]
1468: ** </ul>
1469: **
1470: ** The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
1471: ** deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE]
1472: ** will be set for TEMP databases and their journals, transient
1473: ** databases, and subjournals.
1474: **
1475: ** ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction
1476: ** with the [SQLITE_OPEN_CREATE] flag, which are both directly
1477: ** analogous to the O_EXCL and O_CREAT flags of the POSIX open()
1478: ** API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the
1479: ** SQLITE_OPEN_CREATE, is used to indicate that file should always
1480: ** be created, and that it is an error if it already exists.
1481: ** It is <i>not</i> used to indicate the file should be opened
1482: ** for exclusive access.
1483: **
1484: ** ^At least szOsFile bytes of memory are allocated by SQLite
1485: ** to hold the [sqlite3_file] structure passed as the third
1486: ** argument to xOpen. The xOpen method does not have to
1487: ** allocate the structure; it should just fill it in. Note that
1488: ** the xOpen method must set the sqlite3_file.pMethods to either
1489: ** a valid [sqlite3_io_methods] object or to NULL. xOpen must do
1490: ** this even if the open fails. SQLite expects that the sqlite3_file.pMethods
1491: ** element will be valid after xOpen returns regardless of the success
1492: ** or failure of the xOpen call.
1493: **
1494: ** [[sqlite3_vfs.xAccess]]
1495: ** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
1496: ** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to
1497: ** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]
1498: ** to test whether a file is at least readable. The file can be a
1499: ** directory.
1500: **
1501: ** ^SQLite will always allocate at least mxPathname+1 bytes for the
1502: ** output buffer xFullPathname. The exact size of the output buffer
1503: ** is also passed as a parameter to both methods. If the output buffer
1504: ** is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
1505: ** handled as a fatal error by SQLite, vfs implementations should endeavor
1506: ** to prevent this by setting mxPathname to a sufficiently large value.
1507: **
1508: ** The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64()
1509: ** interfaces are not strictly a part of the filesystem, but they are
1510: ** included in the VFS structure for completeness.
1511: ** The xRandomness() function attempts to return nBytes bytes
1512: ** of good-quality randomness into zOut. The return value is
1513: ** the actual number of bytes of randomness obtained.
1514: ** The xSleep() method causes the calling thread to sleep for at
1515: ** least the number of microseconds given. ^The xCurrentTime()
1516: ** method returns a Julian Day Number for the current date and time as
1517: ** a floating point value.
1518: ** ^The xCurrentTimeInt64() method returns, as an integer, the Julian
1519: ** Day Number multiplied by 86400000 (the number of milliseconds in
1520: ** a 24-hour day).
1521: ** ^SQLite will use the xCurrentTimeInt64() method to get the current
1522: ** date and time if that method is available (if iVersion is 2 or
1523: ** greater and the function pointer is not NULL) and will fall back
1524: ** to xCurrentTime() if xCurrentTimeInt64() is unavailable.
1525: **
1526: ** ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces
1527: ** are not used by the SQLite core. These optional interfaces are provided
1528: ** by some VFSes to facilitate testing of the VFS code. By overriding
1529: ** system calls with functions under its control, a test program can
1530: ** simulate faults and error conditions that would otherwise be difficult
1531: ** or impossible to induce. The set of system calls that can be overridden
1532: ** varies from one VFS to another, and from one version of the same VFS to the
1533: ** next. Applications that use these interfaces must be prepared for any
1534: ** or all of these interfaces to be NULL or for their behavior to change
1535: ** from one release to the next. Applications must not attempt to access
1536: ** any of these methods if the iVersion of the VFS is less than 3.
1537: */
1538: typedef struct sqlite3_vfs sqlite3_vfs;
1539: typedef void (*sqlite3_syscall_ptr)(void);
1540: struct sqlite3_vfs {
1541: int iVersion; /* Structure version number (currently 3) */
1542: int szOsFile; /* Size of subclassed sqlite3_file */
1543: int mxPathname; /* Maximum file pathname length */
1544: sqlite3_vfs *pNext; /* Next registered VFS */
1545: const char *zName; /* Name of this virtual file system */
1546: void *pAppData; /* Pointer to application-specific data */
1547: int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
1548: int flags, int *pOutFlags);
1549: int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
1550: int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
1551: int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
1552: void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
1553: void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
1554: void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
1555: void (*xDlClose)(sqlite3_vfs*, void*);
1556: int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
1557: int (*xSleep)(sqlite3_vfs*, int microseconds);
1558: int (*xCurrentTime)(sqlite3_vfs*, double*);
1559: int (*xGetLastError)(sqlite3_vfs*, int, char *);
1560: /*
1561: ** The methods above are in version 1 of the sqlite_vfs object
1562: ** definition. Those that follow are added in version 2 or later
1563: */
1564: int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*);
1565: /*
1566: ** The methods above are in versions 1 and 2 of the sqlite_vfs object.
1567: ** Those below are for version 3 and greater.
1568: */
1569: int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
1570: sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
1571: const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
1572: /*
1573: ** The methods above are in versions 1 through 3 of the sqlite_vfs object.
1574: ** New fields may be appended in figure versions. The iVersion
1575: ** value will increment whenever this happens.
1576: */
1577: };
1578:
1579: /*
1580: ** CAPI3REF: Flags for the xAccess VFS method
1581: **
1582: ** These integer constants can be used as the third parameter to
1583: ** the xAccess method of an [sqlite3_vfs] object. They determine
1584: ** what kind of permissions the xAccess method is looking for.
1585: ** With SQLITE_ACCESS_EXISTS, the xAccess method
1586: ** simply checks whether the file exists.
1587: ** With SQLITE_ACCESS_READWRITE, the xAccess method
1588: ** checks whether the named directory is both readable and writable
1589: ** (in other words, if files can be added, removed, and renamed within
1590: ** the directory).
1591: ** The SQLITE_ACCESS_READWRITE constant is currently used only by the
1592: ** [temp_store_directory pragma], though this could change in a future
1593: ** release of SQLite.
1594: ** With SQLITE_ACCESS_READ, the xAccess method
1595: ** checks whether the file is readable. The SQLITE_ACCESS_READ constant is
1596: ** currently unused, though it might be used in a future release of
1597: ** SQLite.
1598: */
1599: #define SQLITE_ACCESS_EXISTS 0
1600: #define SQLITE_ACCESS_READWRITE 1 /* Used by PRAGMA temp_store_directory */
1601: #define SQLITE_ACCESS_READ 2 /* Unused */
1602:
1603: /*
1604: ** CAPI3REF: Flags for the xShmLock VFS method
1605: **
1606: ** These integer constants define the various locking operations
1607: ** allowed by the xShmLock method of [sqlite3_io_methods]. The
1608: ** following are the only legal combinations of flags to the
1609: ** xShmLock method:
1610: **
1611: ** <ul>
1612: ** <li> SQLITE_SHM_LOCK | SQLITE_SHM_SHARED
1613: ** <li> SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE
1614: ** <li> SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED
1615: ** <li> SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE
1616: ** </ul>
1617: **
1618: ** When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
1619: ** was given no the corresponding lock.
1620: **
1621: ** The xShmLock method can transition between unlocked and SHARED or
1622: ** between unlocked and EXCLUSIVE. It cannot transition between SHARED
1623: ** and EXCLUSIVE.
1624: */
1625: #define SQLITE_SHM_UNLOCK 1
1626: #define SQLITE_SHM_LOCK 2
1627: #define SQLITE_SHM_SHARED 4
1628: #define SQLITE_SHM_EXCLUSIVE 8
1629:
1630: /*
1631: ** CAPI3REF: Maximum xShmLock index
1632: **
1633: ** The xShmLock method on [sqlite3_io_methods] may use values
1634: ** between 0 and this upper bound as its "offset" argument.
1635: ** The SQLite core will never attempt to acquire or release a
1636: ** lock outside of this range
1637: */
1638: #define SQLITE_SHM_NLOCK 8
1639:
1640:
1641: /*
1642: ** CAPI3REF: Initialize The SQLite Library
1643: **
1644: ** ^The sqlite3_initialize() routine initializes the
1645: ** SQLite library. ^The sqlite3_shutdown() routine
1646: ** deallocates any resources that were allocated by sqlite3_initialize().
1647: ** These routines are designed to aid in process initialization and
1648: ** shutdown on embedded systems. Workstation applications using
1649: ** SQLite normally do not need to invoke either of these routines.
1650: **
1651: ** A call to sqlite3_initialize() is an "effective" call if it is
1652: ** the first time sqlite3_initialize() is invoked during the lifetime of
1653: ** the process, or if it is the first time sqlite3_initialize() is invoked
1654: ** following a call to sqlite3_shutdown(). ^(Only an effective call
1655: ** of sqlite3_initialize() does any initialization. All other calls
1656: ** are harmless no-ops.)^
1657: **
1658: ** A call to sqlite3_shutdown() is an "effective" call if it is the first
1659: ** call to sqlite3_shutdown() since the last sqlite3_initialize(). ^(Only
1660: ** an effective call to sqlite3_shutdown() does any deinitialization.
1661: ** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^
1662: **
1663: ** The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown()
1664: ** is not. The sqlite3_shutdown() interface must only be called from a
1665: ** single thread. All open [database connections] must be closed and all
1666: ** other SQLite resources must be deallocated prior to invoking
1667: ** sqlite3_shutdown().
1668: **
1669: ** Among other things, ^sqlite3_initialize() will invoke
1670: ** sqlite3_os_init(). Similarly, ^sqlite3_shutdown()
1671: ** will invoke sqlite3_os_end().
1672: **
1673: ** ^The sqlite3_initialize() routine returns [SQLITE_OK] on success.
1674: ** ^If for some reason, sqlite3_initialize() is unable to initialize
1675: ** the library (perhaps it is unable to allocate a needed resource such
1676: ** as a mutex) it returns an [error code] other than [SQLITE_OK].
1677: **
1678: ** ^The sqlite3_initialize() routine is called internally by many other
1679: ** SQLite interfaces so that an application usually does not need to
1680: ** invoke sqlite3_initialize() directly. For example, [sqlite3_open()]
1681: ** calls sqlite3_initialize() so the SQLite library will be automatically
1682: ** initialized when [sqlite3_open()] is called if it has not be initialized
1683: ** already. ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT]
1684: ** compile-time option, then the automatic calls to sqlite3_initialize()
1685: ** are omitted and the application must call sqlite3_initialize() directly
1686: ** prior to using any other SQLite interface. For maximum portability,
1687: ** it is recommended that applications always invoke sqlite3_initialize()
1688: ** directly prior to using any other SQLite interface. Future releases
1689: ** of SQLite may require this. In other words, the behavior exhibited
1690: ** when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the
1691: ** default behavior in some future release of SQLite.
1692: **
1693: ** The sqlite3_os_init() routine does operating-system specific
1694: ** initialization of the SQLite library. The sqlite3_os_end()
1695: ** routine undoes the effect of sqlite3_os_init(). Typical tasks
1696: ** performed by these routines include allocation or deallocation
1697: ** of static resources, initialization of global variables,
1698: ** setting up a default [sqlite3_vfs] module, or setting up
1699: ** a default configuration using [sqlite3_config()].
1700: **
1701: ** The application should never invoke either sqlite3_os_init()
1702: ** or sqlite3_os_end() directly. The application should only invoke
1703: ** sqlite3_initialize() and sqlite3_shutdown(). The sqlite3_os_init()
1704: ** interface is called automatically by sqlite3_initialize() and
1705: ** sqlite3_os_end() is called by sqlite3_shutdown(). Appropriate
1706: ** implementations for sqlite3_os_init() and sqlite3_os_end()
1707: ** are built into SQLite when it is compiled for Unix, Windows, or OS/2.
1708: ** When [custom builds | built for other platforms]
1709: ** (using the [SQLITE_OS_OTHER=1] compile-time
1710: ** option) the application must supply a suitable implementation for
1711: ** sqlite3_os_init() and sqlite3_os_end(). An application-supplied
1712: ** implementation of sqlite3_os_init() or sqlite3_os_end()
1713: ** must return [SQLITE_OK] on success and some other [error code] upon
1714: ** failure.
1715: */
1716: SQLITE_API int sqlite3_initialize(void);
1717: SQLITE_API int sqlite3_shutdown(void);
1718: SQLITE_API int sqlite3_os_init(void);
1719: SQLITE_API int sqlite3_os_end(void);
1720:
1721: /*
1722: ** CAPI3REF: Configuring The SQLite Library
1723: **
1724: ** The sqlite3_config() interface is used to make global configuration
1725: ** changes to SQLite in order to tune SQLite to the specific needs of
1726: ** the application. The default configuration is recommended for most
1727: ** applications and so this routine is usually not necessary. It is
1728: ** provided to support rare applications with unusual needs.
1729: **
1730: ** The sqlite3_config() interface is not threadsafe. The application
1731: ** must insure that no other SQLite interfaces are invoked by other
1732: ** threads while sqlite3_config() is running. Furthermore, sqlite3_config()
1733: ** may only be invoked prior to library initialization using
1734: ** [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()].
1735: ** ^If sqlite3_config() is called after [sqlite3_initialize()] and before
1736: ** [sqlite3_shutdown()] then it will return SQLITE_MISUSE.
1737: ** Note, however, that ^sqlite3_config() can be called as part of the
1738: ** implementation of an application-defined [sqlite3_os_init()].
1739: **
1740: ** The first argument to sqlite3_config() is an integer
1741: ** [configuration option] that determines
1742: ** what property of SQLite is to be configured. Subsequent arguments
1743: ** vary depending on the [configuration option]
1744: ** in the first argument.
1745: **
1746: ** ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
1747: ** ^If the option is unknown or SQLite is unable to set the option
1748: ** then this routine returns a non-zero [error code].
1749: */
1750: SQLITE_API int sqlite3_config(int, ...);
1751:
1752: /*
1753: ** CAPI3REF: Configure database connections
1754: **
1755: ** The sqlite3_db_config() interface is used to make configuration
1756: ** changes to a [database connection]. The interface is similar to
1757: ** [sqlite3_config()] except that the changes apply to a single
1758: ** [database connection] (specified in the first argument).
1759: **
1760: ** The second argument to sqlite3_db_config(D,V,...) is the
1761: ** [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code
1762: ** that indicates what aspect of the [database connection] is being configured.
1763: ** Subsequent arguments vary depending on the configuration verb.
1764: **
1765: ** ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
1766: ** the call is considered successful.
1767: */
1768: SQLITE_API int sqlite3_db_config(sqlite3*, int op, ...);
1769:
1770: /*
1771: ** CAPI3REF: Memory Allocation Routines
1772: **
1773: ** An instance of this object defines the interface between SQLite
1774: ** and low-level memory allocation routines.
1775: **
1776: ** This object is used in only one place in the SQLite interface.
1777: ** A pointer to an instance of this object is the argument to
1778: ** [sqlite3_config()] when the configuration option is
1779: ** [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC].
1780: ** By creating an instance of this object
1781: ** and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC])
1782: ** during configuration, an application can specify an alternative
1783: ** memory allocation subsystem for SQLite to use for all of its
1784: ** dynamic memory needs.
1785: **
1786: ** Note that SQLite comes with several [built-in memory allocators]
1787: ** that are perfectly adequate for the overwhelming majority of applications
1788: ** and that this object is only useful to a tiny minority of applications
1789: ** with specialized memory allocation requirements. This object is
1790: ** also used during testing of SQLite in order to specify an alternative
1791: ** memory allocator that simulates memory out-of-memory conditions in
1792: ** order to verify that SQLite recovers gracefully from such
1793: ** conditions.
1794: **
1795: ** The xMalloc, xRealloc, and xFree methods must work like the
1796: ** malloc(), realloc() and free() functions from the standard C library.
1797: ** ^SQLite guarantees that the second argument to
1798: ** xRealloc is always a value returned by a prior call to xRoundup.
1799: **
1800: ** xSize should return the allocated size of a memory allocation
1801: ** previously obtained from xMalloc or xRealloc. The allocated size
1802: ** is always at least as big as the requested size but may be larger.
1803: **
1804: ** The xRoundup method returns what would be the allocated size of
1805: ** a memory allocation given a particular requested size. Most memory
1806: ** allocators round up memory allocations at least to the next multiple
1807: ** of 8. Some allocators round up to a larger multiple or to a power of 2.
1808: ** Every memory allocation request coming in through [sqlite3_malloc()]
1809: ** or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0,
1810: ** that causes the corresponding memory allocation to fail.
1811: **
1812: ** The xInit method initializes the memory allocator. (For example,
1813: ** it might allocate any require mutexes or initialize internal data
1814: ** structures. The xShutdown method is invoked (indirectly) by
1815: ** [sqlite3_shutdown()] and should deallocate any resources acquired
1816: ** by xInit. The pAppData pointer is used as the only parameter to
1817: ** xInit and xShutdown.
1818: **
1819: ** SQLite holds the [SQLITE_MUTEX_STATIC_MASTER] mutex when it invokes
1820: ** the xInit method, so the xInit method need not be threadsafe. The
1821: ** xShutdown method is only called from [sqlite3_shutdown()] so it does
1822: ** not need to be threadsafe either. For all other methods, SQLite
1823: ** holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the
1824: ** [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which
1825: ** it is by default) and so the methods are automatically serialized.
1826: ** However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other
1827: ** methods must be threadsafe or else make their own arrangements for
1828: ** serialization.
1829: **
1830: ** SQLite will never invoke xInit() more than once without an intervening
1831: ** call to xShutdown().
1832: */
1833: typedef struct sqlite3_mem_methods sqlite3_mem_methods;
1834: struct sqlite3_mem_methods {
1835: void *(*xMalloc)(int); /* Memory allocation function */
1836: void (*xFree)(void*); /* Free a prior allocation */
1837: void *(*xRealloc)(void*,int); /* Resize an allocation */
1838: int (*xSize)(void*); /* Return the size of an allocation */
1839: int (*xRoundup)(int); /* Round up request size to allocation size */
1840: int (*xInit)(void*); /* Initialize the memory allocator */
1841: void (*xShutdown)(void*); /* Deinitialize the memory allocator */
1842: void *pAppData; /* Argument to xInit() and xShutdown() */
1843: };
1844:
1845: /*
1846: ** CAPI3REF: Configuration Options
1847: ** KEYWORDS: {configuration option}
1848: **
1849: ** These constants are the available integer configuration options that
1850: ** can be passed as the first argument to the [sqlite3_config()] interface.
1851: **
1852: ** New configuration options may be added in future releases of SQLite.
1853: ** Existing configuration options might be discontinued. Applications
1854: ** should check the return code from [sqlite3_config()] to make sure that
1855: ** the call worked. The [sqlite3_config()] interface will return a
1856: ** non-zero [error code] if a discontinued or unsupported configuration option
1857: ** is invoked.
1858: **
1859: ** <dl>
1860: ** [[SQLITE_CONFIG_SINGLETHREAD]] <dt>SQLITE_CONFIG_SINGLETHREAD</dt>
1861: ** <dd>There are no arguments to this option. ^This option sets the
1862: ** [threading mode] to Single-thread. In other words, it disables
1863: ** all mutexing and puts SQLite into a mode where it can only be used
1864: ** by a single thread. ^If SQLite is compiled with
1865: ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1866: ** it is not possible to change the [threading mode] from its default
1867: ** value of Single-thread and so [sqlite3_config()] will return
1868: ** [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD
1869: ** configuration option.</dd>
1870: **
1871: ** [[SQLITE_CONFIG_MULTITHREAD]] <dt>SQLITE_CONFIG_MULTITHREAD</dt>
1872: ** <dd>There are no arguments to this option. ^This option sets the
1873: ** [threading mode] to Multi-thread. In other words, it disables
1874: ** mutexing on [database connection] and [prepared statement] objects.
1875: ** The application is responsible for serializing access to
1876: ** [database connections] and [prepared statements]. But other mutexes
1877: ** are enabled so that SQLite will be safe to use in a multi-threaded
1878: ** environment as long as no two threads attempt to use the same
1879: ** [database connection] at the same time. ^If SQLite is compiled with
1880: ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1881: ** it is not possible to set the Multi-thread [threading mode] and
1882: ** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
1883: ** SQLITE_CONFIG_MULTITHREAD configuration option.</dd>
1884: **
1885: ** [[SQLITE_CONFIG_SERIALIZED]] <dt>SQLITE_CONFIG_SERIALIZED</dt>
1886: ** <dd>There are no arguments to this option. ^This option sets the
1887: ** [threading mode] to Serialized. In other words, this option enables
1888: ** all mutexes including the recursive
1889: ** mutexes on [database connection] and [prepared statement] objects.
1890: ** In this mode (which is the default when SQLite is compiled with
1891: ** [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access
1892: ** to [database connections] and [prepared statements] so that the
1893: ** application is free to use the same [database connection] or the
1894: ** same [prepared statement] in different threads at the same time.
1895: ** ^If SQLite is compiled with
1896: ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1897: ** it is not possible to set the Serialized [threading mode] and
1898: ** [sqlite3_config()] will return [SQLITE_ERROR] if called with the
1899: ** SQLITE_CONFIG_SERIALIZED configuration option.</dd>
1900: **
1901: ** [[SQLITE_CONFIG_MALLOC]] <dt>SQLITE_CONFIG_MALLOC</dt>
1902: ** <dd> ^(This option takes a single argument which is a pointer to an
1903: ** instance of the [sqlite3_mem_methods] structure. The argument specifies
1904: ** alternative low-level memory allocation routines to be used in place of
1905: ** the memory allocation routines built into SQLite.)^ ^SQLite makes
1906: ** its own private copy of the content of the [sqlite3_mem_methods] structure
1907: ** before the [sqlite3_config()] call returns.</dd>
1908: **
1909: ** [[SQLITE_CONFIG_GETMALLOC]] <dt>SQLITE_CONFIG_GETMALLOC</dt>
1910: ** <dd> ^(This option takes a single argument which is a pointer to an
1911: ** instance of the [sqlite3_mem_methods] structure. The [sqlite3_mem_methods]
1912: ** structure is filled with the currently defined memory allocation routines.)^
1913: ** This option can be used to overload the default memory allocation
1914: ** routines with a wrapper that simulations memory allocation failure or
1915: ** tracks memory usage, for example. </dd>
1916: **
1917: ** [[SQLITE_CONFIG_MEMSTATUS]] <dt>SQLITE_CONFIG_MEMSTATUS</dt>
1918: ** <dd> ^This option takes single argument of type int, interpreted as a
1919: ** boolean, which enables or disables the collection of memory allocation
1920: ** statistics. ^(When memory allocation statistics are disabled, the
1921: ** following SQLite interfaces become non-operational:
1922: ** <ul>
1923: ** <li> [sqlite3_memory_used()]
1924: ** <li> [sqlite3_memory_highwater()]
1925: ** <li> [sqlite3_soft_heap_limit64()]
1926: ** <li> [sqlite3_status()]
1927: ** </ul>)^
1928: ** ^Memory allocation statistics are enabled by default unless SQLite is
1929: ** compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory
1930: ** allocation statistics are disabled by default.
1931: ** </dd>
1932: **
1933: ** [[SQLITE_CONFIG_SCRATCH]] <dt>SQLITE_CONFIG_SCRATCH</dt>
1934: ** <dd> ^This option specifies a static memory buffer that SQLite can use for
1935: ** scratch memory. There are three arguments: A pointer an 8-byte
1936: ** aligned memory buffer from which the scratch allocations will be
1937: ** drawn, the size of each scratch allocation (sz),
1938: ** and the maximum number of scratch allocations (N). The sz
1939: ** argument must be a multiple of 16.
1940: ** The first argument must be a pointer to an 8-byte aligned buffer
1941: ** of at least sz*N bytes of memory.
1942: ** ^SQLite will use no more than two scratch buffers per thread. So
1943: ** N should be set to twice the expected maximum number of threads.
1944: ** ^SQLite will never require a scratch buffer that is more than 6
1945: ** times the database page size. ^If SQLite needs needs additional
1946: ** scratch memory beyond what is provided by this configuration option, then
1947: ** [sqlite3_malloc()] will be used to obtain the memory needed.</dd>
1948: **
1949: ** [[SQLITE_CONFIG_PAGECACHE]] <dt>SQLITE_CONFIG_PAGECACHE</dt>
1950: ** <dd> ^This option specifies a static memory buffer that SQLite can use for
1951: ** the database page cache with the default page cache implementation.
1952: ** This configuration should not be used if an application-define page
1953: ** cache implementation is loaded using the SQLITE_CONFIG_PCACHE2 option.
1954: ** There are three arguments to this option: A pointer to 8-byte aligned
1955: ** memory, the size of each page buffer (sz), and the number of pages (N).
1956: ** The sz argument should be the size of the largest database page
1957: ** (a power of two between 512 and 32768) plus a little extra for each
1958: ** page header. ^The page header size is 20 to 40 bytes depending on
1959: ** the host architecture. ^It is harmless, apart from the wasted memory,
1960: ** to make sz a little too large. The first
1961: ** argument should point to an allocation of at least sz*N bytes of memory.
1962: ** ^SQLite will use the memory provided by the first argument to satisfy its
1963: ** memory needs for the first N pages that it adds to cache. ^If additional
1964: ** page cache memory is needed beyond what is provided by this option, then
1965: ** SQLite goes to [sqlite3_malloc()] for the additional storage space.
1966: ** The pointer in the first argument must
1967: ** be aligned to an 8-byte boundary or subsequent behavior of SQLite
1968: ** will be undefined.</dd>
1969: **
1970: ** [[SQLITE_CONFIG_HEAP]] <dt>SQLITE_CONFIG_HEAP</dt>
1971: ** <dd> ^This option specifies a static memory buffer that SQLite will use
1972: ** for all of its dynamic memory allocation needs beyond those provided
1973: ** for by [SQLITE_CONFIG_SCRATCH] and [SQLITE_CONFIG_PAGECACHE].
1974: ** There are three arguments: An 8-byte aligned pointer to the memory,
1975: ** the number of bytes in the memory buffer, and the minimum allocation size.
1976: ** ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
1977: ** to using its default memory allocator (the system malloc() implementation),
1978: ** undoing any prior invocation of [SQLITE_CONFIG_MALLOC]. ^If the
1979: ** memory pointer is not NULL and either [SQLITE_ENABLE_MEMSYS3] or
1980: ** [SQLITE_ENABLE_MEMSYS5] are defined, then the alternative memory
1981: ** allocator is engaged to handle all of SQLites memory allocation needs.
1982: ** The first pointer (the memory pointer) must be aligned to an 8-byte
1983: ** boundary or subsequent behavior of SQLite will be undefined.
1984: ** The minimum allocation size is capped at 2**12. Reasonable values
1985: ** for the minimum allocation size are 2**5 through 2**8.</dd>
1986: **
1987: ** [[SQLITE_CONFIG_MUTEX]] <dt>SQLITE_CONFIG_MUTEX</dt>
1988: ** <dd> ^(This option takes a single argument which is a pointer to an
1989: ** instance of the [sqlite3_mutex_methods] structure. The argument specifies
1990: ** alternative low-level mutex routines to be used in place
1991: ** the mutex routines built into SQLite.)^ ^SQLite makes a copy of the
1992: ** content of the [sqlite3_mutex_methods] structure before the call to
1993: ** [sqlite3_config()] returns. ^If SQLite is compiled with
1994: ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
1995: ** the entire mutexing subsystem is omitted from the build and hence calls to
1996: ** [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will
1997: ** return [SQLITE_ERROR].</dd>
1998: **
1999: ** [[SQLITE_CONFIG_GETMUTEX]] <dt>SQLITE_CONFIG_GETMUTEX</dt>
2000: ** <dd> ^(This option takes a single argument which is a pointer to an
2001: ** instance of the [sqlite3_mutex_methods] structure. The
2002: ** [sqlite3_mutex_methods]
2003: ** structure is filled with the currently defined mutex routines.)^
2004: ** This option can be used to overload the default mutex allocation
2005: ** routines with a wrapper used to track mutex usage for performance
2006: ** profiling or testing, for example. ^If SQLite is compiled with
2007: ** the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
2008: ** the entire mutexing subsystem is omitted from the build and hence calls to
2009: ** [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will
2010: ** return [SQLITE_ERROR].</dd>
2011: **
2012: ** [[SQLITE_CONFIG_LOOKASIDE]] <dt>SQLITE_CONFIG_LOOKASIDE</dt>
2013: ** <dd> ^(This option takes two arguments that determine the default
2014: ** memory allocation for the lookaside memory allocator on each
2015: ** [database connection]. The first argument is the
2016: ** size of each lookaside buffer slot and the second is the number of
2017: ** slots allocated to each database connection.)^ ^(This option sets the
2018: ** <i>default</i> lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE]
2019: ** verb to [sqlite3_db_config()] can be used to change the lookaside
2020: ** configuration on individual connections.)^ </dd>
2021: **
2022: ** [[SQLITE_CONFIG_PCACHE2]] <dt>SQLITE_CONFIG_PCACHE2</dt>
2023: ** <dd> ^(This option takes a single argument which is a pointer to
2024: ** an [sqlite3_pcache_methods2] object. This object specifies the interface
2025: ** to a custom page cache implementation.)^ ^SQLite makes a copy of the
2026: ** object and uses it for page cache memory allocations.</dd>
2027: **
2028: ** [[SQLITE_CONFIG_GETPCACHE2]] <dt>SQLITE_CONFIG_GETPCACHE2</dt>
2029: ** <dd> ^(This option takes a single argument which is a pointer to an
2030: ** [sqlite3_pcache_methods2] object. SQLite copies of the current
2031: ** page cache implementation into that object.)^ </dd>
2032: **
2033: ** [[SQLITE_CONFIG_LOG]] <dt>SQLITE_CONFIG_LOG</dt>
2034: ** <dd> ^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a
2035: ** function with a call signature of void(*)(void*,int,const char*),
2036: ** and a pointer to void. ^If the function pointer is not NULL, it is
2037: ** invoked by [sqlite3_log()] to process each logging event. ^If the
2038: ** function pointer is NULL, the [sqlite3_log()] interface becomes a no-op.
2039: ** ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is
2040: ** passed through as the first parameter to the application-defined logger
2041: ** function whenever that function is invoked. ^The second parameter to
2042: ** the logger function is a copy of the first parameter to the corresponding
2043: ** [sqlite3_log()] call and is intended to be a [result code] or an
2044: ** [extended result code]. ^The third parameter passed to the logger is
2045: ** log message after formatting via [sqlite3_snprintf()].
2046: ** The SQLite logging interface is not reentrant; the logger function
2047: ** supplied by the application must not invoke any SQLite interface.
2048: ** In a multi-threaded application, the application-defined logger
2049: ** function must be threadsafe. </dd>
2050: **
2051: ** [[SQLITE_CONFIG_URI]] <dt>SQLITE_CONFIG_URI
2052: ** <dd> This option takes a single argument of type int. If non-zero, then
2053: ** URI handling is globally enabled. If the parameter is zero, then URI handling
2054: ** is globally disabled. If URI handling is globally enabled, all filenames
2055: ** passed to [sqlite3_open()], [sqlite3_open_v2()], [sqlite3_open16()] or
2056: ** specified as part of [ATTACH] commands are interpreted as URIs, regardless
2057: ** of whether or not the [SQLITE_OPEN_URI] flag is set when the database
2058: ** connection is opened. If it is globally disabled, filenames are
2059: ** only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the
2060: ** database connection is opened. By default, URI handling is globally
2061: ** disabled. The default value may be changed by compiling with the
2062: ** [SQLITE_USE_URI] symbol defined.
2063: **
2064: ** [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]]
2065: ** <dt>SQLITE_CONFIG_PCACHE and SQLITE_CONFNIG_GETPCACHE
2066: ** <dd> These options are obsolete and should not be used by new code.
2067: ** They are retained for backwards compatibility but are now no-ops.
2068: ** </dl>
2069: */
2070: #define SQLITE_CONFIG_SINGLETHREAD 1 /* nil */
2071: #define SQLITE_CONFIG_MULTITHREAD 2 /* nil */
2072: #define SQLITE_CONFIG_SERIALIZED 3 /* nil */
2073: #define SQLITE_CONFIG_MALLOC 4 /* sqlite3_mem_methods* */
2074: #define SQLITE_CONFIG_GETMALLOC 5 /* sqlite3_mem_methods* */
2075: #define SQLITE_CONFIG_SCRATCH 6 /* void*, int sz, int N */
2076: #define SQLITE_CONFIG_PAGECACHE 7 /* void*, int sz, int N */
2077: #define SQLITE_CONFIG_HEAP 8 /* void*, int nByte, int min */
2078: #define SQLITE_CONFIG_MEMSTATUS 9 /* boolean */
2079: #define SQLITE_CONFIG_MUTEX 10 /* sqlite3_mutex_methods* */
2080: #define SQLITE_CONFIG_GETMUTEX 11 /* sqlite3_mutex_methods* */
2081: /* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */
2082: #define SQLITE_CONFIG_LOOKASIDE 13 /* int int */
2083: #define SQLITE_CONFIG_PCACHE 14 /* no-op */
2084: #define SQLITE_CONFIG_GETPCACHE 15 /* no-op */
2085: #define SQLITE_CONFIG_LOG 16 /* xFunc, void* */
2086: #define SQLITE_CONFIG_URI 17 /* int */
2087: #define SQLITE_CONFIG_PCACHE2 18 /* sqlite3_pcache_methods2* */
2088: #define SQLITE_CONFIG_GETPCACHE2 19 /* sqlite3_pcache_methods2* */
2089:
2090: /*
2091: ** CAPI3REF: Database Connection Configuration Options
2092: **
2093: ** These constants are the available integer configuration options that
2094: ** can be passed as the second argument to the [sqlite3_db_config()] interface.
2095: **
2096: ** New configuration options may be added in future releases of SQLite.
2097: ** Existing configuration options might be discontinued. Applications
2098: ** should check the return code from [sqlite3_db_config()] to make sure that
2099: ** the call worked. ^The [sqlite3_db_config()] interface will return a
2100: ** non-zero [error code] if a discontinued or unsupported configuration option
2101: ** is invoked.
2102: **
2103: ** <dl>
2104: ** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>
2105: ** <dd> ^This option takes three additional arguments that determine the
2106: ** [lookaside memory allocator] configuration for the [database connection].
2107: ** ^The first argument (the third parameter to [sqlite3_db_config()] is a
2108: ** pointer to a memory buffer to use for lookaside memory.
2109: ** ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb
2110: ** may be NULL in which case SQLite will allocate the
2111: ** lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the
2112: ** size of each lookaside buffer slot. ^The third argument is the number of
2113: ** slots. The size of the buffer in the first argument must be greater than
2114: ** or equal to the product of the second and third arguments. The buffer
2115: ** must be aligned to an 8-byte boundary. ^If the second argument to
2116: ** SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
2117: ** rounded down to the next smaller multiple of 8. ^(The lookaside memory
2118: ** configuration for a database connection can only be changed when that
2119: ** connection is not currently using lookaside memory, or in other words
2120: ** when the "current value" returned by
2121: ** [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero.
2122: ** Any attempt to change the lookaside memory configuration when lookaside
2123: ** memory is in use leaves the configuration unchanged and returns
2124: ** [SQLITE_BUSY].)^</dd>
2125: **
2126: ** <dt>SQLITE_DBCONFIG_ENABLE_FKEY</dt>
2127: ** <dd> ^This option is used to enable or disable the enforcement of
2128: ** [foreign key constraints]. There should be two additional arguments.
2129: ** The first argument is an integer which is 0 to disable FK enforcement,
2130: ** positive to enable FK enforcement or negative to leave FK enforcement
2131: ** unchanged. The second parameter is a pointer to an integer into which
2132: ** is written 0 or 1 to indicate whether FK enforcement is off or on
2133: ** following this call. The second parameter may be a NULL pointer, in
2134: ** which case the FK enforcement setting is not reported back. </dd>
2135: **
2136: ** <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt>
2137: ** <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers].
2138: ** There should be two additional arguments.
2139: ** The first argument is an integer which is 0 to disable triggers,
2140: ** positive to enable triggers or negative to leave the setting unchanged.
2141: ** The second parameter is a pointer to an integer into which
2142: ** is written 0 or 1 to indicate whether triggers are disabled or enabled
2143: ** following this call. The second parameter may be a NULL pointer, in
2144: ** which case the trigger setting is not reported back. </dd>
2145: **
2146: ** </dl>
2147: */
2148: #define SQLITE_DBCONFIG_LOOKASIDE 1001 /* void* int int */
2149: #define SQLITE_DBCONFIG_ENABLE_FKEY 1002 /* int int* */
2150: #define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 /* int int* */
2151:
2152:
2153: /*
2154: ** CAPI3REF: Enable Or Disable Extended Result Codes
2155: **
2156: ** ^The sqlite3_extended_result_codes() routine enables or disables the
2157: ** [extended result codes] feature of SQLite. ^The extended result
2158: ** codes are disabled by default for historical compatibility.
2159: */
2160: SQLITE_API int sqlite3_extended_result_codes(sqlite3*, int onoff);
2161:
2162: /*
2163: ** CAPI3REF: Last Insert Rowid
2164: **
2165: ** ^Each entry in an SQLite table has a unique 64-bit signed
2166: ** integer key called the [ROWID | "rowid"]. ^The rowid is always available
2167: ** as an undeclared column named ROWID, OID, or _ROWID_ as long as those
2168: ** names are not also used by explicitly declared columns. ^If
2169: ** the table has a column of type [INTEGER PRIMARY KEY] then that column
2170: ** is another alias for the rowid.
2171: **
2172: ** ^This routine returns the [rowid] of the most recent
2173: ** successful [INSERT] into the database from the [database connection]
2174: ** in the first argument. ^As of SQLite version 3.7.7, this routines
2175: ** records the last insert rowid of both ordinary tables and [virtual tables].
2176: ** ^If no successful [INSERT]s
2177: ** have ever occurred on that database connection, zero is returned.
2178: **
2179: ** ^(If an [INSERT] occurs within a trigger or within a [virtual table]
2180: ** method, then this routine will return the [rowid] of the inserted
2181: ** row as long as the trigger or virtual table method is running.
2182: ** But once the trigger or virtual table method ends, the value returned
2183: ** by this routine reverts to what it was before the trigger or virtual
2184: ** table method began.)^
2185: **
2186: ** ^An [INSERT] that fails due to a constraint violation is not a
2187: ** successful [INSERT] and does not change the value returned by this
2188: ** routine. ^Thus INSERT OR FAIL, INSERT OR IGNORE, INSERT OR ROLLBACK,
2189: ** and INSERT OR ABORT make no changes to the return value of this
2190: ** routine when their insertion fails. ^(When INSERT OR REPLACE
2191: ** encounters a constraint violation, it does not fail. The
2192: ** INSERT continues to completion after deleting rows that caused
2193: ** the constraint problem so INSERT OR REPLACE will always change
2194: ** the return value of this interface.)^
2195: **
2196: ** ^For the purposes of this routine, an [INSERT] is considered to
2197: ** be successful even if it is subsequently rolled back.
2198: **
2199: ** This function is accessible to SQL statements via the
2200: ** [last_insert_rowid() SQL function].
2201: **
2202: ** If a separate thread performs a new [INSERT] on the same
2203: ** database connection while the [sqlite3_last_insert_rowid()]
2204: ** function is running and thus changes the last insert [rowid],
2205: ** then the value returned by [sqlite3_last_insert_rowid()] is
2206: ** unpredictable and might not equal either the old or the new
2207: ** last insert [rowid].
2208: */
2209: SQLITE_API sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);
2210:
2211: /*
2212: ** CAPI3REF: Count The Number Of Rows Modified
2213: **
2214: ** ^This function returns the number of database rows that were changed
2215: ** or inserted or deleted by the most recently completed SQL statement
2216: ** on the [database connection] specified by the first parameter.
2217: ** ^(Only changes that are directly specified by the [INSERT], [UPDATE],
2218: ** or [DELETE] statement are counted. Auxiliary changes caused by
2219: ** triggers or [foreign key actions] are not counted.)^ Use the
2220: ** [sqlite3_total_changes()] function to find the total number of changes
2221: ** including changes caused by triggers and foreign key actions.
2222: **
2223: ** ^Changes to a view that are simulated by an [INSTEAD OF trigger]
2224: ** are not counted. Only real table changes are counted.
2225: **
2226: ** ^(A "row change" is a change to a single row of a single table
2227: ** caused by an INSERT, DELETE, or UPDATE statement. Rows that
2228: ** are changed as side effects of [REPLACE] constraint resolution,
2229: ** rollback, ABORT processing, [DROP TABLE], or by any other
2230: ** mechanisms do not count as direct row changes.)^
2231: **
2232: ** A "trigger context" is a scope of execution that begins and
2233: ** ends with the script of a [CREATE TRIGGER | trigger].
2234: ** Most SQL statements are
2235: ** evaluated outside of any trigger. This is the "top level"
2236: ** trigger context. If a trigger fires from the top level, a
2237: ** new trigger context is entered for the duration of that one
2238: ** trigger. Subtriggers create subcontexts for their duration.
2239: **
2240: ** ^Calling [sqlite3_exec()] or [sqlite3_step()] recursively does
2241: ** not create a new trigger context.
2242: **
2243: ** ^This function returns the number of direct row changes in the
2244: ** most recent INSERT, UPDATE, or DELETE statement within the same
2245: ** trigger context.
2246: **
2247: ** ^Thus, when called from the top level, this function returns the
2248: ** number of changes in the most recent INSERT, UPDATE, or DELETE
2249: ** that also occurred at the top level. ^(Within the body of a trigger,
2250: ** the sqlite3_changes() interface can be called to find the number of
2251: ** changes in the most recently completed INSERT, UPDATE, or DELETE
2252: ** statement within the body of the same trigger.
2253: ** However, the number returned does not include changes
2254: ** caused by subtriggers since those have their own context.)^
2255: **
2256: ** See also the [sqlite3_total_changes()] interface, the
2257: ** [count_changes pragma], and the [changes() SQL function].
2258: **
2259: ** If a separate thread makes changes on the same database connection
2260: ** while [sqlite3_changes()] is running then the value returned
2261: ** is unpredictable and not meaningful.
2262: */
2263: SQLITE_API int sqlite3_changes(sqlite3*);
2264:
2265: /*
2266: ** CAPI3REF: Total Number Of Rows Modified
2267: **
2268: ** ^This function returns the number of row changes caused by [INSERT],
2269: ** [UPDATE] or [DELETE] statements since the [database connection] was opened.
2270: ** ^(The count returned by sqlite3_total_changes() includes all changes
2271: ** from all [CREATE TRIGGER | trigger] contexts and changes made by
2272: ** [foreign key actions]. However,
2273: ** the count does not include changes used to implement [REPLACE] constraints,
2274: ** do rollbacks or ABORT processing, or [DROP TABLE] processing. The
2275: ** count does not include rows of views that fire an [INSTEAD OF trigger],
2276: ** though if the INSTEAD OF trigger makes changes of its own, those changes
2277: ** are counted.)^
2278: ** ^The sqlite3_total_changes() function counts the changes as soon as
2279: ** the statement that makes them is completed (when the statement handle
2280: ** is passed to [sqlite3_reset()] or [sqlite3_finalize()]).
2281: **
2282: ** See also the [sqlite3_changes()] interface, the
2283: ** [count_changes pragma], and the [total_changes() SQL function].
2284: **
2285: ** If a separate thread makes changes on the same database connection
2286: ** while [sqlite3_total_changes()] is running then the value
2287: ** returned is unpredictable and not meaningful.
2288: */
2289: SQLITE_API int sqlite3_total_changes(sqlite3*);
2290:
2291: /*
2292: ** CAPI3REF: Interrupt A Long-Running Query
2293: **
2294: ** ^This function causes any pending database operation to abort and
2295: ** return at its earliest opportunity. This routine is typically
2296: ** called in response to a user action such as pressing "Cancel"
2297: ** or Ctrl-C where the user wants a long query operation to halt
2298: ** immediately.
2299: **
2300: ** ^It is safe to call this routine from a thread different from the
2301: ** thread that is currently running the database operation. But it
2302: ** is not safe to call this routine with a [database connection] that
2303: ** is closed or might close before sqlite3_interrupt() returns.
2304: **
2305: ** ^If an SQL operation is very nearly finished at the time when
2306: ** sqlite3_interrupt() is called, then it might not have an opportunity
2307: ** to be interrupted and might continue to completion.
2308: **
2309: ** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT].
2310: ** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE
2311: ** that is inside an explicit transaction, then the entire transaction
2312: ** will be rolled back automatically.
2313: **
2314: ** ^The sqlite3_interrupt(D) call is in effect until all currently running
2315: ** SQL statements on [database connection] D complete. ^Any new SQL statements
2316: ** that are started after the sqlite3_interrupt() call and before the
2317: ** running statements reaches zero are interrupted as if they had been
2318: ** running prior to the sqlite3_interrupt() call. ^New SQL statements
2319: ** that are started after the running statement count reaches zero are
2320: ** not effected by the sqlite3_interrupt().
2321: ** ^A call to sqlite3_interrupt(D) that occurs when there are no running
2322: ** SQL statements is a no-op and has no effect on SQL statements
2323: ** that are started after the sqlite3_interrupt() call returns.
2324: **
2325: ** If the database connection closes while [sqlite3_interrupt()]
2326: ** is running then bad things will likely happen.
2327: */
2328: SQLITE_API void sqlite3_interrupt(sqlite3*);
2329:
2330: /*
2331: ** CAPI3REF: Determine If An SQL Statement Is Complete
2332: **
2333: ** These routines are useful during command-line input to determine if the
2334: ** currently entered text seems to form a complete SQL statement or
2335: ** if additional input is needed before sending the text into
2336: ** SQLite for parsing. ^These routines return 1 if the input string
2337: ** appears to be a complete SQL statement. ^A statement is judged to be
2338: ** complete if it ends with a semicolon token and is not a prefix of a
2339: ** well-formed CREATE TRIGGER statement. ^Semicolons that are embedded within
2340: ** string literals or quoted identifier names or comments are not
2341: ** independent tokens (they are part of the token in which they are
2342: ** embedded) and thus do not count as a statement terminator. ^Whitespace
2343: ** and comments that follow the final semicolon are ignored.
2344: **
2345: ** ^These routines return 0 if the statement is incomplete. ^If a
2346: ** memory allocation fails, then SQLITE_NOMEM is returned.
2347: **
2348: ** ^These routines do not parse the SQL statements thus
2349: ** will not detect syntactically incorrect SQL.
2350: **
2351: ** ^(If SQLite has not been initialized using [sqlite3_initialize()] prior
2352: ** to invoking sqlite3_complete16() then sqlite3_initialize() is invoked
2353: ** automatically by sqlite3_complete16(). If that initialization fails,
2354: ** then the return value from sqlite3_complete16() will be non-zero
2355: ** regardless of whether or not the input SQL is complete.)^
2356: **
2357: ** The input to [sqlite3_complete()] must be a zero-terminated
2358: ** UTF-8 string.
2359: **
2360: ** The input to [sqlite3_complete16()] must be a zero-terminated
2361: ** UTF-16 string in native byte order.
2362: */
2363: SQLITE_API int sqlite3_complete(const char *sql);
2364: SQLITE_API int sqlite3_complete16(const void *sql);
2365:
2366: /*
2367: ** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors
2368: **
2369: ** ^This routine sets a callback function that might be invoked whenever
2370: ** an attempt is made to open a database table that another thread
2371: ** or process has locked.
2372: **
2373: ** ^If the busy callback is NULL, then [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED]
2374: ** is returned immediately upon encountering the lock. ^If the busy callback
2375: ** is not NULL, then the callback might be invoked with two arguments.
2376: **
2377: ** ^The first argument to the busy handler is a copy of the void* pointer which
2378: ** is the third argument to sqlite3_busy_handler(). ^The second argument to
2379: ** the busy handler callback is the number of times that the busy handler has
2380: ** been invoked for this locking event. ^If the
2381: ** busy callback returns 0, then no additional attempts are made to
2382: ** access the database and [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED] is returned.
2383: ** ^If the callback returns non-zero, then another attempt
2384: ** is made to open the database for reading and the cycle repeats.
2385: **
2386: ** The presence of a busy handler does not guarantee that it will be invoked
2387: ** when there is lock contention. ^If SQLite determines that invoking the busy
2388: ** handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY]
2389: ** or [SQLITE_IOERR_BLOCKED] instead of invoking the busy handler.
2390: ** Consider a scenario where one process is holding a read lock that
2391: ** it is trying to promote to a reserved lock and
2392: ** a second process is holding a reserved lock that it is trying
2393: ** to promote to an exclusive lock. The first process cannot proceed
2394: ** because it is blocked by the second and the second process cannot
2395: ** proceed because it is blocked by the first. If both processes
2396: ** invoke the busy handlers, neither will make any progress. Therefore,
2397: ** SQLite returns [SQLITE_BUSY] for the first process, hoping that this
2398: ** will induce the first process to release its read lock and allow
2399: ** the second process to proceed.
2400: **
2401: ** ^The default busy callback is NULL.
2402: **
2403: ** ^The [SQLITE_BUSY] error is converted to [SQLITE_IOERR_BLOCKED]
2404: ** when SQLite is in the middle of a large transaction where all the
2405: ** changes will not fit into the in-memory cache. SQLite will
2406: ** already hold a RESERVED lock on the database file, but it needs
2407: ** to promote this lock to EXCLUSIVE so that it can spill cache
2408: ** pages into the database file without harm to concurrent
2409: ** readers. ^If it is unable to promote the lock, then the in-memory
2410: ** cache will be left in an inconsistent state and so the error
2411: ** code is promoted from the relatively benign [SQLITE_BUSY] to
2412: ** the more severe [SQLITE_IOERR_BLOCKED]. ^This error code promotion
2413: ** forces an automatic rollback of the changes. See the
2414: ** <a href="/cvstrac/wiki?p=CorruptionFollowingBusyError">
2415: ** CorruptionFollowingBusyError</a> wiki page for a discussion of why
2416: ** this is important.
2417: **
2418: ** ^(There can only be a single busy handler defined for each
2419: ** [database connection]. Setting a new busy handler clears any
2420: ** previously set handler.)^ ^Note that calling [sqlite3_busy_timeout()]
2421: ** will also set or clear the busy handler.
2422: **
2423: ** The busy callback should not take any actions which modify the
2424: ** database connection that invoked the busy handler. Any such actions
2425: ** result in undefined behavior.
2426: **
2427: ** A busy handler must not close the database connection
2428: ** or [prepared statement] that invoked the busy handler.
2429: */
2430: SQLITE_API int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*);
2431:
2432: /*
2433: ** CAPI3REF: Set A Busy Timeout
2434: **
2435: ** ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps
2436: ** for a specified amount of time when a table is locked. ^The handler
2437: ** will sleep multiple times until at least "ms" milliseconds of sleeping
2438: ** have accumulated. ^After at least "ms" milliseconds of sleeping,
2439: ** the handler returns 0 which causes [sqlite3_step()] to return
2440: ** [SQLITE_BUSY] or [SQLITE_IOERR_BLOCKED].
2441: **
2442: ** ^Calling this routine with an argument less than or equal to zero
2443: ** turns off all busy handlers.
2444: **
2445: ** ^(There can only be a single busy handler for a particular
2446: ** [database connection] any any given moment. If another busy handler
2447: ** was defined (using [sqlite3_busy_handler()]) prior to calling
2448: ** this routine, that other busy handler is cleared.)^
2449: */
2450: SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);
2451:
2452: /*
2453: ** CAPI3REF: Convenience Routines For Running Queries
2454: **
2455: ** This is a legacy interface that is preserved for backwards compatibility.
2456: ** Use of this interface is not recommended.
2457: **
2458: ** Definition: A <b>result table</b> is memory data structure created by the
2459: ** [sqlite3_get_table()] interface. A result table records the
2460: ** complete query results from one or more queries.
2461: **
2462: ** The table conceptually has a number of rows and columns. But
2463: ** these numbers are not part of the result table itself. These
2464: ** numbers are obtained separately. Let N be the number of rows
2465: ** and M be the number of columns.
2466: **
2467: ** A result table is an array of pointers to zero-terminated UTF-8 strings.
2468: ** There are (N+1)*M elements in the array. The first M pointers point
2469: ** to zero-terminated strings that contain the names of the columns.
2470: ** The remaining entries all point to query results. NULL values result
2471: ** in NULL pointers. All other values are in their UTF-8 zero-terminated
2472: ** string representation as returned by [sqlite3_column_text()].
2473: **
2474: ** A result table might consist of one or more memory allocations.
2475: ** It is not safe to pass a result table directly to [sqlite3_free()].
2476: ** A result table should be deallocated using [sqlite3_free_table()].
2477: **
2478: ** ^(As an example of the result table format, suppose a query result
2479: ** is as follows:
2480: **
2481: ** <blockquote><pre>
2482: ** Name | Age
2483: ** -----------------------
2484: ** Alice | 43
2485: ** Bob | 28
2486: ** Cindy | 21
2487: ** </pre></blockquote>
2488: **
2489: ** There are two column (M==2) and three rows (N==3). Thus the
2490: ** result table has 8 entries. Suppose the result table is stored
2491: ** in an array names azResult. Then azResult holds this content:
2492: **
2493: ** <blockquote><pre>
2494: ** azResult[0] = "Name";
2495: ** azResult[1] = "Age";
2496: ** azResult[2] = "Alice";
2497: ** azResult[3] = "43";
2498: ** azResult[4] = "Bob";
2499: ** azResult[5] = "28";
2500: ** azResult[6] = "Cindy";
2501: ** azResult[7] = "21";
2502: ** </pre></blockquote>)^
2503: **
2504: ** ^The sqlite3_get_table() function evaluates one or more
2505: ** semicolon-separated SQL statements in the zero-terminated UTF-8
2506: ** string of its 2nd parameter and returns a result table to the
2507: ** pointer given in its 3rd parameter.
2508: **
2509: ** After the application has finished with the result from sqlite3_get_table(),
2510: ** it must pass the result table pointer to sqlite3_free_table() in order to
2511: ** release the memory that was malloced. Because of the way the
2512: ** [sqlite3_malloc()] happens within sqlite3_get_table(), the calling
2513: ** function must not try to call [sqlite3_free()] directly. Only
2514: ** [sqlite3_free_table()] is able to release the memory properly and safely.
2515: **
2516: ** The sqlite3_get_table() interface is implemented as a wrapper around
2517: ** [sqlite3_exec()]. The sqlite3_get_table() routine does not have access
2518: ** to any internal data structures of SQLite. It uses only the public
2519: ** interface defined here. As a consequence, errors that occur in the
2520: ** wrapper layer outside of the internal [sqlite3_exec()] call are not
2521: ** reflected in subsequent calls to [sqlite3_errcode()] or
2522: ** [sqlite3_errmsg()].
2523: */
2524: SQLITE_API int sqlite3_get_table(
2525: sqlite3 *db, /* An open database */
2526: const char *zSql, /* SQL to be evaluated */
2527: char ***pazResult, /* Results of the query */
2528: int *pnRow, /* Number of result rows written here */
2529: int *pnColumn, /* Number of result columns written here */
2530: char **pzErrmsg /* Error msg written here */
2531: );
2532: SQLITE_API void sqlite3_free_table(char **result);
2533:
2534: /*
2535: ** CAPI3REF: Formatted String Printing Functions
2536: **
2537: ** These routines are work-alikes of the "printf()" family of functions
2538: ** from the standard C library.
2539: **
2540: ** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
2541: ** results into memory obtained from [sqlite3_malloc()].
2542: ** The strings returned by these two routines should be
2543: ** released by [sqlite3_free()]. ^Both routines return a
2544: ** NULL pointer if [sqlite3_malloc()] is unable to allocate enough
2545: ** memory to hold the resulting string.
2546: **
2547: ** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
2548: ** the standard C library. The result is written into the
2549: ** buffer supplied as the second parameter whose size is given by
2550: ** the first parameter. Note that the order of the
2551: ** first two parameters is reversed from snprintf().)^ This is an
2552: ** historical accident that cannot be fixed without breaking
2553: ** backwards compatibility. ^(Note also that sqlite3_snprintf()
2554: ** returns a pointer to its buffer instead of the number of
2555: ** characters actually written into the buffer.)^ We admit that
2556: ** the number of characters written would be a more useful return
2557: ** value but we cannot change the implementation of sqlite3_snprintf()
2558: ** now without breaking compatibility.
2559: **
2560: ** ^As long as the buffer size is greater than zero, sqlite3_snprintf()
2561: ** guarantees that the buffer is always zero-terminated. ^The first
2562: ** parameter "n" is the total size of the buffer, including space for
2563: ** the zero terminator. So the longest string that can be completely
2564: ** written will be n-1 characters.
2565: **
2566: ** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
2567: **
2568: ** These routines all implement some additional formatting
2569: ** options that are useful for constructing SQL statements.
2570: ** All of the usual printf() formatting options apply. In addition, there
2571: ** is are "%q", "%Q", and "%z" options.
2572: **
2573: ** ^(The %q option works like %s in that it substitutes a nul-terminated
2574: ** string from the argument list. But %q also doubles every '\'' character.
2575: ** %q is designed for use inside a string literal.)^ By doubling each '\''
2576: ** character it escapes that character and allows it to be inserted into
2577: ** the string.
2578: **
2579: ** For example, assume the string variable zText contains text as follows:
2580: **
2581: ** <blockquote><pre>
2582: ** char *zText = "It's a happy day!";
2583: ** </pre></blockquote>
2584: **
2585: ** One can use this text in an SQL statement as follows:
2586: **
2587: ** <blockquote><pre>
2588: ** char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
2589: ** sqlite3_exec(db, zSQL, 0, 0, 0);
2590: ** sqlite3_free(zSQL);
2591: ** </pre></blockquote>
2592: **
2593: ** Because the %q format string is used, the '\'' character in zText
2594: ** is escaped and the SQL generated is as follows:
2595: **
2596: ** <blockquote><pre>
2597: ** INSERT INTO table1 VALUES('It''s a happy day!')
2598: ** </pre></blockquote>
2599: **
2600: ** This is correct. Had we used %s instead of %q, the generated SQL
2601: ** would have looked like this:
2602: **
2603: ** <blockquote><pre>
2604: ** INSERT INTO table1 VALUES('It's a happy day!');
2605: ** </pre></blockquote>
2606: **
2607: ** This second example is an SQL syntax error. As a general rule you should
2608: ** always use %q instead of %s when inserting text into a string literal.
2609: **
2610: ** ^(The %Q option works like %q except it also adds single quotes around
2611: ** the outside of the total string. Additionally, if the parameter in the
2612: ** argument list is a NULL pointer, %Q substitutes the text "NULL" (without
2613: ** single quotes).)^ So, for example, one could say:
2614: **
2615: ** <blockquote><pre>
2616: ** char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
2617: ** sqlite3_exec(db, zSQL, 0, 0, 0);
2618: ** sqlite3_free(zSQL);
2619: ** </pre></blockquote>
2620: **
2621: ** The code above will render a correct SQL statement in the zSQL
2622: ** variable even if the zText variable is a NULL pointer.
2623: **
2624: ** ^(The "%z" formatting option works like "%s" but with the
2625: ** addition that after the string has been read and copied into
2626: ** the result, [sqlite3_free()] is called on the input string.)^
2627: */
2628: SQLITE_API char *sqlite3_mprintf(const char*,...);
2629: SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
2630: SQLITE_API char *sqlite3_snprintf(int,char*,const char*, ...);
2631: SQLITE_API char *sqlite3_vsnprintf(int,char*,const char*, va_list);
2632:
2633: /*
2634: ** CAPI3REF: Memory Allocation Subsystem
2635: **
2636: ** The SQLite core uses these three routines for all of its own
2637: ** internal memory allocation needs. "Core" in the previous sentence
2638: ** does not include operating-system specific VFS implementation. The
2639: ** Windows VFS uses native malloc() and free() for some operations.
2640: **
2641: ** ^The sqlite3_malloc() routine returns a pointer to a block
2642: ** of memory at least N bytes in length, where N is the parameter.
2643: ** ^If sqlite3_malloc() is unable to obtain sufficient free
2644: ** memory, it returns a NULL pointer. ^If the parameter N to
2645: ** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
2646: ** a NULL pointer.
2647: **
2648: ** ^Calling sqlite3_free() with a pointer previously returned
2649: ** by sqlite3_malloc() or sqlite3_realloc() releases that memory so
2650: ** that it might be reused. ^The sqlite3_free() routine is
2651: ** a no-op if is called with a NULL pointer. Passing a NULL pointer
2652: ** to sqlite3_free() is harmless. After being freed, memory
2653: ** should neither be read nor written. Even reading previously freed
2654: ** memory might result in a segmentation fault or other severe error.
2655: ** Memory corruption, a segmentation fault, or other severe error
2656: ** might result if sqlite3_free() is called with a non-NULL pointer that
2657: ** was not obtained from sqlite3_malloc() or sqlite3_realloc().
2658: **
2659: ** ^(The sqlite3_realloc() interface attempts to resize a
2660: ** prior memory allocation to be at least N bytes, where N is the
2661: ** second parameter. The memory allocation to be resized is the first
2662: ** parameter.)^ ^ If the first parameter to sqlite3_realloc()
2663: ** is a NULL pointer then its behavior is identical to calling
2664: ** sqlite3_malloc(N) where N is the second parameter to sqlite3_realloc().
2665: ** ^If the second parameter to sqlite3_realloc() is zero or
2666: ** negative then the behavior is exactly the same as calling
2667: ** sqlite3_free(P) where P is the first parameter to sqlite3_realloc().
2668: ** ^sqlite3_realloc() returns a pointer to a memory allocation
2669: ** of at least N bytes in size or NULL if sufficient memory is unavailable.
2670: ** ^If M is the size of the prior allocation, then min(N,M) bytes
2671: ** of the prior allocation are copied into the beginning of buffer returned
2672: ** by sqlite3_realloc() and the prior allocation is freed.
2673: ** ^If sqlite3_realloc() returns NULL, then the prior allocation
2674: ** is not freed.
2675: **
2676: ** ^The memory returned by sqlite3_malloc() and sqlite3_realloc()
2677: ** is always aligned to at least an 8 byte boundary, or to a
2678: ** 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time
2679: ** option is used.
2680: **
2681: ** In SQLite version 3.5.0 and 3.5.1, it was possible to define
2682: ** the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in
2683: ** implementation of these routines to be omitted. That capability
2684: ** is no longer provided. Only built-in memory allocators can be used.
2685: **
2686: ** The Windows OS interface layer calls
2687: ** the system malloc() and free() directly when converting
2688: ** filenames between the UTF-8 encoding used by SQLite
2689: ** and whatever filename encoding is used by the particular Windows
2690: ** installation. Memory allocation errors are detected, but
2691: ** they are reported back as [SQLITE_CANTOPEN] or
2692: ** [SQLITE_IOERR] rather than [SQLITE_NOMEM].
2693: **
2694: ** The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]
2695: ** must be either NULL or else pointers obtained from a prior
2696: ** invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have
2697: ** not yet been released.
2698: **
2699: ** The application must not read or write any part of
2700: ** a block of memory after it has been released using
2701: ** [sqlite3_free()] or [sqlite3_realloc()].
2702: */
2703: SQLITE_API void *sqlite3_malloc(int);
2704: SQLITE_API void *sqlite3_realloc(void*, int);
2705: SQLITE_API void sqlite3_free(void*);
2706:
2707: /*
2708: ** CAPI3REF: Memory Allocator Statistics
2709: **
2710: ** SQLite provides these two interfaces for reporting on the status
2711: ** of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()]
2712: ** routines, which form the built-in memory allocation subsystem.
2713: **
2714: ** ^The [sqlite3_memory_used()] routine returns the number of bytes
2715: ** of memory currently outstanding (malloced but not freed).
2716: ** ^The [sqlite3_memory_highwater()] routine returns the maximum
2717: ** value of [sqlite3_memory_used()] since the high-water mark
2718: ** was last reset. ^The values returned by [sqlite3_memory_used()] and
2719: ** [sqlite3_memory_highwater()] include any overhead
2720: ** added by SQLite in its implementation of [sqlite3_malloc()],
2721: ** but not overhead added by the any underlying system library
2722: ** routines that [sqlite3_malloc()] may call.
2723: **
2724: ** ^The memory high-water mark is reset to the current value of
2725: ** [sqlite3_memory_used()] if and only if the parameter to
2726: ** [sqlite3_memory_highwater()] is true. ^The value returned
2727: ** by [sqlite3_memory_highwater(1)] is the high-water mark
2728: ** prior to the reset.
2729: */
2730: SQLITE_API sqlite3_int64 sqlite3_memory_used(void);
2731: SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag);
2732:
2733: /*
2734: ** CAPI3REF: Pseudo-Random Number Generator
2735: **
2736: ** SQLite contains a high-quality pseudo-random number generator (PRNG) used to
2737: ** select random [ROWID | ROWIDs] when inserting new records into a table that
2738: ** already uses the largest possible [ROWID]. The PRNG is also used for
2739: ** the build-in random() and randomblob() SQL functions. This interface allows
2740: ** applications to access the same PRNG for other purposes.
2741: **
2742: ** ^A call to this routine stores N bytes of randomness into buffer P.
2743: **
2744: ** ^The first time this routine is invoked (either internally or by
2745: ** the application) the PRNG is seeded using randomness obtained
2746: ** from the xRandomness method of the default [sqlite3_vfs] object.
2747: ** ^On all subsequent invocations, the pseudo-randomness is generated
2748: ** internally and without recourse to the [sqlite3_vfs] xRandomness
2749: ** method.
2750: */
2751: SQLITE_API void sqlite3_randomness(int N, void *P);
2752:
2753: /*
2754: ** CAPI3REF: Compile-Time Authorization Callbacks
2755: **
2756: ** ^This routine registers an authorizer callback with a particular
2757: ** [database connection], supplied in the first argument.
2758: ** ^The authorizer callback is invoked as SQL statements are being compiled
2759: ** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()],
2760: ** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various
2761: ** points during the compilation process, as logic is being created
2762: ** to perform various actions, the authorizer callback is invoked to
2763: ** see if those actions are allowed. ^The authorizer callback should
2764: ** return [SQLITE_OK] to allow the action, [SQLITE_IGNORE] to disallow the
2765: ** specific action but allow the SQL statement to continue to be
2766: ** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be
2767: ** rejected with an error. ^If the authorizer callback returns
2768: ** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
2769: ** then the [sqlite3_prepare_v2()] or equivalent call that triggered
2770: ** the authorizer will fail with an error message.
2771: **
2772: ** When the callback returns [SQLITE_OK], that means the operation
2773: ** requested is ok. ^When the callback returns [SQLITE_DENY], the
2774: ** [sqlite3_prepare_v2()] or equivalent call that triggered the
2775: ** authorizer will fail with an error message explaining that
2776: ** access is denied.
2777: **
2778: ** ^The first parameter to the authorizer callback is a copy of the third
2779: ** parameter to the sqlite3_set_authorizer() interface. ^The second parameter
2780: ** to the callback is an integer [SQLITE_COPY | action code] that specifies
2781: ** the particular action to be authorized. ^The third through sixth parameters
2782: ** to the callback are zero-terminated strings that contain additional
2783: ** details about the action to be authorized.
2784: **
2785: ** ^If the action code is [SQLITE_READ]
2786: ** and the callback returns [SQLITE_IGNORE] then the
2787: ** [prepared statement] statement is constructed to substitute
2788: ** a NULL value in place of the table column that would have
2789: ** been read if [SQLITE_OK] had been returned. The [SQLITE_IGNORE]
2790: ** return can be used to deny an untrusted user access to individual
2791: ** columns of a table.
2792: ** ^If the action code is [SQLITE_DELETE] and the callback returns
2793: ** [SQLITE_IGNORE] then the [DELETE] operation proceeds but the
2794: ** [truncate optimization] is disabled and all rows are deleted individually.
2795: **
2796: ** An authorizer is used when [sqlite3_prepare | preparing]
2797: ** SQL statements from an untrusted source, to ensure that the SQL statements
2798: ** do not try to access data they are not allowed to see, or that they do not
2799: ** try to execute malicious statements that damage the database. For
2800: ** example, an application may allow a user to enter arbitrary
2801: ** SQL queries for evaluation by a database. But the application does
2802: ** not want the user to be able to make arbitrary changes to the
2803: ** database. An authorizer could then be put in place while the
2804: ** user-entered SQL is being [sqlite3_prepare | prepared] that
2805: ** disallows everything except [SELECT] statements.
2806: **
2807: ** Applications that need to process SQL from untrusted sources
2808: ** might also consider lowering resource limits using [sqlite3_limit()]
2809: ** and limiting database size using the [max_page_count] [PRAGMA]
2810: ** in addition to using an authorizer.
2811: **
2812: ** ^(Only a single authorizer can be in place on a database connection
2813: ** at a time. Each call to sqlite3_set_authorizer overrides the
2814: ** previous call.)^ ^Disable the authorizer by installing a NULL callback.
2815: ** The authorizer is disabled by default.
2816: **
2817: ** The authorizer callback must not do anything that will modify
2818: ** the database connection that invoked the authorizer callback.
2819: ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
2820: ** database connections for the meaning of "modify" in this paragraph.
2821: **
2822: ** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the
2823: ** statement might be re-prepared during [sqlite3_step()] due to a
2824: ** schema change. Hence, the application should ensure that the
2825: ** correct authorizer callback remains in place during the [sqlite3_step()].
2826: **
2827: ** ^Note that the authorizer callback is invoked only during
2828: ** [sqlite3_prepare()] or its variants. Authorization is not
2829: ** performed during statement evaluation in [sqlite3_step()], unless
2830: ** as stated in the previous paragraph, sqlite3_step() invokes
2831: ** sqlite3_prepare_v2() to reprepare a statement after a schema change.
2832: */
2833: SQLITE_API int sqlite3_set_authorizer(
2834: sqlite3*,
2835: int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
2836: void *pUserData
2837: );
2838:
2839: /*
2840: ** CAPI3REF: Authorizer Return Codes
2841: **
2842: ** The [sqlite3_set_authorizer | authorizer callback function] must
2843: ** return either [SQLITE_OK] or one of these two constants in order
2844: ** to signal SQLite whether or not the action is permitted. See the
2845: ** [sqlite3_set_authorizer | authorizer documentation] for additional
2846: ** information.
2847: **
2848: ** Note that SQLITE_IGNORE is also used as a [SQLITE_ROLLBACK | return code]
2849: ** from the [sqlite3_vtab_on_conflict()] interface.
2850: */
2851: #define SQLITE_DENY 1 /* Abort the SQL statement with an error */
2852: #define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */
2853:
2854: /*
2855: ** CAPI3REF: Authorizer Action Codes
2856: **
2857: ** The [sqlite3_set_authorizer()] interface registers a callback function
2858: ** that is invoked to authorize certain SQL statement actions. The
2859: ** second parameter to the callback is an integer code that specifies
2860: ** what action is being authorized. These are the integer action codes that
2861: ** the authorizer callback may be passed.
2862: **
2863: ** These action code values signify what kind of operation is to be
2864: ** authorized. The 3rd and 4th parameters to the authorization
2865: ** callback function will be parameters or NULL depending on which of these
2866: ** codes is used as the second parameter. ^(The 5th parameter to the
2867: ** authorizer callback is the name of the database ("main", "temp",
2868: ** etc.) if applicable.)^ ^The 6th parameter to the authorizer callback
2869: ** is the name of the inner-most trigger or view that is responsible for
2870: ** the access attempt or NULL if this access attempt is directly from
2871: ** top-level SQL code.
2872: */
2873: /******************************************* 3rd ************ 4th ***********/
2874: #define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */
2875: #define SQLITE_CREATE_TABLE 2 /* Table Name NULL */
2876: #define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */
2877: #define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */
2878: #define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */
2879: #define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */
2880: #define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */
2881: #define SQLITE_CREATE_VIEW 8 /* View Name NULL */
2882: #define SQLITE_DELETE 9 /* Table Name NULL */
2883: #define SQLITE_DROP_INDEX 10 /* Index Name Table Name */
2884: #define SQLITE_DROP_TABLE 11 /* Table Name NULL */
2885: #define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */
2886: #define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */
2887: #define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */
2888: #define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */
2889: #define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */
2890: #define SQLITE_DROP_VIEW 17 /* View Name NULL */
2891: #define SQLITE_INSERT 18 /* Table Name NULL */
2892: #define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */
2893: #define SQLITE_READ 20 /* Table Name Column Name */
2894: #define SQLITE_SELECT 21 /* NULL NULL */
2895: #define SQLITE_TRANSACTION 22 /* Operation NULL */
2896: #define SQLITE_UPDATE 23 /* Table Name Column Name */
2897: #define SQLITE_ATTACH 24 /* Filename NULL */
2898: #define SQLITE_DETACH 25 /* Database Name NULL */
2899: #define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */
2900: #define SQLITE_REINDEX 27 /* Index Name NULL */
2901: #define SQLITE_ANALYZE 28 /* Table Name NULL */
2902: #define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */
2903: #define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */
2904: #define SQLITE_FUNCTION 31 /* NULL Function Name */
2905: #define SQLITE_SAVEPOINT 32 /* Operation Savepoint Name */
2906: #define SQLITE_COPY 0 /* No longer used */
2907:
2908: /*
2909: ** CAPI3REF: Tracing And Profiling Functions
2910: **
2911: ** These routines register callback functions that can be used for
2912: ** tracing and profiling the execution of SQL statements.
2913: **
2914: ** ^The callback function registered by sqlite3_trace() is invoked at
2915: ** various times when an SQL statement is being run by [sqlite3_step()].
2916: ** ^The sqlite3_trace() callback is invoked with a UTF-8 rendering of the
2917: ** SQL statement text as the statement first begins executing.
2918: ** ^(Additional sqlite3_trace() callbacks might occur
2919: ** as each triggered subprogram is entered. The callbacks for triggers
2920: ** contain a UTF-8 SQL comment that identifies the trigger.)^
2921: **
2922: ** ^The callback function registered by sqlite3_profile() is invoked
2923: ** as each SQL statement finishes. ^The profile callback contains
2924: ** the original statement text and an estimate of wall-clock time
2925: ** of how long that statement took to run. ^The profile callback
2926: ** time is in units of nanoseconds, however the current implementation
2927: ** is only capable of millisecond resolution so the six least significant
2928: ** digits in the time are meaningless. Future versions of SQLite
2929: ** might provide greater resolution on the profiler callback. The
2930: ** sqlite3_profile() function is considered experimental and is
2931: ** subject to change in future versions of SQLite.
2932: */
2933: SQLITE_API void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*);
2934: SQLITE_API SQLITE_EXPERIMENTAL void *sqlite3_profile(sqlite3*,
2935: void(*xProfile)(void*,const char*,sqlite3_uint64), void*);
2936:
2937: /*
2938: ** CAPI3REF: Query Progress Callbacks
2939: **
2940: ** ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback
2941: ** function X to be invoked periodically during long running calls to
2942: ** [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for
2943: ** database connection D. An example use for this
2944: ** interface is to keep a GUI updated during a large query.
2945: **
2946: ** ^The parameter P is passed through as the only parameter to the
2947: ** callback function X. ^The parameter N is the number of
2948: ** [virtual machine instructions] that are evaluated between successive
2949: ** invocations of the callback X.
2950: **
2951: ** ^Only a single progress handler may be defined at one time per
2952: ** [database connection]; setting a new progress handler cancels the
2953: ** old one. ^Setting parameter X to NULL disables the progress handler.
2954: ** ^The progress handler is also disabled by setting N to a value less
2955: ** than 1.
2956: **
2957: ** ^If the progress callback returns non-zero, the operation is
2958: ** interrupted. This feature can be used to implement a
2959: ** "Cancel" button on a GUI progress dialog box.
2960: **
2961: ** The progress handler callback must not do anything that will modify
2962: ** the database connection that invoked the progress handler.
2963: ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
2964: ** database connections for the meaning of "modify" in this paragraph.
2965: **
2966: */
2967: SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
2968:
2969: /*
2970: ** CAPI3REF: Opening A New Database Connection
2971: **
2972: ** ^These routines open an SQLite database file as specified by the
2973: ** filename argument. ^The filename argument is interpreted as UTF-8 for
2974: ** sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte
2975: ** order for sqlite3_open16(). ^(A [database connection] handle is usually
2976: ** returned in *ppDb, even if an error occurs. The only exception is that
2977: ** if SQLite is unable to allocate memory to hold the [sqlite3] object,
2978: ** a NULL will be written into *ppDb instead of a pointer to the [sqlite3]
2979: ** object.)^ ^(If the database is opened (and/or created) successfully, then
2980: ** [SQLITE_OK] is returned. Otherwise an [error code] is returned.)^ ^The
2981: ** [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain
2982: ** an English language description of the error following a failure of any
2983: ** of the sqlite3_open() routines.
2984: **
2985: ** ^The default encoding for the database will be UTF-8 if
2986: ** sqlite3_open() or sqlite3_open_v2() is called and
2987: ** UTF-16 in the native byte order if sqlite3_open16() is used.
2988: **
2989: ** Whether or not an error occurs when it is opened, resources
2990: ** associated with the [database connection] handle should be released by
2991: ** passing it to [sqlite3_close()] when it is no longer required.
2992: **
2993: ** The sqlite3_open_v2() interface works like sqlite3_open()
2994: ** except that it accepts two additional parameters for additional control
2995: ** over the new database connection. ^(The flags parameter to
2996: ** sqlite3_open_v2() can take one of
2997: ** the following three values, optionally combined with the
2998: ** [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE],
2999: ** [SQLITE_OPEN_PRIVATECACHE], and/or [SQLITE_OPEN_URI] flags:)^
3000: **
3001: ** <dl>
3002: ** ^(<dt>[SQLITE_OPEN_READONLY]</dt>
3003: ** <dd>The database is opened in read-only mode. If the database does not
3004: ** already exist, an error is returned.</dd>)^
3005: **
3006: ** ^(<dt>[SQLITE_OPEN_READWRITE]</dt>
3007: ** <dd>The database is opened for reading and writing if possible, or reading
3008: ** only if the file is write protected by the operating system. In either
3009: ** case the database must already exist, otherwise an error is returned.</dd>)^
3010: **
3011: ** ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>
3012: ** <dd>The database is opened for reading and writing, and is created if
3013: ** it does not already exist. This is the behavior that is always used for
3014: ** sqlite3_open() and sqlite3_open16().</dd>)^
3015: ** </dl>
3016: **
3017: ** If the 3rd parameter to sqlite3_open_v2() is not one of the
3018: ** combinations shown above optionally combined with other
3019: ** [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits]
3020: ** then the behavior is undefined.
3021: **
3022: ** ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
3023: ** opens in the multi-thread [threading mode] as long as the single-thread
3024: ** mode has not been set at compile-time or start-time. ^If the
3025: ** [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
3026: ** in the serialized [threading mode] unless single-thread was
3027: ** previously selected at compile-time or start-time.
3028: ** ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be
3029: ** eligible to use [shared cache mode], regardless of whether or not shared
3030: ** cache is enabled using [sqlite3_enable_shared_cache()]. ^The
3031: ** [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
3032: ** participate in [shared cache mode] even if it is enabled.
3033: **
3034: ** ^The fourth parameter to sqlite3_open_v2() is the name of the
3035: ** [sqlite3_vfs] object that defines the operating system interface that
3036: ** the new database connection should use. ^If the fourth parameter is
3037: ** a NULL pointer then the default [sqlite3_vfs] object is used.
3038: **
3039: ** ^If the filename is ":memory:", then a private, temporary in-memory database
3040: ** is created for the connection. ^This in-memory database will vanish when
3041: ** the database connection is closed. Future versions of SQLite might
3042: ** make use of additional special filenames that begin with the ":" character.
3043: ** It is recommended that when a database filename actually does begin with
3044: ** a ":" character you should prefix the filename with a pathname such as
3045: ** "./" to avoid ambiguity.
3046: **
3047: ** ^If the filename is an empty string, then a private, temporary
3048: ** on-disk database will be created. ^This private database will be
3049: ** automatically deleted as soon as the database connection is closed.
3050: **
3051: ** [[URI filenames in sqlite3_open()]] <h3>URI Filenames</h3>
3052: **
3053: ** ^If [URI filename] interpretation is enabled, and the filename argument
3054: ** begins with "file:", then the filename is interpreted as a URI. ^URI
3055: ** filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is
3056: ** set in the fourth argument to sqlite3_open_v2(), or if it has
3057: ** been enabled globally using the [SQLITE_CONFIG_URI] option with the
3058: ** [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option.
3059: ** As of SQLite version 3.7.7, URI filename interpretation is turned off
3060: ** by default, but future releases of SQLite might enable URI filename
3061: ** interpretation by default. See "[URI filenames]" for additional
3062: ** information.
3063: **
3064: ** URI filenames are parsed according to RFC 3986. ^If the URI contains an
3065: ** authority, then it must be either an empty string or the string
3066: ** "localhost". ^If the authority is not an empty string or "localhost", an
3067: ** error is returned to the caller. ^The fragment component of a URI, if
3068: ** present, is ignored.
3069: **
3070: ** ^SQLite uses the path component of the URI as the name of the disk file
3071: ** which contains the database. ^If the path begins with a '/' character,
3072: ** then it is interpreted as an absolute path. ^If the path does not begin
3073: ** with a '/' (meaning that the authority section is omitted from the URI)
3074: ** then the path is interpreted as a relative path.
3075: ** ^On windows, the first component of an absolute path
3076: ** is a drive specification (e.g. "C:").
3077: **
3078: ** [[core URI query parameters]]
3079: ** The query component of a URI may contain parameters that are interpreted
3080: ** either by SQLite itself, or by a [VFS | custom VFS implementation].
3081: ** SQLite interprets the following three query parameters:
3082: **
3083: ** <ul>
3084: ** <li> <b>vfs</b>: ^The "vfs" parameter may be used to specify the name of
3085: ** a VFS object that provides the operating system interface that should
3086: ** be used to access the database file on disk. ^If this option is set to
3087: ** an empty string the default VFS object is used. ^Specifying an unknown
3088: ** VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is
3089: ** present, then the VFS specified by the option takes precedence over
3090: ** the value passed as the fourth parameter to sqlite3_open_v2().
3091: **
3092: ** <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw" or
3093: ** "rwc". Attempting to set it to any other value is an error)^.
3094: ** ^If "ro" is specified, then the database is opened for read-only
3095: ** access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the
3096: ** third argument to sqlite3_prepare_v2(). ^If the mode option is set to
3097: ** "rw", then the database is opened for read-write (but not create)
3098: ** access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had
3099: ** been set. ^Value "rwc" is equivalent to setting both
3100: ** SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE. ^If sqlite3_open_v2() is
3101: ** used, it is an error to specify a value for the mode parameter that is
3102: ** less restrictive than that specified by the flags passed as the third
3103: ** parameter.
3104: **
3105: ** <li> <b>cache</b>: ^The cache parameter may be set to either "shared" or
3106: ** "private". ^Setting it to "shared" is equivalent to setting the
3107: ** SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to
3108: ** sqlite3_open_v2(). ^Setting the cache parameter to "private" is
3109: ** equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit.
3110: ** ^If sqlite3_open_v2() is used and the "cache" parameter is present in
3111: ** a URI filename, its value overrides any behaviour requested by setting
3112: ** SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag.
3113: ** </ul>
3114: **
3115: ** ^Specifying an unknown parameter in the query component of a URI is not an
3116: ** error. Future versions of SQLite might understand additional query
3117: ** parameters. See "[query parameters with special meaning to SQLite]" for
3118: ** additional information.
3119: **
3120: ** [[URI filename examples]] <h3>URI filename examples</h3>
3121: **
3122: ** <table border="1" align=center cellpadding=5>
3123: ** <tr><th> URI filenames <th> Results
3124: ** <tr><td> file:data.db <td>
3125: ** Open the file "data.db" in the current directory.
3126: ** <tr><td> file:/home/fred/data.db<br>
3127: ** file:///home/fred/data.db <br>
3128: ** file://localhost/home/fred/data.db <br> <td>
3129: ** Open the database file "/home/fred/data.db".
3130: ** <tr><td> file://darkstar/home/fred/data.db <td>
3131: ** An error. "darkstar" is not a recognized authority.
3132: ** <tr><td style="white-space:nowrap">
3133: ** file:///C:/Documents%20and%20Settings/fred/Desktop/data.db
3134: ** <td> Windows only: Open the file "data.db" on fred's desktop on drive
3135: ** C:. Note that the %20 escaping in this example is not strictly
3136: ** necessary - space characters can be used literally
3137: ** in URI filenames.
3138: ** <tr><td> file:data.db?mode=ro&cache=private <td>
3139: ** Open file "data.db" in the current directory for read-only access.
3140: ** Regardless of whether or not shared-cache mode is enabled by
3141: ** default, use a private cache.
3142: ** <tr><td> file:/home/fred/data.db?vfs=unix-nolock <td>
3143: ** Open file "/home/fred/data.db". Use the special VFS "unix-nolock".
3144: ** <tr><td> file:data.db?mode=readonly <td>
3145: ** An error. "readonly" is not a valid option for the "mode" parameter.
3146: ** </table>
3147: **
3148: ** ^URI hexadecimal escape sequences (%HH) are supported within the path and
3149: ** query components of a URI. A hexadecimal escape sequence consists of a
3150: ** percent sign - "%" - followed by exactly two hexadecimal digits
3151: ** specifying an octet value. ^Before the path or query components of a
3152: ** URI filename are interpreted, they are encoded using UTF-8 and all
3153: ** hexadecimal escape sequences replaced by a single byte containing the
3154: ** corresponding octet. If this process generates an invalid UTF-8 encoding,
3155: ** the results are undefined.
3156: **
3157: ** <b>Note to Windows users:</b> The encoding used for the filename argument
3158: ** of sqlite3_open() and sqlite3_open_v2() must be UTF-8, not whatever
3159: ** codepage is currently defined. Filenames containing international
3160: ** characters must be converted to UTF-8 prior to passing them into
3161: ** sqlite3_open() or sqlite3_open_v2().
3162: */
3163: SQLITE_API int sqlite3_open(
3164: const char *filename, /* Database filename (UTF-8) */
3165: sqlite3 **ppDb /* OUT: SQLite db handle */
3166: );
3167: SQLITE_API int sqlite3_open16(
3168: const void *filename, /* Database filename (UTF-16) */
3169: sqlite3 **ppDb /* OUT: SQLite db handle */
3170: );
3171: SQLITE_API int sqlite3_open_v2(
3172: const char *filename, /* Database filename (UTF-8) */
3173: sqlite3 **ppDb, /* OUT: SQLite db handle */
3174: int flags, /* Flags */
3175: const char *zVfs /* Name of VFS module to use */
3176: );
3177:
3178: /*
3179: ** CAPI3REF: Obtain Values For URI Parameters
3180: **
3181: ** These are utility routines, useful to VFS implementations, that check
3182: ** to see if a database file was a URI that contained a specific query
3183: ** parameter, and if so obtains the value of that query parameter.
3184: **
3185: ** If F is the database filename pointer passed into the xOpen() method of
3186: ** a VFS implementation when the flags parameter to xOpen() has one or
3187: ** more of the [SQLITE_OPEN_URI] or [SQLITE_OPEN_MAIN_DB] bits set and
3188: ** P is the name of the query parameter, then
3189: ** sqlite3_uri_parameter(F,P) returns the value of the P
3190: ** parameter if it exists or a NULL pointer if P does not appear as a
3191: ** query parameter on F. If P is a query parameter of F
3192: ** has no explicit value, then sqlite3_uri_parameter(F,P) returns
3193: ** a pointer to an empty string.
3194: **
3195: ** The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean
3196: ** parameter and returns true (1) or false (0) according to the value
3197: ** of P. The value of P is true if it is "yes" or "true" or "on" or
3198: ** a non-zero number and is false otherwise. If P is not a query parameter
3199: ** on F then sqlite3_uri_boolean(F,P,B) returns (B!=0).
3200: **
3201: ** The sqlite3_uri_int64(F,P,D) routine converts the value of P into a
3202: ** 64-bit signed integer and returns that integer, or D if P does not
3203: ** exist. If the value of P is something other than an integer, then
3204: ** zero is returned.
3205: **
3206: ** If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and
3207: ** sqlite3_uri_boolean(F,P,B) returns B. If F is not a NULL pointer and
3208: ** is not a database file pathname pointer that SQLite passed into the xOpen
3209: ** VFS method, then the behavior of this routine is undefined and probably
3210: ** undesirable.
3211: */
3212: SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
3213: SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
3214: SQLITE_API sqlite3_int64 sqlite3_uri_int64(const char*, const char*, sqlite3_int64);
3215:
3216:
3217: /*
3218: ** CAPI3REF: Error Codes And Messages
3219: **
3220: ** ^The sqlite3_errcode() interface returns the numeric [result code] or
3221: ** [extended result code] for the most recent failed sqlite3_* API call
3222: ** associated with a [database connection]. If a prior API call failed
3223: ** but the most recent API call succeeded, the return value from
3224: ** sqlite3_errcode() is undefined. ^The sqlite3_extended_errcode()
3225: ** interface is the same except that it always returns the
3226: ** [extended result code] even when extended result codes are
3227: ** disabled.
3228: **
3229: ** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
3230: ** text that describes the error, as either UTF-8 or UTF-16 respectively.
3231: ** ^(Memory to hold the error message string is managed internally.
3232: ** The application does not need to worry about freeing the result.
3233: ** However, the error string might be overwritten or deallocated by
3234: ** subsequent calls to other SQLite interface functions.)^
3235: **
3236: ** When the serialized [threading mode] is in use, it might be the
3237: ** case that a second error occurs on a separate thread in between
3238: ** the time of the first error and the call to these interfaces.
3239: ** When that happens, the second error will be reported since these
3240: ** interfaces always report the most recent result. To avoid
3241: ** this, each thread can obtain exclusive use of the [database connection] D
3242: ** by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning
3243: ** to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after
3244: ** all calls to the interfaces listed here are completed.
3245: **
3246: ** If an interface fails with SQLITE_MISUSE, that means the interface
3247: ** was invoked incorrectly by the application. In that case, the
3248: ** error code and message may or may not be set.
3249: */
3250: SQLITE_API int sqlite3_errcode(sqlite3 *db);
3251: SQLITE_API int sqlite3_extended_errcode(sqlite3 *db);
3252: SQLITE_API const char *sqlite3_errmsg(sqlite3*);
3253: SQLITE_API const void *sqlite3_errmsg16(sqlite3*);
3254:
3255: /*
3256: ** CAPI3REF: SQL Statement Object
3257: ** KEYWORDS: {prepared statement} {prepared statements}
3258: **
3259: ** An instance of this object represents a single SQL statement.
3260: ** This object is variously known as a "prepared statement" or a
3261: ** "compiled SQL statement" or simply as a "statement".
3262: **
3263: ** The life of a statement object goes something like this:
3264: **
3265: ** <ol>
3266: ** <li> Create the object using [sqlite3_prepare_v2()] or a related
3267: ** function.
3268: ** <li> Bind values to [host parameters] using the sqlite3_bind_*()
3269: ** interfaces.
3270: ** <li> Run the SQL by calling [sqlite3_step()] one or more times.
3271: ** <li> Reset the statement using [sqlite3_reset()] then go back
3272: ** to step 2. Do this zero or more times.
3273: ** <li> Destroy the object using [sqlite3_finalize()].
3274: ** </ol>
3275: **
3276: ** Refer to documentation on individual methods above for additional
3277: ** information.
3278: */
3279: typedef struct sqlite3_stmt sqlite3_stmt;
3280:
3281: /*
3282: ** CAPI3REF: Run-time Limits
3283: **
3284: ** ^(This interface allows the size of various constructs to be limited
3285: ** on a connection by connection basis. The first parameter is the
3286: ** [database connection] whose limit is to be set or queried. The
3287: ** second parameter is one of the [limit categories] that define a
3288: ** class of constructs to be size limited. The third parameter is the
3289: ** new limit for that construct.)^
3290: **
3291: ** ^If the new limit is a negative number, the limit is unchanged.
3292: ** ^(For each limit category SQLITE_LIMIT_<i>NAME</i> there is a
3293: ** [limits | hard upper bound]
3294: ** set at compile-time by a C preprocessor macro called
3295: ** [limits | SQLITE_MAX_<i>NAME</i>].
3296: ** (The "_LIMIT_" in the name is changed to "_MAX_".))^
3297: ** ^Attempts to increase a limit above its hard upper bound are
3298: ** silently truncated to the hard upper bound.
3299: **
3300: ** ^Regardless of whether or not the limit was changed, the
3301: ** [sqlite3_limit()] interface returns the prior value of the limit.
3302: ** ^Hence, to find the current value of a limit without changing it,
3303: ** simply invoke this interface with the third parameter set to -1.
3304: **
3305: ** Run-time limits are intended for use in applications that manage
3306: ** both their own internal database and also databases that are controlled
3307: ** by untrusted external sources. An example application might be a
3308: ** web browser that has its own databases for storing history and
3309: ** separate databases controlled by JavaScript applications downloaded
3310: ** off the Internet. The internal databases can be given the
3311: ** large, default limits. Databases managed by external sources can
3312: ** be given much smaller limits designed to prevent a denial of service
3313: ** attack. Developers might also want to use the [sqlite3_set_authorizer()]
3314: ** interface to further control untrusted SQL. The size of the database
3315: ** created by an untrusted script can be contained using the
3316: ** [max_page_count] [PRAGMA].
3317: **
3318: ** New run-time limit categories may be added in future releases.
3319: */
3320: SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
3321:
3322: /*
3323: ** CAPI3REF: Run-Time Limit Categories
3324: ** KEYWORDS: {limit category} {*limit categories}
3325: **
3326: ** These constants define various performance limits
3327: ** that can be lowered at run-time using [sqlite3_limit()].
3328: ** The synopsis of the meanings of the various limits is shown below.
3329: ** Additional information is available at [limits | Limits in SQLite].
3330: **
3331: ** <dl>
3332: ** [[SQLITE_LIMIT_LENGTH]] ^(<dt>SQLITE_LIMIT_LENGTH</dt>
3333: ** <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
3334: **
3335: ** [[SQLITE_LIMIT_SQL_LENGTH]] ^(<dt>SQLITE_LIMIT_SQL_LENGTH</dt>
3336: ** <dd>The maximum length of an SQL statement, in bytes.</dd>)^
3337: **
3338: ** [[SQLITE_LIMIT_COLUMN]] ^(<dt>SQLITE_LIMIT_COLUMN</dt>
3339: ** <dd>The maximum number of columns in a table definition or in the
3340: ** result set of a [SELECT] or the maximum number of columns in an index
3341: ** or in an ORDER BY or GROUP BY clause.</dd>)^
3342: **
3343: ** [[SQLITE_LIMIT_EXPR_DEPTH]] ^(<dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
3344: ** <dd>The maximum depth of the parse tree on any expression.</dd>)^
3345: **
3346: ** [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
3347: ** <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
3348: **
3349: ** [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
3350: ** <dd>The maximum number of instructions in a virtual machine program
3351: ** used to implement an SQL statement. This limit is not currently
3352: ** enforced, though that might be added in some future release of
3353: ** SQLite.</dd>)^
3354: **
3355: ** [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
3356: ** <dd>The maximum number of arguments on a function.</dd>)^
3357: **
3358: ** [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
3359: ** <dd>The maximum number of [ATTACH | attached databases].)^</dd>
3360: **
3361: ** [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]]
3362: ** ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
3363: ** <dd>The maximum length of the pattern argument to the [LIKE] or
3364: ** [GLOB] operators.</dd>)^
3365: **
3366: ** [[SQLITE_LIMIT_VARIABLE_NUMBER]]
3367: ** ^(<dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
3368: ** <dd>The maximum index number of any [parameter] in an SQL statement.)^
3369: **
3370: ** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
3371: ** <dd>The maximum depth of recursion for triggers.</dd>)^
3372: ** </dl>
3373: */
3374: #define SQLITE_LIMIT_LENGTH 0
3375: #define SQLITE_LIMIT_SQL_LENGTH 1
3376: #define SQLITE_LIMIT_COLUMN 2
3377: #define SQLITE_LIMIT_EXPR_DEPTH 3
3378: #define SQLITE_LIMIT_COMPOUND_SELECT 4
3379: #define SQLITE_LIMIT_VDBE_OP 5
3380: #define SQLITE_LIMIT_FUNCTION_ARG 6
3381: #define SQLITE_LIMIT_ATTACHED 7
3382: #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8
3383: #define SQLITE_LIMIT_VARIABLE_NUMBER 9
3384: #define SQLITE_LIMIT_TRIGGER_DEPTH 10
3385:
3386: /*
3387: ** CAPI3REF: Compiling An SQL Statement
3388: ** KEYWORDS: {SQL statement compiler}
3389: **
3390: ** To execute an SQL query, it must first be compiled into a byte-code
3391: ** program using one of these routines.
3392: **
3393: ** The first argument, "db", is a [database connection] obtained from a
3394: ** prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or
3395: ** [sqlite3_open16()]. The database connection must not have been closed.
3396: **
3397: ** The second argument, "zSql", is the statement to be compiled, encoded
3398: ** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2()
3399: ** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2()
3400: ** use UTF-16.
3401: **
3402: ** ^If the nByte argument is less than zero, then zSql is read up to the
3403: ** first zero terminator. ^If nByte is non-negative, then it is the maximum
3404: ** number of bytes read from zSql. ^When nByte is non-negative, the
3405: ** zSql string ends at either the first '\000' or '\u0000' character or
3406: ** the nByte-th byte, whichever comes first. If the caller knows
3407: ** that the supplied string is nul-terminated, then there is a small
3408: ** performance advantage to be gained by passing an nByte parameter that
3409: ** is equal to the number of bytes in the input string <i>including</i>
3410: ** the nul-terminator bytes as this saves SQLite from having to
3411: ** make a copy of the input string.
3412: **
3413: ** ^If pzTail is not NULL then *pzTail is made to point to the first byte
3414: ** past the end of the first SQL statement in zSql. These routines only
3415: ** compile the first statement in zSql, so *pzTail is left pointing to
3416: ** what remains uncompiled.
3417: **
3418: ** ^*ppStmt is left pointing to a compiled [prepared statement] that can be
3419: ** executed using [sqlite3_step()]. ^If there is an error, *ppStmt is set
3420: ** to NULL. ^If the input text contains no SQL (if the input is an empty
3421: ** string or a comment) then *ppStmt is set to NULL.
3422: ** The calling procedure is responsible for deleting the compiled
3423: ** SQL statement using [sqlite3_finalize()] after it has finished with it.
3424: ** ppStmt may not be NULL.
3425: **
3426: ** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
3427: ** otherwise an [error code] is returned.
3428: **
3429: ** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are
3430: ** recommended for all new programs. The two older interfaces are retained
3431: ** for backwards compatibility, but their use is discouraged.
3432: ** ^In the "v2" interfaces, the prepared statement
3433: ** that is returned (the [sqlite3_stmt] object) contains a copy of the
3434: ** original SQL text. This causes the [sqlite3_step()] interface to
3435: ** behave differently in three ways:
3436: **
3437: ** <ol>
3438: ** <li>
3439: ** ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
3440: ** always used to do, [sqlite3_step()] will automatically recompile the SQL
3441: ** statement and try to run it again.
3442: ** </li>
3443: **
3444: ** <li>
3445: ** ^When an error occurs, [sqlite3_step()] will return one of the detailed
3446: ** [error codes] or [extended error codes]. ^The legacy behavior was that
3447: ** [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code
3448: ** and the application would have to make a second call to [sqlite3_reset()]
3449: ** in order to find the underlying cause of the problem. With the "v2" prepare
3450: ** interfaces, the underlying reason for the error is returned immediately.
3451: ** </li>
3452: **
3453: ** <li>
3454: ** ^If the specific value bound to [parameter | host parameter] in the
3455: ** WHERE clause might influence the choice of query plan for a statement,
3456: ** then the statement will be automatically recompiled, as if there had been
3457: ** a schema change, on the first [sqlite3_step()] call following any change
3458: ** to the [sqlite3_bind_text | bindings] of that [parameter].
3459: ** ^The specific value of WHERE-clause [parameter] might influence the
3460: ** choice of query plan if the parameter is the left-hand side of a [LIKE]
3461: ** or [GLOB] operator or if the parameter is compared to an indexed column
3462: ** and the [SQLITE_ENABLE_STAT3] compile-time option is enabled.
3463: ** the
3464: ** </li>
3465: ** </ol>
3466: */
3467: SQLITE_API int sqlite3_prepare(
3468: sqlite3 *db, /* Database handle */
3469: const char *zSql, /* SQL statement, UTF-8 encoded */
3470: int nByte, /* Maximum length of zSql in bytes. */
3471: sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3472: const char **pzTail /* OUT: Pointer to unused portion of zSql */
3473: );
3474: SQLITE_API int sqlite3_prepare_v2(
3475: sqlite3 *db, /* Database handle */
3476: const char *zSql, /* SQL statement, UTF-8 encoded */
3477: int nByte, /* Maximum length of zSql in bytes. */
3478: sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3479: const char **pzTail /* OUT: Pointer to unused portion of zSql */
3480: );
3481: SQLITE_API int sqlite3_prepare16(
3482: sqlite3 *db, /* Database handle */
3483: const void *zSql, /* SQL statement, UTF-16 encoded */
3484: int nByte, /* Maximum length of zSql in bytes. */
3485: sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3486: const void **pzTail /* OUT: Pointer to unused portion of zSql */
3487: );
3488: SQLITE_API int sqlite3_prepare16_v2(
3489: sqlite3 *db, /* Database handle */
3490: const void *zSql, /* SQL statement, UTF-16 encoded */
3491: int nByte, /* Maximum length of zSql in bytes. */
3492: sqlite3_stmt **ppStmt, /* OUT: Statement handle */
3493: const void **pzTail /* OUT: Pointer to unused portion of zSql */
3494: );
3495:
3496: /*
3497: ** CAPI3REF: Retrieving Statement SQL
3498: **
3499: ** ^This interface can be used to retrieve a saved copy of the original
3500: ** SQL text used to create a [prepared statement] if that statement was
3501: ** compiled using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
3502: */
3503: SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
3504:
3505: /*
3506: ** CAPI3REF: Determine If An SQL Statement Writes The Database
3507: **
3508: ** ^The sqlite3_stmt_readonly(X) interface returns true (non-zero) if
3509: ** and only if the [prepared statement] X makes no direct changes to
3510: ** the content of the database file.
3511: **
3512: ** Note that [application-defined SQL functions] or
3513: ** [virtual tables] might change the database indirectly as a side effect.
3514: ** ^(For example, if an application defines a function "eval()" that
3515: ** calls [sqlite3_exec()], then the following SQL statement would
3516: ** change the database file through side-effects:
3517: **
3518: ** <blockquote><pre>
3519: ** SELECT eval('DELETE FROM t1') FROM t2;
3520: ** </pre></blockquote>
3521: **
3522: ** But because the [SELECT] statement does not change the database file
3523: ** directly, sqlite3_stmt_readonly() would still return true.)^
3524: **
3525: ** ^Transaction control statements such as [BEGIN], [COMMIT], [ROLLBACK],
3526: ** [SAVEPOINT], and [RELEASE] cause sqlite3_stmt_readonly() to return true,
3527: ** since the statements themselves do not actually modify the database but
3528: ** rather they control the timing of when other statements modify the
3529: ** database. ^The [ATTACH] and [DETACH] statements also cause
3530: ** sqlite3_stmt_readonly() to return true since, while those statements
3531: ** change the configuration of a database connection, they do not make
3532: ** changes to the content of the database files on disk.
3533: */
3534: SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
3535:
3536: /*
3537: ** CAPI3REF: Determine If A Prepared Statement Has Been Reset
3538: **
3539: ** ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the
3540: ** [prepared statement] S has been stepped at least once using
3541: ** [sqlite3_step(S)] but has not run to completion and/or has not
3542: ** been reset using [sqlite3_reset(S)]. ^The sqlite3_stmt_busy(S)
3543: ** interface returns false if S is a NULL pointer. If S is not a
3544: ** NULL pointer and is not a pointer to a valid [prepared statement]
3545: ** object, then the behavior is undefined and probably undesirable.
3546: **
3547: ** This interface can be used in combination [sqlite3_next_stmt()]
3548: ** to locate all prepared statements associated with a database
3549: ** connection that are in need of being reset. This can be used,
3550: ** for example, in diagnostic routines to search for prepared
3551: ** statements that are holding a transaction open.
3552: */
3553: SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt*);
3554:
3555: /*
3556: ** CAPI3REF: Dynamically Typed Value Object
3557: ** KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value}
3558: **
3559: ** SQLite uses the sqlite3_value object to represent all values
3560: ** that can be stored in a database table. SQLite uses dynamic typing
3561: ** for the values it stores. ^Values stored in sqlite3_value objects
3562: ** can be integers, floating point values, strings, BLOBs, or NULL.
3563: **
3564: ** An sqlite3_value object may be either "protected" or "unprotected".
3565: ** Some interfaces require a protected sqlite3_value. Other interfaces
3566: ** will accept either a protected or an unprotected sqlite3_value.
3567: ** Every interface that accepts sqlite3_value arguments specifies
3568: ** whether or not it requires a protected sqlite3_value.
3569: **
3570: ** The terms "protected" and "unprotected" refer to whether or not
3571: ** a mutex is held. An internal mutex is held for a protected
3572: ** sqlite3_value object but no mutex is held for an unprotected
3573: ** sqlite3_value object. If SQLite is compiled to be single-threaded
3574: ** (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0)
3575: ** or if SQLite is run in one of reduced mutex modes
3576: ** [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD]
3577: ** then there is no distinction between protected and unprotected
3578: ** sqlite3_value objects and they can be used interchangeably. However,
3579: ** for maximum code portability it is recommended that applications
3580: ** still make the distinction between protected and unprotected
3581: ** sqlite3_value objects even when not strictly required.
3582: **
3583: ** ^The sqlite3_value objects that are passed as parameters into the
3584: ** implementation of [application-defined SQL functions] are protected.
3585: ** ^The sqlite3_value object returned by
3586: ** [sqlite3_column_value()] is unprotected.
3587: ** Unprotected sqlite3_value objects may only be used with
3588: ** [sqlite3_result_value()] and [sqlite3_bind_value()].
3589: ** The [sqlite3_value_blob | sqlite3_value_type()] family of
3590: ** interfaces require protected sqlite3_value objects.
3591: */
3592: typedef struct Mem sqlite3_value;
3593:
3594: /*
3595: ** CAPI3REF: SQL Function Context Object
3596: **
3597: ** The context in which an SQL function executes is stored in an
3598: ** sqlite3_context object. ^A pointer to an sqlite3_context object
3599: ** is always first parameter to [application-defined SQL functions].
3600: ** The application-defined SQL function implementation will pass this
3601: ** pointer through into calls to [sqlite3_result_int | sqlite3_result()],
3602: ** [sqlite3_aggregate_context()], [sqlite3_user_data()],
3603: ** [sqlite3_context_db_handle()], [sqlite3_get_auxdata()],
3604: ** and/or [sqlite3_set_auxdata()].
3605: */
3606: typedef struct sqlite3_context sqlite3_context;
3607:
3608: /*
3609: ** CAPI3REF: Binding Values To Prepared Statements
3610: ** KEYWORDS: {host parameter} {host parameters} {host parameter name}
3611: ** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
3612: **
3613: ** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,
3614: ** literals may be replaced by a [parameter] that matches one of following
3615: ** templates:
3616: **
3617: ** <ul>
3618: ** <li> ?
3619: ** <li> ?NNN
3620: ** <li> :VVV
3621: ** <li> @VVV
3622: ** <li> $VVV
3623: ** </ul>
3624: **
3625: ** In the templates above, NNN represents an integer literal,
3626: ** and VVV represents an alphanumeric identifier.)^ ^The values of these
3627: ** parameters (also called "host parameter names" or "SQL parameters")
3628: ** can be set using the sqlite3_bind_*() routines defined here.
3629: **
3630: ** ^The first argument to the sqlite3_bind_*() routines is always
3631: ** a pointer to the [sqlite3_stmt] object returned from
3632: ** [sqlite3_prepare_v2()] or its variants.
3633: **
3634: ** ^The second argument is the index of the SQL parameter to be set.
3635: ** ^The leftmost SQL parameter has an index of 1. ^When the same named
3636: ** SQL parameter is used more than once, second and subsequent
3637: ** occurrences have the same index as the first occurrence.
3638: ** ^The index for named parameters can be looked up using the
3639: ** [sqlite3_bind_parameter_index()] API if desired. ^The index
3640: ** for "?NNN" parameters is the value of NNN.
3641: ** ^The NNN value must be between 1 and the [sqlite3_limit()]
3642: ** parameter [SQLITE_LIMIT_VARIABLE_NUMBER] (default value: 999).
3643: **
3644: ** ^The third argument is the value to bind to the parameter.
3645: **
3646: ** ^(In those routines that have a fourth argument, its value is the
3647: ** number of bytes in the parameter. To be clear: the value is the
3648: ** number of <u>bytes</u> in the value, not the number of characters.)^
3649: ** ^If the fourth parameter is negative, the length of the string is
3650: ** the number of bytes up to the first zero terminator.
3651: ** If a non-negative fourth parameter is provided to sqlite3_bind_text()
3652: ** or sqlite3_bind_text16() then that parameter must be the byte offset
3653: ** where the NUL terminator would occur assuming the string were NUL
3654: ** terminated. If any NUL characters occur at byte offsets less than
3655: ** the value of the fourth parameter then the resulting string value will
3656: ** contain embedded NULs. The result of expressions involving strings
3657: ** with embedded NULs is undefined.
3658: **
3659: ** ^The fifth argument to sqlite3_bind_blob(), sqlite3_bind_text(), and
3660: ** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or
3661: ** string after SQLite has finished with it. ^The destructor is called
3662: ** to dispose of the BLOB or string even if the call to sqlite3_bind_blob(),
3663: ** sqlite3_bind_text(), or sqlite3_bind_text16() fails.
3664: ** ^If the fifth argument is
3665: ** the special value [SQLITE_STATIC], then SQLite assumes that the
3666: ** information is in static, unmanaged space and does not need to be freed.
3667: ** ^If the fifth argument has the value [SQLITE_TRANSIENT], then
3668: ** SQLite makes its own private copy of the data immediately, before
3669: ** the sqlite3_bind_*() routine returns.
3670: **
3671: ** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
3672: ** is filled with zeroes. ^A zeroblob uses a fixed amount of memory
3673: ** (just an integer to hold its size) while it is being processed.
3674: ** Zeroblobs are intended to serve as placeholders for BLOBs whose
3675: ** content is later written using
3676: ** [sqlite3_blob_open | incremental BLOB I/O] routines.
3677: ** ^A negative value for the zeroblob results in a zero-length BLOB.
3678: **
3679: ** ^If any of the sqlite3_bind_*() routines are called with a NULL pointer
3680: ** for the [prepared statement] or with a prepared statement for which
3681: ** [sqlite3_step()] has been called more recently than [sqlite3_reset()],
3682: ** then the call will return [SQLITE_MISUSE]. If any sqlite3_bind_()
3683: ** routine is passed a [prepared statement] that has been finalized, the
3684: ** result is undefined and probably harmful.
3685: **
3686: ** ^Bindings are not cleared by the [sqlite3_reset()] routine.
3687: ** ^Unbound parameters are interpreted as NULL.
3688: **
3689: ** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
3690: ** [error code] if anything goes wrong.
3691: ** ^[SQLITE_RANGE] is returned if the parameter
3692: ** index is out of range. ^[SQLITE_NOMEM] is returned if malloc() fails.
3693: **
3694: ** See also: [sqlite3_bind_parameter_count()],
3695: ** [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()].
3696: */
3697: SQLITE_API int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
3698: SQLITE_API int sqlite3_bind_double(sqlite3_stmt*, int, double);
3699: SQLITE_API int sqlite3_bind_int(sqlite3_stmt*, int, int);
3700: SQLITE_API int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
3701: SQLITE_API int sqlite3_bind_null(sqlite3_stmt*, int);
3702: SQLITE_API int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*));
3703: SQLITE_API int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
3704: SQLITE_API int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
3705: SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
3706:
3707: /*
3708: ** CAPI3REF: Number Of SQL Parameters
3709: **
3710: ** ^This routine can be used to find the number of [SQL parameters]
3711: ** in a [prepared statement]. SQL parameters are tokens of the
3712: ** form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
3713: ** placeholders for values that are [sqlite3_bind_blob | bound]
3714: ** to the parameters at a later time.
3715: **
3716: ** ^(This routine actually returns the index of the largest (rightmost)
3717: ** parameter. For all forms except ?NNN, this will correspond to the
3718: ** number of unique parameters. If parameters of the ?NNN form are used,
3719: ** there may be gaps in the list.)^
3720: **
3721: ** See also: [sqlite3_bind_blob|sqlite3_bind()],
3722: ** [sqlite3_bind_parameter_name()], and
3723: ** [sqlite3_bind_parameter_index()].
3724: */
3725: SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt*);
3726:
3727: /*
3728: ** CAPI3REF: Name Of A Host Parameter
3729: **
3730: ** ^The sqlite3_bind_parameter_name(P,N) interface returns
3731: ** the name of the N-th [SQL parameter] in the [prepared statement] P.
3732: ** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA"
3733: ** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA"
3734: ** respectively.
3735: ** In other words, the initial ":" or "$" or "@" or "?"
3736: ** is included as part of the name.)^
3737: ** ^Parameters of the form "?" without a following integer have no name
3738: ** and are referred to as "nameless" or "anonymous parameters".
3739: **
3740: ** ^The first host parameter has an index of 1, not 0.
3741: **
3742: ** ^If the value N is out of range or if the N-th parameter is
3743: ** nameless, then NULL is returned. ^The returned string is
3744: ** always in UTF-8 encoding even if the named parameter was
3745: ** originally specified as UTF-16 in [sqlite3_prepare16()] or
3746: ** [sqlite3_prepare16_v2()].
3747: **
3748: ** See also: [sqlite3_bind_blob|sqlite3_bind()],
3749: ** [sqlite3_bind_parameter_count()], and
3750: ** [sqlite3_bind_parameter_index()].
3751: */
3752: SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
3753:
3754: /*
3755: ** CAPI3REF: Index Of A Parameter With A Given Name
3756: **
3757: ** ^Return the index of an SQL parameter given its name. ^The
3758: ** index value returned is suitable for use as the second
3759: ** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero
3760: ** is returned if no matching parameter is found. ^The parameter
3761: ** name must be given in UTF-8 even if the original statement
3762: ** was prepared from UTF-16 text using [sqlite3_prepare16_v2()].
3763: **
3764: ** See also: [sqlite3_bind_blob|sqlite3_bind()],
3765: ** [sqlite3_bind_parameter_count()], and
3766: ** [sqlite3_bind_parameter_index()].
3767: */
3768: SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);
3769:
3770: /*
3771: ** CAPI3REF: Reset All Bindings On A Prepared Statement
3772: **
3773: ** ^Contrary to the intuition of many, [sqlite3_reset()] does not reset
3774: ** the [sqlite3_bind_blob | bindings] on a [prepared statement].
3775: ** ^Use this routine to reset all host parameters to NULL.
3776: */
3777: SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt*);
3778:
3779: /*
3780: ** CAPI3REF: Number Of Columns In A Result Set
3781: **
3782: ** ^Return the number of columns in the result set returned by the
3783: ** [prepared statement]. ^This routine returns 0 if pStmt is an SQL
3784: ** statement that does not return data (for example an [UPDATE]).
3785: **
3786: ** See also: [sqlite3_data_count()]
3787: */
3788: SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt);
3789:
3790: /*
3791: ** CAPI3REF: Column Names In A Result Set
3792: **
3793: ** ^These routines return the name assigned to a particular column
3794: ** in the result set of a [SELECT] statement. ^The sqlite3_column_name()
3795: ** interface returns a pointer to a zero-terminated UTF-8 string
3796: ** and sqlite3_column_name16() returns a pointer to a zero-terminated
3797: ** UTF-16 string. ^The first parameter is the [prepared statement]
3798: ** that implements the [SELECT] statement. ^The second parameter is the
3799: ** column number. ^The leftmost column is number 0.
3800: **
3801: ** ^The returned string pointer is valid until either the [prepared statement]
3802: ** is destroyed by [sqlite3_finalize()] or until the statement is automatically
3803: ** reprepared by the first call to [sqlite3_step()] for a particular run
3804: ** or until the next call to
3805: ** sqlite3_column_name() or sqlite3_column_name16() on the same column.
3806: **
3807: ** ^If sqlite3_malloc() fails during the processing of either routine
3808: ** (for example during a conversion from UTF-8 to UTF-16) then a
3809: ** NULL pointer is returned.
3810: **
3811: ** ^The name of a result column is the value of the "AS" clause for
3812: ** that column, if there is an AS clause. If there is no AS clause
3813: ** then the name of the column is unspecified and may change from
3814: ** one release of SQLite to the next.
3815: */
3816: SQLITE_API const char *sqlite3_column_name(sqlite3_stmt*, int N);
3817: SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt*, int N);
3818:
3819: /*
3820: ** CAPI3REF: Source Of Data In A Query Result
3821: **
3822: ** ^These routines provide a means to determine the database, table, and
3823: ** table column that is the origin of a particular result column in
3824: ** [SELECT] statement.
3825: ** ^The name of the database or table or column can be returned as
3826: ** either a UTF-8 or UTF-16 string. ^The _database_ routines return
3827: ** the database name, the _table_ routines return the table name, and
3828: ** the origin_ routines return the column name.
3829: ** ^The returned string is valid until the [prepared statement] is destroyed
3830: ** using [sqlite3_finalize()] or until the statement is automatically
3831: ** reprepared by the first call to [sqlite3_step()] for a particular run
3832: ** or until the same information is requested
3833: ** again in a different encoding.
3834: **
3835: ** ^The names returned are the original un-aliased names of the
3836: ** database, table, and column.
3837: **
3838: ** ^The first argument to these interfaces is a [prepared statement].
3839: ** ^These functions return information about the Nth result column returned by
3840: ** the statement, where N is the second function argument.
3841: ** ^The left-most column is column 0 for these routines.
3842: **
3843: ** ^If the Nth column returned by the statement is an expression or
3844: ** subquery and is not a column value, then all of these functions return
3845: ** NULL. ^These routine might also return NULL if a memory allocation error
3846: ** occurs. ^Otherwise, they return the name of the attached database, table,
3847: ** or column that query result column was extracted from.
3848: **
3849: ** ^As with all other SQLite APIs, those whose names end with "16" return
3850: ** UTF-16 encoded strings and the other functions return UTF-8.
3851: **
3852: ** ^These APIs are only available if the library was compiled with the
3853: ** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol.
3854: **
3855: ** If two or more threads call one or more of these routines against the same
3856: ** prepared statement and column at the same time then the results are
3857: ** undefined.
3858: **
3859: ** If two or more threads call one or more
3860: ** [sqlite3_column_database_name | column metadata interfaces]
3861: ** for the same [prepared statement] and result column
3862: ** at the same time then the results are undefined.
3863: */
3864: SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt*,int);
3865: SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
3866: SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt*,int);
3867: SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
3868: SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
3869: SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);
3870:
3871: /*
3872: ** CAPI3REF: Declared Datatype Of A Query Result
3873: **
3874: ** ^(The first parameter is a [prepared statement].
3875: ** If this statement is a [SELECT] statement and the Nth column of the
3876: ** returned result set of that [SELECT] is a table column (not an
3877: ** expression or subquery) then the declared type of the table
3878: ** column is returned.)^ ^If the Nth column of the result set is an
3879: ** expression or subquery, then a NULL pointer is returned.
3880: ** ^The returned string is always UTF-8 encoded.
3881: **
3882: ** ^(For example, given the database schema:
3883: **
3884: ** CREATE TABLE t1(c1 VARIANT);
3885: **
3886: ** and the following statement to be compiled:
3887: **
3888: ** SELECT c1 + 1, c1 FROM t1;
3889: **
3890: ** this routine would return the string "VARIANT" for the second result
3891: ** column (i==1), and a NULL pointer for the first result column (i==0).)^
3892: **
3893: ** ^SQLite uses dynamic run-time typing. ^So just because a column
3894: ** is declared to contain a particular type does not mean that the
3895: ** data stored in that column is of the declared type. SQLite is
3896: ** strongly typed, but the typing is dynamic not static. ^Type
3897: ** is associated with individual values, not with the containers
3898: ** used to hold those values.
3899: */
3900: SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt*,int);
3901: SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
3902:
3903: /*
3904: ** CAPI3REF: Evaluate An SQL Statement
3905: **
3906: ** After a [prepared statement] has been prepared using either
3907: ** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy
3908: ** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function
3909: ** must be called one or more times to evaluate the statement.
3910: **
3911: ** The details of the behavior of the sqlite3_step() interface depend
3912: ** on whether the statement was prepared using the newer "v2" interface
3913: ** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy
3914: ** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the
3915: ** new "v2" interface is recommended for new applications but the legacy
3916: ** interface will continue to be supported.
3917: **
3918: ** ^In the legacy interface, the return value will be either [SQLITE_BUSY],
3919: ** [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE].
3920: ** ^With the "v2" interface, any of the other [result codes] or
3921: ** [extended result codes] might be returned as well.
3922: **
3923: ** ^[SQLITE_BUSY] means that the database engine was unable to acquire the
3924: ** database locks it needs to do its job. ^If the statement is a [COMMIT]
3925: ** or occurs outside of an explicit transaction, then you can retry the
3926: ** statement. If the statement is not a [COMMIT] and occurs within an
3927: ** explicit transaction then you should rollback the transaction before
3928: ** continuing.
3929: **
3930: ** ^[SQLITE_DONE] means that the statement has finished executing
3931: ** successfully. sqlite3_step() should not be called again on this virtual
3932: ** machine without first calling [sqlite3_reset()] to reset the virtual
3933: ** machine back to its initial state.
3934: **
3935: ** ^If the SQL statement being executed returns any data, then [SQLITE_ROW]
3936: ** is returned each time a new row of data is ready for processing by the
3937: ** caller. The values may be accessed using the [column access functions].
3938: ** sqlite3_step() is called again to retrieve the next row of data.
3939: **
3940: ** ^[SQLITE_ERROR] means that a run-time error (such as a constraint
3941: ** violation) has occurred. sqlite3_step() should not be called again on
3942: ** the VM. More information may be found by calling [sqlite3_errmsg()].
3943: ** ^With the legacy interface, a more specific error code (for example,
3944: ** [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth)
3945: ** can be obtained by calling [sqlite3_reset()] on the
3946: ** [prepared statement]. ^In the "v2" interface,
3947: ** the more specific error code is returned directly by sqlite3_step().
3948: **
3949: ** [SQLITE_MISUSE] means that the this routine was called inappropriately.
3950: ** Perhaps it was called on a [prepared statement] that has
3951: ** already been [sqlite3_finalize | finalized] or on one that had
3952: ** previously returned [SQLITE_ERROR] or [SQLITE_DONE]. Or it could
3953: ** be the case that the same database connection is being used by two or
3954: ** more threads at the same moment in time.
3955: **
3956: ** For all versions of SQLite up to and including 3.6.23.1, a call to
3957: ** [sqlite3_reset()] was required after sqlite3_step() returned anything
3958: ** other than [SQLITE_ROW] before any subsequent invocation of
3959: ** sqlite3_step(). Failure to reset the prepared statement using
3960: ** [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from
3961: ** sqlite3_step(). But after version 3.6.23.1, sqlite3_step() began
3962: ** calling [sqlite3_reset()] automatically in this circumstance rather
3963: ** than returning [SQLITE_MISUSE]. This is not considered a compatibility
3964: ** break because any application that ever receives an SQLITE_MISUSE error
3965: ** is broken by definition. The [SQLITE_OMIT_AUTORESET] compile-time option
3966: ** can be used to restore the legacy behavior.
3967: **
3968: ** <b>Goofy Interface Alert:</b> In the legacy interface, the sqlite3_step()
3969: ** API always returns a generic error code, [SQLITE_ERROR], following any
3970: ** error other than [SQLITE_BUSY] and [SQLITE_MISUSE]. You must call
3971: ** [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the
3972: ** specific [error codes] that better describes the error.
3973: ** We admit that this is a goofy design. The problem has been fixed
3974: ** with the "v2" interface. If you prepare all of your SQL statements
3975: ** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead
3976: ** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces,
3977: ** then the more specific [error codes] are returned directly
3978: ** by sqlite3_step(). The use of the "v2" interface is recommended.
3979: */
3980: SQLITE_API int sqlite3_step(sqlite3_stmt*);
3981:
3982: /*
3983: ** CAPI3REF: Number of columns in a result set
3984: **
3985: ** ^The sqlite3_data_count(P) interface returns the number of columns in the
3986: ** current row of the result set of [prepared statement] P.
3987: ** ^If prepared statement P does not have results ready to return
3988: ** (via calls to the [sqlite3_column_int | sqlite3_column_*()] of
3989: ** interfaces) then sqlite3_data_count(P) returns 0.
3990: ** ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer.
3991: ** ^The sqlite3_data_count(P) routine returns 0 if the previous call to
3992: ** [sqlite3_step](P) returned [SQLITE_DONE]. ^The sqlite3_data_count(P)
3993: ** will return non-zero if previous call to [sqlite3_step](P) returned
3994: ** [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum]
3995: ** where it always returns zero since each step of that multi-step
3996: ** pragma returns 0 columns of data.
3997: **
3998: ** See also: [sqlite3_column_count()]
3999: */
4000: SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
4001:
4002: /*
4003: ** CAPI3REF: Fundamental Datatypes
4004: ** KEYWORDS: SQLITE_TEXT
4005: **
4006: ** ^(Every value in SQLite has one of five fundamental datatypes:
4007: **
4008: ** <ul>
4009: ** <li> 64-bit signed integer
4010: ** <li> 64-bit IEEE floating point number
4011: ** <li> string
4012: ** <li> BLOB
4013: ** <li> NULL
4014: ** </ul>)^
4015: **
4016: ** These constants are codes for each of those types.
4017: **
4018: ** Note that the SQLITE_TEXT constant was also used in SQLite version 2
4019: ** for a completely different meaning. Software that links against both
4020: ** SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not
4021: ** SQLITE_TEXT.
4022: */
4023: #define SQLITE_INTEGER 1
4024: #define SQLITE_FLOAT 2
4025: #define SQLITE_BLOB 4
4026: #define SQLITE_NULL 5
4027: #ifdef SQLITE_TEXT
4028: # undef SQLITE_TEXT
4029: #else
4030: # define SQLITE_TEXT 3
4031: #endif
4032: #define SQLITE3_TEXT 3
4033:
4034: /*
4035: ** CAPI3REF: Result Values From A Query
4036: ** KEYWORDS: {column access functions}
4037: **
4038: ** These routines form the "result set" interface.
4039: **
4040: ** ^These routines return information about a single column of the current
4041: ** result row of a query. ^In every case the first argument is a pointer
4042: ** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*]
4043: ** that was returned from [sqlite3_prepare_v2()] or one of its variants)
4044: ** and the second argument is the index of the column for which information
4045: ** should be returned. ^The leftmost column of the result set has the index 0.
4046: ** ^The number of columns in the result can be determined using
4047: ** [sqlite3_column_count()].
4048: **
4049: ** If the SQL statement does not currently point to a valid row, or if the
4050: ** column index is out of range, the result is undefined.
4051: ** These routines may only be called when the most recent call to
4052: ** [sqlite3_step()] has returned [SQLITE_ROW] and neither
4053: ** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently.
4054: ** If any of these routines are called after [sqlite3_reset()] or
4055: ** [sqlite3_finalize()] or after [sqlite3_step()] has returned
4056: ** something other than [SQLITE_ROW], the results are undefined.
4057: ** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()]
4058: ** are called from a different thread while any of these routines
4059: ** are pending, then the results are undefined.
4060: **
4061: ** ^The sqlite3_column_type() routine returns the
4062: ** [SQLITE_INTEGER | datatype code] for the initial data type
4063: ** of the result column. ^The returned value is one of [SQLITE_INTEGER],
4064: ** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL]. The value
4065: ** returned by sqlite3_column_type() is only meaningful if no type
4066: ** conversions have occurred as described below. After a type conversion,
4067: ** the value returned by sqlite3_column_type() is undefined. Future
4068: ** versions of SQLite may change the behavior of sqlite3_column_type()
4069: ** following a type conversion.
4070: **
4071: ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
4072: ** routine returns the number of bytes in that BLOB or string.
4073: ** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
4074: ** the string to UTF-8 and then returns the number of bytes.
4075: ** ^If the result is a numeric value then sqlite3_column_bytes() uses
4076: ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
4077: ** the number of bytes in that string.
4078: ** ^If the result is NULL, then sqlite3_column_bytes() returns zero.
4079: **
4080: ** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
4081: ** routine returns the number of bytes in that BLOB or string.
4082: ** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts
4083: ** the string to UTF-16 and then returns the number of bytes.
4084: ** ^If the result is a numeric value then sqlite3_column_bytes16() uses
4085: ** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
4086: ** the number of bytes in that string.
4087: ** ^If the result is NULL, then sqlite3_column_bytes16() returns zero.
4088: **
4089: ** ^The values returned by [sqlite3_column_bytes()] and
4090: ** [sqlite3_column_bytes16()] do not include the zero terminators at the end
4091: ** of the string. ^For clarity: the values returned by
4092: ** [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of
4093: ** bytes in the string, not the number of characters.
4094: **
4095: ** ^Strings returned by sqlite3_column_text() and sqlite3_column_text16(),
4096: ** even empty strings, are always zero-terminated. ^The return
4097: ** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
4098: **
4099: ** ^The object returned by [sqlite3_column_value()] is an
4100: ** [unprotected sqlite3_value] object. An unprotected sqlite3_value object
4101: ** may only be used with [sqlite3_bind_value()] and [sqlite3_result_value()].
4102: ** If the [unprotected sqlite3_value] object returned by
4103: ** [sqlite3_column_value()] is used in any other way, including calls
4104: ** to routines like [sqlite3_value_int()], [sqlite3_value_text()],
4105: ** or [sqlite3_value_bytes()], then the behavior is undefined.
4106: **
4107: ** These routines attempt to convert the value where appropriate. ^For
4108: ** example, if the internal representation is FLOAT and a text result
4109: ** is requested, [sqlite3_snprintf()] is used internally to perform the
4110: ** conversion automatically. ^(The following table details the conversions
4111: ** that are applied:
4112: **
4113: ** <blockquote>
4114: ** <table border="1">
4115: ** <tr><th> Internal<br>Type <th> Requested<br>Type <th> Conversion
4116: **
4117: ** <tr><td> NULL <td> INTEGER <td> Result is 0
4118: ** <tr><td> NULL <td> FLOAT <td> Result is 0.0
4119: ** <tr><td> NULL <td> TEXT <td> Result is NULL pointer
4120: ** <tr><td> NULL <td> BLOB <td> Result is NULL pointer
4121: ** <tr><td> INTEGER <td> FLOAT <td> Convert from integer to float
4122: ** <tr><td> INTEGER <td> TEXT <td> ASCII rendering of the integer
4123: ** <tr><td> INTEGER <td> BLOB <td> Same as INTEGER->TEXT
4124: ** <tr><td> FLOAT <td> INTEGER <td> Convert from float to integer
4125: ** <tr><td> FLOAT <td> TEXT <td> ASCII rendering of the float
4126: ** <tr><td> FLOAT <td> BLOB <td> Same as FLOAT->TEXT
4127: ** <tr><td> TEXT <td> INTEGER <td> Use atoi()
4128: ** <tr><td> TEXT <td> FLOAT <td> Use atof()
4129: ** <tr><td> TEXT <td> BLOB <td> No change
4130: ** <tr><td> BLOB <td> INTEGER <td> Convert to TEXT then use atoi()
4131: ** <tr><td> BLOB <td> FLOAT <td> Convert to TEXT then use atof()
4132: ** <tr><td> BLOB <td> TEXT <td> Add a zero terminator if needed
4133: ** </table>
4134: ** </blockquote>)^
4135: **
4136: ** The table above makes reference to standard C library functions atoi()
4137: ** and atof(). SQLite does not really use these functions. It has its
4138: ** own equivalent internal routines. The atoi() and atof() names are
4139: ** used in the table for brevity and because they are familiar to most
4140: ** C programmers.
4141: **
4142: ** Note that when type conversions occur, pointers returned by prior
4143: ** calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
4144: ** sqlite3_column_text16() may be invalidated.
4145: ** Type conversions and pointer invalidations might occur
4146: ** in the following cases:
4147: **
4148: ** <ul>
4149: ** <li> The initial content is a BLOB and sqlite3_column_text() or
4150: ** sqlite3_column_text16() is called. A zero-terminator might
4151: ** need to be added to the string.</li>
4152: ** <li> The initial content is UTF-8 text and sqlite3_column_bytes16() or
4153: ** sqlite3_column_text16() is called. The content must be converted
4154: ** to UTF-16.</li>
4155: ** <li> The initial content is UTF-16 text and sqlite3_column_bytes() or
4156: ** sqlite3_column_text() is called. The content must be converted
4157: ** to UTF-8.</li>
4158: ** </ul>
4159: **
4160: ** ^Conversions between UTF-16be and UTF-16le are always done in place and do
4161: ** not invalidate a prior pointer, though of course the content of the buffer
4162: ** that the prior pointer references will have been modified. Other kinds
4163: ** of conversion are done in place when it is possible, but sometimes they
4164: ** are not possible and in those cases prior pointers are invalidated.
4165: **
4166: ** The safest and easiest to remember policy is to invoke these routines
4167: ** in one of the following ways:
4168: **
4169: ** <ul>
4170: ** <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
4171: ** <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
4172: ** <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
4173: ** </ul>
4174: **
4175: ** In other words, you should call sqlite3_column_text(),
4176: ** sqlite3_column_blob(), or sqlite3_column_text16() first to force the result
4177: ** into the desired format, then invoke sqlite3_column_bytes() or
4178: ** sqlite3_column_bytes16() to find the size of the result. Do not mix calls
4179: ** to sqlite3_column_text() or sqlite3_column_blob() with calls to
4180: ** sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16()
4181: ** with calls to sqlite3_column_bytes().
4182: **
4183: ** ^The pointers returned are valid until a type conversion occurs as
4184: ** described above, or until [sqlite3_step()] or [sqlite3_reset()] or
4185: ** [sqlite3_finalize()] is called. ^The memory space used to hold strings
4186: ** and BLOBs is freed automatically. Do <b>not</b> pass the pointers returned
4187: ** [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
4188: ** [sqlite3_free()].
4189: **
4190: ** ^(If a memory allocation error occurs during the evaluation of any
4191: ** of these routines, a default value is returned. The default value
4192: ** is either the integer 0, the floating point number 0.0, or a NULL
4193: ** pointer. Subsequent calls to [sqlite3_errcode()] will return
4194: ** [SQLITE_NOMEM].)^
4195: */
4196: SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
4197: SQLITE_API int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
4198: SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
4199: SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
4200: SQLITE_API int sqlite3_column_int(sqlite3_stmt*, int iCol);
4201: SQLITE_API sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
4202: SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
4203: SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
4204: SQLITE_API int sqlite3_column_type(sqlite3_stmt*, int iCol);
4205: SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
4206:
4207: /*
4208: ** CAPI3REF: Destroy A Prepared Statement Object
4209: **
4210: ** ^The sqlite3_finalize() function is called to delete a [prepared statement].
4211: ** ^If the most recent evaluation of the statement encountered no errors
4212: ** or if the statement is never been evaluated, then sqlite3_finalize() returns
4213: ** SQLITE_OK. ^If the most recent evaluation of statement S failed, then
4214: ** sqlite3_finalize(S) returns the appropriate [error code] or
4215: ** [extended error code].
4216: **
4217: ** ^The sqlite3_finalize(S) routine can be called at any point during
4218: ** the life cycle of [prepared statement] S:
4219: ** before statement S is ever evaluated, after
4220: ** one or more calls to [sqlite3_reset()], or after any call
4221: ** to [sqlite3_step()] regardless of whether or not the statement has
4222: ** completed execution.
4223: **
4224: ** ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op.
4225: **
4226: ** The application must finalize every [prepared statement] in order to avoid
4227: ** resource leaks. It is a grievous error for the application to try to use
4228: ** a prepared statement after it has been finalized. Any use of a prepared
4229: ** statement after it has been finalized can result in undefined and
4230: ** undesirable behavior such as segfaults and heap corruption.
4231: */
4232: SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt);
4233:
4234: /*
4235: ** CAPI3REF: Reset A Prepared Statement Object
4236: **
4237: ** The sqlite3_reset() function is called to reset a [prepared statement]
4238: ** object back to its initial state, ready to be re-executed.
4239: ** ^Any SQL statement variables that had values bound to them using
4240: ** the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values.
4241: ** Use [sqlite3_clear_bindings()] to reset the bindings.
4242: **
4243: ** ^The [sqlite3_reset(S)] interface resets the [prepared statement] S
4244: ** back to the beginning of its program.
4245: **
4246: ** ^If the most recent call to [sqlite3_step(S)] for the
4247: ** [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE],
4248: ** or if [sqlite3_step(S)] has never before been called on S,
4249: ** then [sqlite3_reset(S)] returns [SQLITE_OK].
4250: **
4251: ** ^If the most recent call to [sqlite3_step(S)] for the
4252: ** [prepared statement] S indicated an error, then
4253: ** [sqlite3_reset(S)] returns an appropriate [error code].
4254: **
4255: ** ^The [sqlite3_reset(S)] interface does not change the values
4256: ** of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
4257: */
4258: SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
4259:
4260: /*
4261: ** CAPI3REF: Create Or Redefine SQL Functions
4262: ** KEYWORDS: {function creation routines}
4263: ** KEYWORDS: {application-defined SQL function}
4264: ** KEYWORDS: {application-defined SQL functions}
4265: **
4266: ** ^These functions (collectively known as "function creation routines")
4267: ** are used to add SQL functions or aggregates or to redefine the behavior
4268: ** of existing SQL functions or aggregates. The only differences between
4269: ** these routines are the text encoding expected for
4270: ** the second parameter (the name of the function being created)
4271: ** and the presence or absence of a destructor callback for
4272: ** the application data pointer.
4273: **
4274: ** ^The first parameter is the [database connection] to which the SQL
4275: ** function is to be added. ^If an application uses more than one database
4276: ** connection then application-defined SQL functions must be added
4277: ** to each database connection separately.
4278: **
4279: ** ^The second parameter is the name of the SQL function to be created or
4280: ** redefined. ^The length of the name is limited to 255 bytes in a UTF-8
4281: ** representation, exclusive of the zero-terminator. ^Note that the name
4282: ** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
4283: ** ^Any attempt to create a function with a longer name
4284: ** will result in [SQLITE_MISUSE] being returned.
4285: **
4286: ** ^The third parameter (nArg)
4287: ** is the number of arguments that the SQL function or
4288: ** aggregate takes. ^If this parameter is -1, then the SQL function or
4289: ** aggregate may take any number of arguments between 0 and the limit
4290: ** set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]). If the third
4291: ** parameter is less than -1 or greater than 127 then the behavior is
4292: ** undefined.
4293: **
4294: ** ^The fourth parameter, eTextRep, specifies what
4295: ** [SQLITE_UTF8 | text encoding] this SQL function prefers for
4296: ** its parameters. Every SQL function implementation must be able to work
4297: ** with UTF-8, UTF-16le, or UTF-16be. But some implementations may be
4298: ** more efficient with one encoding than another. ^An application may
4299: ** invoke sqlite3_create_function() or sqlite3_create_function16() multiple
4300: ** times with the same function but with different values of eTextRep.
4301: ** ^When multiple implementations of the same function are available, SQLite
4302: ** will pick the one that involves the least amount of data conversion.
4303: ** If there is only a single implementation which does not care what text
4304: ** encoding is used, then the fourth argument should be [SQLITE_ANY].
4305: **
4306: ** ^(The fifth parameter is an arbitrary pointer. The implementation of the
4307: ** function can gain access to this pointer using [sqlite3_user_data()].)^
4308: **
4309: ** ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are
4310: ** pointers to C-language functions that implement the SQL function or
4311: ** aggregate. ^A scalar SQL function requires an implementation of the xFunc
4312: ** callback only; NULL pointers must be passed as the xStep and xFinal
4313: ** parameters. ^An aggregate SQL function requires an implementation of xStep
4314: ** and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing
4315: ** SQL function or aggregate, pass NULL pointers for all three function
4316: ** callbacks.
4317: **
4318: ** ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL,
4319: ** then it is destructor for the application data pointer.
4320: ** The destructor is invoked when the function is deleted, either by being
4321: ** overloaded or when the database connection closes.)^
4322: ** ^The destructor is also invoked if the call to
4323: ** sqlite3_create_function_v2() fails.
4324: ** ^When the destructor callback of the tenth parameter is invoked, it
4325: ** is passed a single argument which is a copy of the application data
4326: ** pointer which was the fifth parameter to sqlite3_create_function_v2().
4327: **
4328: ** ^It is permitted to register multiple implementations of the same
4329: ** functions with the same name but with either differing numbers of
4330: ** arguments or differing preferred text encodings. ^SQLite will use
4331: ** the implementation that most closely matches the way in which the
4332: ** SQL function is used. ^A function implementation with a non-negative
4333: ** nArg parameter is a better match than a function implementation with
4334: ** a negative nArg. ^A function where the preferred text encoding
4335: ** matches the database encoding is a better
4336: ** match than a function where the encoding is different.
4337: ** ^A function where the encoding difference is between UTF16le and UTF16be
4338: ** is a closer match than a function where the encoding difference is
4339: ** between UTF8 and UTF16.
4340: **
4341: ** ^Built-in functions may be overloaded by new application-defined functions.
4342: **
4343: ** ^An application-defined function is permitted to call other
4344: ** SQLite interfaces. However, such calls must not
4345: ** close the database connection nor finalize or reset the prepared
4346: ** statement in which the function is running.
4347: */
4348: SQLITE_API int sqlite3_create_function(
4349: sqlite3 *db,
4350: const char *zFunctionName,
4351: int nArg,
4352: int eTextRep,
4353: void *pApp,
4354: void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
4355: void (*xStep)(sqlite3_context*,int,sqlite3_value**),
4356: void (*xFinal)(sqlite3_context*)
4357: );
4358: SQLITE_API int sqlite3_create_function16(
4359: sqlite3 *db,
4360: const void *zFunctionName,
4361: int nArg,
4362: int eTextRep,
4363: void *pApp,
4364: void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
4365: void (*xStep)(sqlite3_context*,int,sqlite3_value**),
4366: void (*xFinal)(sqlite3_context*)
4367: );
4368: SQLITE_API int sqlite3_create_function_v2(
4369: sqlite3 *db,
4370: const char *zFunctionName,
4371: int nArg,
4372: int eTextRep,
4373: void *pApp,
4374: void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
4375: void (*xStep)(sqlite3_context*,int,sqlite3_value**),
4376: void (*xFinal)(sqlite3_context*),
4377: void(*xDestroy)(void*)
4378: );
4379:
4380: /*
4381: ** CAPI3REF: Text Encodings
4382: **
4383: ** These constant define integer codes that represent the various
4384: ** text encodings supported by SQLite.
4385: */
4386: #define SQLITE_UTF8 1
4387: #define SQLITE_UTF16LE 2
4388: #define SQLITE_UTF16BE 3
4389: #define SQLITE_UTF16 4 /* Use native byte order */
4390: #define SQLITE_ANY 5 /* sqlite3_create_function only */
4391: #define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */
4392:
4393: /*
4394: ** CAPI3REF: Deprecated Functions
4395: ** DEPRECATED
4396: **
4397: ** These functions are [deprecated]. In order to maintain
4398: ** backwards compatibility with older code, these functions continue
4399: ** to be supported. However, new applications should avoid
4400: ** the use of these functions. To help encourage people to avoid
4401: ** using these functions, we are not going to tell you what they do.
4402: */
4403: #ifndef SQLITE_OMIT_DEPRECATED
4404: SQLITE_API SQLITE_DEPRECATED int sqlite3_aggregate_count(sqlite3_context*);
4405: SQLITE_API SQLITE_DEPRECATED int sqlite3_expired(sqlite3_stmt*);
4406: SQLITE_API SQLITE_DEPRECATED int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
4407: SQLITE_API SQLITE_DEPRECATED int sqlite3_global_recover(void);
4408: SQLITE_API SQLITE_DEPRECATED void sqlite3_thread_cleanup(void);
4409: SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),void*,sqlite3_int64);
4410: #endif
4411:
4412: /*
4413: ** CAPI3REF: Obtaining SQL Function Parameter Values
4414: **
4415: ** The C-language implementation of SQL functions and aggregates uses
4416: ** this set of interface routines to access the parameter values on
4417: ** the function or aggregate.
4418: **
4419: ** The xFunc (for scalar functions) or xStep (for aggregates) parameters
4420: ** to [sqlite3_create_function()] and [sqlite3_create_function16()]
4421: ** define callbacks that implement the SQL functions and aggregates.
4422: ** The 3rd parameter to these callbacks is an array of pointers to
4423: ** [protected sqlite3_value] objects. There is one [sqlite3_value] object for
4424: ** each parameter to the SQL function. These routines are used to
4425: ** extract values from the [sqlite3_value] objects.
4426: **
4427: ** These routines work only with [protected sqlite3_value] objects.
4428: ** Any attempt to use these routines on an [unprotected sqlite3_value]
4429: ** object results in undefined behavior.
4430: **
4431: ** ^These routines work just like the corresponding [column access functions]
4432: ** except that these routines take a single [protected sqlite3_value] object
4433: ** pointer instead of a [sqlite3_stmt*] pointer and an integer column number.
4434: **
4435: ** ^The sqlite3_value_text16() interface extracts a UTF-16 string
4436: ** in the native byte-order of the host machine. ^The
4437: ** sqlite3_value_text16be() and sqlite3_value_text16le() interfaces
4438: ** extract UTF-16 strings as big-endian and little-endian respectively.
4439: **
4440: ** ^(The sqlite3_value_numeric_type() interface attempts to apply
4441: ** numeric affinity to the value. This means that an attempt is
4442: ** made to convert the value to an integer or floating point. If
4443: ** such a conversion is possible without loss of information (in other
4444: ** words, if the value is a string that looks like a number)
4445: ** then the conversion is performed. Otherwise no conversion occurs.
4446: ** The [SQLITE_INTEGER | datatype] after conversion is returned.)^
4447: **
4448: ** Please pay particular attention to the fact that the pointer returned
4449: ** from [sqlite3_value_blob()], [sqlite3_value_text()], or
4450: ** [sqlite3_value_text16()] can be invalidated by a subsequent call to
4451: ** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()],
4452: ** or [sqlite3_value_text16()].
4453: **
4454: ** These routines must be called from the same thread as
4455: ** the SQL function that supplied the [sqlite3_value*] parameters.
4456: */
4457: SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
4458: SQLITE_API int sqlite3_value_bytes(sqlite3_value*);
4459: SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
4460: SQLITE_API double sqlite3_value_double(sqlite3_value*);
4461: SQLITE_API int sqlite3_value_int(sqlite3_value*);
4462: SQLITE_API sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
4463: SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value*);
4464: SQLITE_API const void *sqlite3_value_text16(sqlite3_value*);
4465: SQLITE_API const void *sqlite3_value_text16le(sqlite3_value*);
4466: SQLITE_API const void *sqlite3_value_text16be(sqlite3_value*);
4467: SQLITE_API int sqlite3_value_type(sqlite3_value*);
4468: SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
4469:
4470: /*
4471: ** CAPI3REF: Obtain Aggregate Function Context
4472: **
4473: ** Implementations of aggregate SQL functions use this
4474: ** routine to allocate memory for storing their state.
4475: **
4476: ** ^The first time the sqlite3_aggregate_context(C,N) routine is called
4477: ** for a particular aggregate function, SQLite
4478: ** allocates N of memory, zeroes out that memory, and returns a pointer
4479: ** to the new memory. ^On second and subsequent calls to
4480: ** sqlite3_aggregate_context() for the same aggregate function instance,
4481: ** the same buffer is returned. Sqlite3_aggregate_context() is normally
4482: ** called once for each invocation of the xStep callback and then one
4483: ** last time when the xFinal callback is invoked. ^(When no rows match
4484: ** an aggregate query, the xStep() callback of the aggregate function
4485: ** implementation is never called and xFinal() is called exactly once.
4486: ** In those cases, sqlite3_aggregate_context() might be called for the
4487: ** first time from within xFinal().)^
4488: **
4489: ** ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer if N is
4490: ** less than or equal to zero or if a memory allocate error occurs.
4491: **
4492: ** ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is
4493: ** determined by the N parameter on first successful call. Changing the
4494: ** value of N in subsequent call to sqlite3_aggregate_context() within
4495: ** the same aggregate function instance will not resize the memory
4496: ** allocation.)^
4497: **
4498: ** ^SQLite automatically frees the memory allocated by
4499: ** sqlite3_aggregate_context() when the aggregate query concludes.
4500: **
4501: ** The first parameter must be a copy of the
4502: ** [sqlite3_context | SQL function context] that is the first parameter
4503: ** to the xStep or xFinal callback routine that implements the aggregate
4504: ** function.
4505: **
4506: ** This routine must be called from the same thread in which
4507: ** the aggregate SQL function is running.
4508: */
4509: SQLITE_API void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);
4510:
4511: /*
4512: ** CAPI3REF: User Data For Functions
4513: **
4514: ** ^The sqlite3_user_data() interface returns a copy of
4515: ** the pointer that was the pUserData parameter (the 5th parameter)
4516: ** of the [sqlite3_create_function()]
4517: ** and [sqlite3_create_function16()] routines that originally
4518: ** registered the application defined function.
4519: **
4520: ** This routine must be called from the same thread in which
4521: ** the application-defined function is running.
4522: */
4523: SQLITE_API void *sqlite3_user_data(sqlite3_context*);
4524:
4525: /*
4526: ** CAPI3REF: Database Connection For Functions
4527: **
4528: ** ^The sqlite3_context_db_handle() interface returns a copy of
4529: ** the pointer to the [database connection] (the 1st parameter)
4530: ** of the [sqlite3_create_function()]
4531: ** and [sqlite3_create_function16()] routines that originally
4532: ** registered the application defined function.
4533: */
4534: SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context*);
4535:
4536: /*
4537: ** CAPI3REF: Function Auxiliary Data
4538: **
4539: ** The following two functions may be used by scalar SQL functions to
4540: ** associate metadata with argument values. If the same value is passed to
4541: ** multiple invocations of the same SQL function during query execution, under
4542: ** some circumstances the associated metadata may be preserved. This may
4543: ** be used, for example, to add a regular-expression matching scalar
4544: ** function. The compiled version of the regular expression is stored as
4545: ** metadata associated with the SQL value passed as the regular expression
4546: ** pattern. The compiled regular expression can be reused on multiple
4547: ** invocations of the same function so that the original pattern string
4548: ** does not need to be recompiled on each invocation.
4549: **
4550: ** ^The sqlite3_get_auxdata() interface returns a pointer to the metadata
4551: ** associated by the sqlite3_set_auxdata() function with the Nth argument
4552: ** value to the application-defined function. ^If no metadata has been ever
4553: ** been set for the Nth argument of the function, or if the corresponding
4554: ** function parameter has changed since the meta-data was set,
4555: ** then sqlite3_get_auxdata() returns a NULL pointer.
4556: **
4557: ** ^The sqlite3_set_auxdata() interface saves the metadata
4558: ** pointed to by its 3rd parameter as the metadata for the N-th
4559: ** argument of the application-defined function. Subsequent
4560: ** calls to sqlite3_get_auxdata() might return this data, if it has
4561: ** not been destroyed.
4562: ** ^If it is not NULL, SQLite will invoke the destructor
4563: ** function given by the 4th parameter to sqlite3_set_auxdata() on
4564: ** the metadata when the corresponding function parameter changes
4565: ** or when the SQL statement completes, whichever comes first.
4566: **
4567: ** SQLite is free to call the destructor and drop metadata on any
4568: ** parameter of any function at any time. ^The only guarantee is that
4569: ** the destructor will be called before the metadata is dropped.
4570: **
4571: ** ^(In practice, metadata is preserved between function calls for
4572: ** expressions that are constant at compile time. This includes literal
4573: ** values and [parameters].)^
4574: **
4575: ** These routines must be called from the same thread in which
4576: ** the SQL function is running.
4577: */
4578: SQLITE_API void *sqlite3_get_auxdata(sqlite3_context*, int N);
4579: SQLITE_API void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));
4580:
4581:
4582: /*
4583: ** CAPI3REF: Constants Defining Special Destructor Behavior
4584: **
4585: ** These are special values for the destructor that is passed in as the
4586: ** final argument to routines like [sqlite3_result_blob()]. ^If the destructor
4587: ** argument is SQLITE_STATIC, it means that the content pointer is constant
4588: ** and will never change. It does not need to be destroyed. ^The
4589: ** SQLITE_TRANSIENT value means that the content will likely change in
4590: ** the near future and that SQLite should make its own private copy of
4591: ** the content before returning.
4592: **
4593: ** The typedef is necessary to work around problems in certain
4594: ** C++ compilers. See ticket #2191.
4595: */
4596: typedef void (*sqlite3_destructor_type)(void*);
4597: #define SQLITE_STATIC ((sqlite3_destructor_type)0)
4598: #define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1)
4599:
4600: /*
4601: ** CAPI3REF: Setting The Result Of An SQL Function
4602: **
4603: ** These routines are used by the xFunc or xFinal callbacks that
4604: ** implement SQL functions and aggregates. See
4605: ** [sqlite3_create_function()] and [sqlite3_create_function16()]
4606: ** for additional information.
4607: **
4608: ** These functions work very much like the [parameter binding] family of
4609: ** functions used to bind values to host parameters in prepared statements.
4610: ** Refer to the [SQL parameter] documentation for additional information.
4611: **
4612: ** ^The sqlite3_result_blob() interface sets the result from
4613: ** an application-defined function to be the BLOB whose content is pointed
4614: ** to by the second parameter and which is N bytes long where N is the
4615: ** third parameter.
4616: **
4617: ** ^The sqlite3_result_zeroblob() interfaces set the result of
4618: ** the application-defined function to be a BLOB containing all zero
4619: ** bytes and N bytes in size, where N is the value of the 2nd parameter.
4620: **
4621: ** ^The sqlite3_result_double() interface sets the result from
4622: ** an application-defined function to be a floating point value specified
4623: ** by its 2nd argument.
4624: **
4625: ** ^The sqlite3_result_error() and sqlite3_result_error16() functions
4626: ** cause the implemented SQL function to throw an exception.
4627: ** ^SQLite uses the string pointed to by the
4628: ** 2nd parameter of sqlite3_result_error() or sqlite3_result_error16()
4629: ** as the text of an error message. ^SQLite interprets the error
4630: ** message string from sqlite3_result_error() as UTF-8. ^SQLite
4631: ** interprets the string from sqlite3_result_error16() as UTF-16 in native
4632: ** byte order. ^If the third parameter to sqlite3_result_error()
4633: ** or sqlite3_result_error16() is negative then SQLite takes as the error
4634: ** message all text up through the first zero character.
4635: ** ^If the third parameter to sqlite3_result_error() or
4636: ** sqlite3_result_error16() is non-negative then SQLite takes that many
4637: ** bytes (not characters) from the 2nd parameter as the error message.
4638: ** ^The sqlite3_result_error() and sqlite3_result_error16()
4639: ** routines make a private copy of the error message text before
4640: ** they return. Hence, the calling function can deallocate or
4641: ** modify the text after they return without harm.
4642: ** ^The sqlite3_result_error_code() function changes the error code
4643: ** returned by SQLite as a result of an error in a function. ^By default,
4644: ** the error code is SQLITE_ERROR. ^A subsequent call to sqlite3_result_error()
4645: ** or sqlite3_result_error16() resets the error code to SQLITE_ERROR.
4646: **
4647: ** ^The sqlite3_result_toobig() interface causes SQLite to throw an error
4648: ** indicating that a string or BLOB is too long to represent.
4649: **
4650: ** ^The sqlite3_result_nomem() interface causes SQLite to throw an error
4651: ** indicating that a memory allocation failed.
4652: **
4653: ** ^The sqlite3_result_int() interface sets the return value
4654: ** of the application-defined function to be the 32-bit signed integer
4655: ** value given in the 2nd argument.
4656: ** ^The sqlite3_result_int64() interface sets the return value
4657: ** of the application-defined function to be the 64-bit signed integer
4658: ** value given in the 2nd argument.
4659: **
4660: ** ^The sqlite3_result_null() interface sets the return value
4661: ** of the application-defined function to be NULL.
4662: **
4663: ** ^The sqlite3_result_text(), sqlite3_result_text16(),
4664: ** sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces
4665: ** set the return value of the application-defined function to be
4666: ** a text string which is represented as UTF-8, UTF-16 native byte order,
4667: ** UTF-16 little endian, or UTF-16 big endian, respectively.
4668: ** ^SQLite takes the text result from the application from
4669: ** the 2nd parameter of the sqlite3_result_text* interfaces.
4670: ** ^If the 3rd parameter to the sqlite3_result_text* interfaces
4671: ** is negative, then SQLite takes result text from the 2nd parameter
4672: ** through the first zero character.
4673: ** ^If the 3rd parameter to the sqlite3_result_text* interfaces
4674: ** is non-negative, then as many bytes (not characters) of the text
4675: ** pointed to by the 2nd parameter are taken as the application-defined
4676: ** function result. If the 3rd parameter is non-negative, then it
4677: ** must be the byte offset into the string where the NUL terminator would
4678: ** appear if the string where NUL terminated. If any NUL characters occur
4679: ** in the string at a byte offset that is less than the value of the 3rd
4680: ** parameter, then the resulting string will contain embedded NULs and the
4681: ** result of expressions operating on strings with embedded NULs is undefined.
4682: ** ^If the 4th parameter to the sqlite3_result_text* interfaces
4683: ** or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
4684: ** function as the destructor on the text or BLOB result when it has
4685: ** finished using that result.
4686: ** ^If the 4th parameter to the sqlite3_result_text* interfaces or to
4687: ** sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite
4688: ** assumes that the text or BLOB result is in constant space and does not
4689: ** copy the content of the parameter nor call a destructor on the content
4690: ** when it has finished using that result.
4691: ** ^If the 4th parameter to the sqlite3_result_text* interfaces
4692: ** or sqlite3_result_blob is the special constant SQLITE_TRANSIENT
4693: ** then SQLite makes a copy of the result into space obtained from
4694: ** from [sqlite3_malloc()] before it returns.
4695: **
4696: ** ^The sqlite3_result_value() interface sets the result of
4697: ** the application-defined function to be a copy the
4698: ** [unprotected sqlite3_value] object specified by the 2nd parameter. ^The
4699: ** sqlite3_result_value() interface makes a copy of the [sqlite3_value]
4700: ** so that the [sqlite3_value] specified in the parameter may change or
4701: ** be deallocated after sqlite3_result_value() returns without harm.
4702: ** ^A [protected sqlite3_value] object may always be used where an
4703: ** [unprotected sqlite3_value] object is required, so either
4704: ** kind of [sqlite3_value] object can be used with this interface.
4705: **
4706: ** If these routines are called from within the different thread
4707: ** than the one containing the application-defined function that received
4708: ** the [sqlite3_context] pointer, the results are undefined.
4709: */
4710: SQLITE_API void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
4711: SQLITE_API void sqlite3_result_double(sqlite3_context*, double);
4712: SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);
4713: SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, int);
4714: SQLITE_API void sqlite3_result_error_toobig(sqlite3_context*);
4715: SQLITE_API void sqlite3_result_error_nomem(sqlite3_context*);
4716: SQLITE_API void sqlite3_result_error_code(sqlite3_context*, int);
4717: SQLITE_API void sqlite3_result_int(sqlite3_context*, int);
4718: SQLITE_API void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
4719: SQLITE_API void sqlite3_result_null(sqlite3_context*);
4720: SQLITE_API void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
4721: SQLITE_API void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
4722: SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
4723: SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
4724: SQLITE_API void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
4725: SQLITE_API void sqlite3_result_zeroblob(sqlite3_context*, int n);
4726:
4727: /*
4728: ** CAPI3REF: Define New Collating Sequences
4729: **
4730: ** ^These functions add, remove, or modify a [collation] associated
4731: ** with the [database connection] specified as the first argument.
4732: **
4733: ** ^The name of the collation is a UTF-8 string
4734: ** for sqlite3_create_collation() and sqlite3_create_collation_v2()
4735: ** and a UTF-16 string in native byte order for sqlite3_create_collation16().
4736: ** ^Collation names that compare equal according to [sqlite3_strnicmp()] are
4737: ** considered to be the same name.
4738: **
4739: ** ^(The third argument (eTextRep) must be one of the constants:
4740: ** <ul>
4741: ** <li> [SQLITE_UTF8],
4742: ** <li> [SQLITE_UTF16LE],
4743: ** <li> [SQLITE_UTF16BE],
4744: ** <li> [SQLITE_UTF16], or
4745: ** <li> [SQLITE_UTF16_ALIGNED].
4746: ** </ul>)^
4747: ** ^The eTextRep argument determines the encoding of strings passed
4748: ** to the collating function callback, xCallback.
4749: ** ^The [SQLITE_UTF16] and [SQLITE_UTF16_ALIGNED] values for eTextRep
4750: ** force strings to be UTF16 with native byte order.
4751: ** ^The [SQLITE_UTF16_ALIGNED] value for eTextRep forces strings to begin
4752: ** on an even byte address.
4753: **
4754: ** ^The fourth argument, pArg, is an application data pointer that is passed
4755: ** through as the first argument to the collating function callback.
4756: **
4757: ** ^The fifth argument, xCallback, is a pointer to the collating function.
4758: ** ^Multiple collating functions can be registered using the same name but
4759: ** with different eTextRep parameters and SQLite will use whichever
4760: ** function requires the least amount of data transformation.
4761: ** ^If the xCallback argument is NULL then the collating function is
4762: ** deleted. ^When all collating functions having the same name are deleted,
4763: ** that collation is no longer usable.
4764: **
4765: ** ^The collating function callback is invoked with a copy of the pArg
4766: ** application data pointer and with two strings in the encoding specified
4767: ** by the eTextRep argument. The collating function must return an
4768: ** integer that is negative, zero, or positive
4769: ** if the first string is less than, equal to, or greater than the second,
4770: ** respectively. A collating function must always return the same answer
4771: ** given the same inputs. If two or more collating functions are registered
4772: ** to the same collation name (using different eTextRep values) then all
4773: ** must give an equivalent answer when invoked with equivalent strings.
4774: ** The collating function must obey the following properties for all
4775: ** strings A, B, and C:
4776: **
4777: ** <ol>
4778: ** <li> If A==B then B==A.
4779: ** <li> If A==B and B==C then A==C.
4780: ** <li> If A<B THEN B>A.
4781: ** <li> If A<B and B<C then A<C.
4782: ** </ol>
4783: **
4784: ** If a collating function fails any of the above constraints and that
4785: ** collating function is registered and used, then the behavior of SQLite
4786: ** is undefined.
4787: **
4788: ** ^The sqlite3_create_collation_v2() works like sqlite3_create_collation()
4789: ** with the addition that the xDestroy callback is invoked on pArg when
4790: ** the collating function is deleted.
4791: ** ^Collating functions are deleted when they are overridden by later
4792: ** calls to the collation creation functions or when the
4793: ** [database connection] is closed using [sqlite3_close()].
4794: **
4795: ** ^The xDestroy callback is <u>not</u> called if the
4796: ** sqlite3_create_collation_v2() function fails. Applications that invoke
4797: ** sqlite3_create_collation_v2() with a non-NULL xDestroy argument should
4798: ** check the return code and dispose of the application data pointer
4799: ** themselves rather than expecting SQLite to deal with it for them.
4800: ** This is different from every other SQLite interface. The inconsistency
4801: ** is unfortunate but cannot be changed without breaking backwards
4802: ** compatibility.
4803: **
4804: ** See also: [sqlite3_collation_needed()] and [sqlite3_collation_needed16()].
4805: */
4806: SQLITE_API int sqlite3_create_collation(
4807: sqlite3*,
4808: const char *zName,
4809: int eTextRep,
4810: void *pArg,
4811: int(*xCompare)(void*,int,const void*,int,const void*)
4812: );
4813: SQLITE_API int sqlite3_create_collation_v2(
4814: sqlite3*,
4815: const char *zName,
4816: int eTextRep,
4817: void *pArg,
4818: int(*xCompare)(void*,int,const void*,int,const void*),
4819: void(*xDestroy)(void*)
4820: );
4821: SQLITE_API int sqlite3_create_collation16(
4822: sqlite3*,
4823: const void *zName,
4824: int eTextRep,
4825: void *pArg,
4826: int(*xCompare)(void*,int,const void*,int,const void*)
4827: );
4828:
4829: /*
4830: ** CAPI3REF: Collation Needed Callbacks
4831: **
4832: ** ^To avoid having to register all collation sequences before a database
4833: ** can be used, a single callback function may be registered with the
4834: ** [database connection] to be invoked whenever an undefined collation
4835: ** sequence is required.
4836: **
4837: ** ^If the function is registered using the sqlite3_collation_needed() API,
4838: ** then it is passed the names of undefined collation sequences as strings
4839: ** encoded in UTF-8. ^If sqlite3_collation_needed16() is used,
4840: ** the names are passed as UTF-16 in machine native byte order.
4841: ** ^A call to either function replaces the existing collation-needed callback.
4842: **
4843: ** ^(When the callback is invoked, the first argument passed is a copy
4844: ** of the second argument to sqlite3_collation_needed() or
4845: ** sqlite3_collation_needed16(). The second argument is the database
4846: ** connection. The third argument is one of [SQLITE_UTF8], [SQLITE_UTF16BE],
4847: ** or [SQLITE_UTF16LE], indicating the most desirable form of the collation
4848: ** sequence function required. The fourth parameter is the name of the
4849: ** required collation sequence.)^
4850: **
4851: ** The callback function should register the desired collation using
4852: ** [sqlite3_create_collation()], [sqlite3_create_collation16()], or
4853: ** [sqlite3_create_collation_v2()].
4854: */
4855: SQLITE_API int sqlite3_collation_needed(
4856: sqlite3*,
4857: void*,
4858: void(*)(void*,sqlite3*,int eTextRep,const char*)
4859: );
4860: SQLITE_API int sqlite3_collation_needed16(
4861: sqlite3*,
4862: void*,
4863: void(*)(void*,sqlite3*,int eTextRep,const void*)
4864: );
4865:
4866: #ifdef SQLITE_HAS_CODEC
4867: /*
4868: ** Specify the key for an encrypted database. This routine should be
4869: ** called right after sqlite3_open().
4870: **
4871: ** The code to implement this API is not available in the public release
4872: ** of SQLite.
4873: */
4874: SQLITE_API int sqlite3_key(
4875: sqlite3 *db, /* Database to be rekeyed */
4876: const void *pKey, int nKey /* The key */
4877: );
4878:
4879: /*
4880: ** Change the key on an open database. If the current database is not
4881: ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the
4882: ** database is decrypted.
4883: **
4884: ** The code to implement this API is not available in the public release
4885: ** of SQLite.
4886: */
4887: SQLITE_API int sqlite3_rekey(
4888: sqlite3 *db, /* Database to be rekeyed */
4889: const void *pKey, int nKey /* The new key */
4890: );
4891:
4892: /*
4893: ** Specify the activation key for a SEE database. Unless
4894: ** activated, none of the SEE routines will work.
4895: */
4896: SQLITE_API void sqlite3_activate_see(
4897: const char *zPassPhrase /* Activation phrase */
4898: );
4899: #endif
4900:
4901: #ifdef SQLITE_ENABLE_CEROD
4902: /*
4903: ** Specify the activation key for a CEROD database. Unless
4904: ** activated, none of the CEROD routines will work.
4905: */
4906: SQLITE_API void sqlite3_activate_cerod(
4907: const char *zPassPhrase /* Activation phrase */
4908: );
4909: #endif
4910:
4911: /*
4912: ** CAPI3REF: Suspend Execution For A Short Time
4913: **
4914: ** The sqlite3_sleep() function causes the current thread to suspend execution
4915: ** for at least a number of milliseconds specified in its parameter.
4916: **
4917: ** If the operating system does not support sleep requests with
4918: ** millisecond time resolution, then the time will be rounded up to
4919: ** the nearest second. The number of milliseconds of sleep actually
4920: ** requested from the operating system is returned.
4921: **
4922: ** ^SQLite implements this interface by calling the xSleep()
4923: ** method of the default [sqlite3_vfs] object. If the xSleep() method
4924: ** of the default VFS is not implemented correctly, or not implemented at
4925: ** all, then the behavior of sqlite3_sleep() may deviate from the description
4926: ** in the previous paragraphs.
4927: */
4928: SQLITE_API int sqlite3_sleep(int);
4929:
4930: /*
4931: ** CAPI3REF: Name Of The Folder Holding Temporary Files
4932: **
4933: ** ^(If this global variable is made to point to a string which is
4934: ** the name of a folder (a.k.a. directory), then all temporary files
4935: ** created by SQLite when using a built-in [sqlite3_vfs | VFS]
4936: ** will be placed in that directory.)^ ^If this variable
4937: ** is a NULL pointer, then SQLite performs a search for an appropriate
4938: ** temporary file directory.
4939: **
4940: ** It is not safe to read or modify this variable in more than one
4941: ** thread at a time. It is not safe to read or modify this variable
4942: ** if a [database connection] is being used at the same time in a separate
4943: ** thread.
4944: ** It is intended that this variable be set once
4945: ** as part of process initialization and before any SQLite interface
4946: ** routines have been called and that this variable remain unchanged
4947: ** thereafter.
4948: **
4949: ** ^The [temp_store_directory pragma] may modify this variable and cause
4950: ** it to point to memory obtained from [sqlite3_malloc]. ^Furthermore,
4951: ** the [temp_store_directory pragma] always assumes that any string
4952: ** that this variable points to is held in memory obtained from
4953: ** [sqlite3_malloc] and the pragma may attempt to free that memory
4954: ** using [sqlite3_free].
4955: ** Hence, if this variable is modified directly, either it should be
4956: ** made NULL or made to point to memory obtained from [sqlite3_malloc]
4957: ** or else the use of the [temp_store_directory pragma] should be avoided.
4958: */
4959: SQLITE_API char *sqlite3_temp_directory;
4960:
4961: /*
4962: ** CAPI3REF: Test For Auto-Commit Mode
4963: ** KEYWORDS: {autocommit mode}
4964: **
4965: ** ^The sqlite3_get_autocommit() interface returns non-zero or
4966: ** zero if the given database connection is or is not in autocommit mode,
4967: ** respectively. ^Autocommit mode is on by default.
4968: ** ^Autocommit mode is disabled by a [BEGIN] statement.
4969: ** ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
4970: **
4971: ** If certain kinds of errors occur on a statement within a multi-statement
4972: ** transaction (errors including [SQLITE_FULL], [SQLITE_IOERR],
4973: ** [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
4974: ** transaction might be rolled back automatically. The only way to
4975: ** find out whether SQLite automatically rolled back the transaction after
4976: ** an error is to use this function.
4977: **
4978: ** If another thread changes the autocommit status of the database
4979: ** connection while this routine is running, then the return value
4980: ** is undefined.
4981: */
4982: SQLITE_API int sqlite3_get_autocommit(sqlite3*);
4983:
4984: /*
4985: ** CAPI3REF: Find The Database Handle Of A Prepared Statement
4986: **
4987: ** ^The sqlite3_db_handle interface returns the [database connection] handle
4988: ** to which a [prepared statement] belongs. ^The [database connection]
4989: ** returned by sqlite3_db_handle is the same [database connection]
4990: ** that was the first argument
4991: ** to the [sqlite3_prepare_v2()] call (or its variants) that was used to
4992: ** create the statement in the first place.
4993: */
4994: SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
4995:
4996: /*
4997: ** CAPI3REF: Return The Filename For A Database Connection
4998: **
4999: ** ^The sqlite3_db_filename(D,N) interface returns a pointer to a filename
5000: ** associated with database N of connection D. ^The main database file
5001: ** has the name "main". If there is no attached database N on the database
5002: ** connection D, or if database N is a temporary or in-memory database, then
5003: ** a NULL pointer is returned.
5004: **
5005: ** ^The filename returned by this function is the output of the
5006: ** xFullPathname method of the [VFS]. ^In other words, the filename
5007: ** will be an absolute pathname, even if the filename used
5008: ** to open the database originally was a URI or relative pathname.
5009: */
5010: SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);
5011:
5012: /*
5013: ** CAPI3REF: Find the next prepared statement
5014: **
5015: ** ^This interface returns a pointer to the next [prepared statement] after
5016: ** pStmt associated with the [database connection] pDb. ^If pStmt is NULL
5017: ** then this interface returns a pointer to the first prepared statement
5018: ** associated with the database connection pDb. ^If no prepared statement
5019: ** satisfies the conditions of this routine, it returns NULL.
5020: **
5021: ** The [database connection] pointer D in a call to
5022: ** [sqlite3_next_stmt(D,S)] must refer to an open database
5023: ** connection and in particular must not be a NULL pointer.
5024: */
5025: SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
5026:
5027: /*
5028: ** CAPI3REF: Commit And Rollback Notification Callbacks
5029: **
5030: ** ^The sqlite3_commit_hook() interface registers a callback
5031: ** function to be invoked whenever a transaction is [COMMIT | committed].
5032: ** ^Any callback set by a previous call to sqlite3_commit_hook()
5033: ** for the same database connection is overridden.
5034: ** ^The sqlite3_rollback_hook() interface registers a callback
5035: ** function to be invoked whenever a transaction is [ROLLBACK | rolled back].
5036: ** ^Any callback set by a previous call to sqlite3_rollback_hook()
5037: ** for the same database connection is overridden.
5038: ** ^The pArg argument is passed through to the callback.
5039: ** ^If the callback on a commit hook function returns non-zero,
5040: ** then the commit is converted into a rollback.
5041: **
5042: ** ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions
5043: ** return the P argument from the previous call of the same function
5044: ** on the same [database connection] D, or NULL for
5045: ** the first call for each function on D.
5046: **
5047: ** The commit and rollback hook callbacks are not reentrant.
5048: ** The callback implementation must not do anything that will modify
5049: ** the database connection that invoked the callback. Any actions
5050: ** to modify the database connection must be deferred until after the
5051: ** completion of the [sqlite3_step()] call that triggered the commit
5052: ** or rollback hook in the first place.
5053: ** Note that running any other SQL statements, including SELECT statements,
5054: ** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify
5055: ** the database connections for the meaning of "modify" in this paragraph.
5056: **
5057: ** ^Registering a NULL function disables the callback.
5058: **
5059: ** ^When the commit hook callback routine returns zero, the [COMMIT]
5060: ** operation is allowed to continue normally. ^If the commit hook
5061: ** returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
5062: ** ^The rollback hook is invoked on a rollback that results from a commit
5063: ** hook returning non-zero, just as it would be with any other rollback.
5064: **
5065: ** ^For the purposes of this API, a transaction is said to have been
5066: ** rolled back if an explicit "ROLLBACK" statement is executed, or
5067: ** an error or constraint causes an implicit rollback to occur.
5068: ** ^The rollback callback is not invoked if a transaction is
5069: ** automatically rolled back because the database connection is closed.
5070: **
5071: ** See also the [sqlite3_update_hook()] interface.
5072: */
5073: SQLITE_API void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
5074: SQLITE_API void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
5075:
5076: /*
5077: ** CAPI3REF: Data Change Notification Callbacks
5078: **
5079: ** ^The sqlite3_update_hook() interface registers a callback function
5080: ** with the [database connection] identified by the first argument
5081: ** to be invoked whenever a row is updated, inserted or deleted.
5082: ** ^Any callback set by a previous call to this function
5083: ** for the same database connection is overridden.
5084: **
5085: ** ^The second argument is a pointer to the function to invoke when a
5086: ** row is updated, inserted or deleted.
5087: ** ^The first argument to the callback is a copy of the third argument
5088: ** to sqlite3_update_hook().
5089: ** ^The second callback argument is one of [SQLITE_INSERT], [SQLITE_DELETE],
5090: ** or [SQLITE_UPDATE], depending on the operation that caused the callback
5091: ** to be invoked.
5092: ** ^The third and fourth arguments to the callback contain pointers to the
5093: ** database and table name containing the affected row.
5094: ** ^The final callback parameter is the [rowid] of the row.
5095: ** ^In the case of an update, this is the [rowid] after the update takes place.
5096: **
5097: ** ^(The update hook is not invoked when internal system tables are
5098: ** modified (i.e. sqlite_master and sqlite_sequence).)^
5099: **
5100: ** ^In the current implementation, the update hook
5101: ** is not invoked when duplication rows are deleted because of an
5102: ** [ON CONFLICT | ON CONFLICT REPLACE] clause. ^Nor is the update hook
5103: ** invoked when rows are deleted using the [truncate optimization].
5104: ** The exceptions defined in this paragraph might change in a future
5105: ** release of SQLite.
5106: **
5107: ** The update hook implementation must not do anything that will modify
5108: ** the database connection that invoked the update hook. Any actions
5109: ** to modify the database connection must be deferred until after the
5110: ** completion of the [sqlite3_step()] call that triggered the update hook.
5111: ** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
5112: ** database connections for the meaning of "modify" in this paragraph.
5113: **
5114: ** ^The sqlite3_update_hook(D,C,P) function
5115: ** returns the P argument from the previous call
5116: ** on the same [database connection] D, or NULL for
5117: ** the first call on D.
5118: **
5119: ** See also the [sqlite3_commit_hook()] and [sqlite3_rollback_hook()]
5120: ** interfaces.
5121: */
5122: SQLITE_API void *sqlite3_update_hook(
5123: sqlite3*,
5124: void(*)(void *,int ,char const *,char const *,sqlite3_int64),
5125: void*
5126: );
5127:
5128: /*
5129: ** CAPI3REF: Enable Or Disable Shared Pager Cache
5130: ** KEYWORDS: {shared cache}
5131: **
5132: ** ^(This routine enables or disables the sharing of the database cache
5133: ** and schema data structures between [database connection | connections]
5134: ** to the same database. Sharing is enabled if the argument is true
5135: ** and disabled if the argument is false.)^
5136: **
5137: ** ^Cache sharing is enabled and disabled for an entire process.
5138: ** This is a change as of SQLite version 3.5.0. In prior versions of SQLite,
5139: ** sharing was enabled or disabled for each thread separately.
5140: **
5141: ** ^(The cache sharing mode set by this interface effects all subsequent
5142: ** calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()].
5143: ** Existing database connections continue use the sharing mode
5144: ** that was in effect at the time they were opened.)^
5145: **
5146: ** ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
5147: ** successfully. An [error code] is returned otherwise.)^
5148: **
5149: ** ^Shared cache is disabled by default. But this might change in
5150: ** future releases of SQLite. Applications that care about shared
5151: ** cache setting should set it explicitly.
5152: **
5153: ** See Also: [SQLite Shared-Cache Mode]
5154: */
5155: SQLITE_API int sqlite3_enable_shared_cache(int);
5156:
5157: /*
5158: ** CAPI3REF: Attempt To Free Heap Memory
5159: **
5160: ** ^The sqlite3_release_memory() interface attempts to free N bytes
5161: ** of heap memory by deallocating non-essential memory allocations
5162: ** held by the database library. Memory used to cache database
5163: ** pages to improve performance is an example of non-essential memory.
5164: ** ^sqlite3_release_memory() returns the number of bytes actually freed,
5165: ** which might be more or less than the amount requested.
5166: ** ^The sqlite3_release_memory() routine is a no-op returning zero
5167: ** if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT].
5168: **
5169: ** See also: [sqlite3_db_release_memory()]
5170: */
5171: SQLITE_API int sqlite3_release_memory(int);
5172:
5173: /*
5174: ** CAPI3REF: Free Memory Used By A Database Connection
5175: **
5176: ** ^The sqlite3_db_release_memory(D) interface attempts to free as much heap
5177: ** memory as possible from database connection D. Unlike the
5178: ** [sqlite3_release_memory()] interface, this interface is effect even
5179: ** when then [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
5180: ** omitted.
5181: **
5182: ** See also: [sqlite3_release_memory()]
5183: */
5184: SQLITE_API int sqlite3_db_release_memory(sqlite3*);
5185:
5186: /*
5187: ** CAPI3REF: Impose A Limit On Heap Size
5188: **
5189: ** ^The sqlite3_soft_heap_limit64() interface sets and/or queries the
5190: ** soft limit on the amount of heap memory that may be allocated by SQLite.
5191: ** ^SQLite strives to keep heap memory utilization below the soft heap
5192: ** limit by reducing the number of pages held in the page cache
5193: ** as heap memory usages approaches the limit.
5194: ** ^The soft heap limit is "soft" because even though SQLite strives to stay
5195: ** below the limit, it will exceed the limit rather than generate
5196: ** an [SQLITE_NOMEM] error. In other words, the soft heap limit
5197: ** is advisory only.
5198: **
5199: ** ^The return value from sqlite3_soft_heap_limit64() is the size of
5200: ** the soft heap limit prior to the call, or negative in the case of an
5201: ** error. ^If the argument N is negative
5202: ** then no change is made to the soft heap limit. Hence, the current
5203: ** size of the soft heap limit can be determined by invoking
5204: ** sqlite3_soft_heap_limit64() with a negative argument.
5205: **
5206: ** ^If the argument N is zero then the soft heap limit is disabled.
5207: **
5208: ** ^(The soft heap limit is not enforced in the current implementation
5209: ** if one or more of following conditions are true:
5210: **
5211: ** <ul>
5212: ** <li> The soft heap limit is set to zero.
5213: ** <li> Memory accounting is disabled using a combination of the
5214: ** [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and
5215: ** the [SQLITE_DEFAULT_MEMSTATUS] compile-time option.
5216: ** <li> An alternative page cache implementation is specified using
5217: ** [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...).
5218: ** <li> The page cache allocates from its own memory pool supplied
5219: ** by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than
5220: ** from the heap.
5221: ** </ul>)^
5222: **
5223: ** Beginning with SQLite version 3.7.3, the soft heap limit is enforced
5224: ** regardless of whether or not the [SQLITE_ENABLE_MEMORY_MANAGEMENT]
5225: ** compile-time option is invoked. With [SQLITE_ENABLE_MEMORY_MANAGEMENT],
5226: ** the soft heap limit is enforced on every memory allocation. Without
5227: ** [SQLITE_ENABLE_MEMORY_MANAGEMENT], the soft heap limit is only enforced
5228: ** when memory is allocated by the page cache. Testing suggests that because
5229: ** the page cache is the predominate memory user in SQLite, most
5230: ** applications will achieve adequate soft heap limit enforcement without
5231: ** the use of [SQLITE_ENABLE_MEMORY_MANAGEMENT].
5232: **
5233: ** The circumstances under which SQLite will enforce the soft heap limit may
5234: ** changes in future releases of SQLite.
5235: */
5236: SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);
5237:
5238: /*
5239: ** CAPI3REF: Deprecated Soft Heap Limit Interface
5240: ** DEPRECATED
5241: **
5242: ** This is a deprecated version of the [sqlite3_soft_heap_limit64()]
5243: ** interface. This routine is provided for historical compatibility
5244: ** only. All new applications should use the
5245: ** [sqlite3_soft_heap_limit64()] interface rather than this one.
5246: */
5247: SQLITE_API SQLITE_DEPRECATED void sqlite3_soft_heap_limit(int N);
5248:
5249:
5250: /*
5251: ** CAPI3REF: Extract Metadata About A Column Of A Table
5252: **
5253: ** ^This routine returns metadata about a specific column of a specific
5254: ** database table accessible using the [database connection] handle
5255: ** passed as the first function argument.
5256: **
5257: ** ^The column is identified by the second, third and fourth parameters to
5258: ** this function. ^The second parameter is either the name of the database
5259: ** (i.e. "main", "temp", or an attached database) containing the specified
5260: ** table or NULL. ^If it is NULL, then all attached databases are searched
5261: ** for the table using the same algorithm used by the database engine to
5262: ** resolve unqualified table references.
5263: **
5264: ** ^The third and fourth parameters to this function are the table and column
5265: ** name of the desired column, respectively. Neither of these parameters
5266: ** may be NULL.
5267: **
5268: ** ^Metadata is returned by writing to the memory locations passed as the 5th
5269: ** and subsequent parameters to this function. ^Any of these arguments may be
5270: ** NULL, in which case the corresponding element of metadata is omitted.
5271: **
5272: ** ^(<blockquote>
5273: ** <table border="1">
5274: ** <tr><th> Parameter <th> Output<br>Type <th> Description
5275: **
5276: ** <tr><td> 5th <td> const char* <td> Data type
5277: ** <tr><td> 6th <td> const char* <td> Name of default collation sequence
5278: ** <tr><td> 7th <td> int <td> True if column has a NOT NULL constraint
5279: ** <tr><td> 8th <td> int <td> True if column is part of the PRIMARY KEY
5280: ** <tr><td> 9th <td> int <td> True if column is [AUTOINCREMENT]
5281: ** </table>
5282: ** </blockquote>)^
5283: **
5284: ** ^The memory pointed to by the character pointers returned for the
5285: ** declaration type and collation sequence is valid only until the next
5286: ** call to any SQLite API function.
5287: **
5288: ** ^If the specified table is actually a view, an [error code] is returned.
5289: **
5290: ** ^If the specified column is "rowid", "oid" or "_rowid_" and an
5291: ** [INTEGER PRIMARY KEY] column has been explicitly declared, then the output
5292: ** parameters are set for the explicitly declared column. ^(If there is no
5293: ** explicitly declared [INTEGER PRIMARY KEY] column, then the output
5294: ** parameters are set as follows:
5295: **
5296: ** <pre>
5297: ** data type: "INTEGER"
5298: ** collation sequence: "BINARY"
5299: ** not null: 0
5300: ** primary key: 1
5301: ** auto increment: 0
5302: ** </pre>)^
5303: **
5304: ** ^(This function may load one or more schemas from database files. If an
5305: ** error occurs during this process, or if the requested table or column
5306: ** cannot be found, an [error code] is returned and an error message left
5307: ** in the [database connection] (to be retrieved using sqlite3_errmsg()).)^
5308: **
5309: ** ^This API is only available if the library was compiled with the
5310: ** [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol defined.
5311: */
5312: SQLITE_API int sqlite3_table_column_metadata(
5313: sqlite3 *db, /* Connection handle */
5314: const char *zDbName, /* Database name or NULL */
5315: const char *zTableName, /* Table name */
5316: const char *zColumnName, /* Column name */
5317: char const **pzDataType, /* OUTPUT: Declared data type */
5318: char const **pzCollSeq, /* OUTPUT: Collation sequence name */
5319: int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
5320: int *pPrimaryKey, /* OUTPUT: True if column part of PK */
5321: int *pAutoinc /* OUTPUT: True if column is auto-increment */
5322: );
5323:
5324: /*
5325: ** CAPI3REF: Load An Extension
5326: **
5327: ** ^This interface loads an SQLite extension library from the named file.
5328: **
5329: ** ^The sqlite3_load_extension() interface attempts to load an
5330: ** SQLite extension library contained in the file zFile.
5331: **
5332: ** ^The entry point is zProc.
5333: ** ^zProc may be 0, in which case the name of the entry point
5334: ** defaults to "sqlite3_extension_init".
5335: ** ^The sqlite3_load_extension() interface returns
5336: ** [SQLITE_OK] on success and [SQLITE_ERROR] if something goes wrong.
5337: ** ^If an error occurs and pzErrMsg is not 0, then the
5338: ** [sqlite3_load_extension()] interface shall attempt to
5339: ** fill *pzErrMsg with error message text stored in memory
5340: ** obtained from [sqlite3_malloc()]. The calling function
5341: ** should free this memory by calling [sqlite3_free()].
5342: **
5343: ** ^Extension loading must be enabled using
5344: ** [sqlite3_enable_load_extension()] prior to calling this API,
5345: ** otherwise an error will be returned.
5346: **
5347: ** See also the [load_extension() SQL function].
5348: */
5349: SQLITE_API int sqlite3_load_extension(
5350: sqlite3 *db, /* Load the extension into this database connection */
5351: const char *zFile, /* Name of the shared library containing extension */
5352: const char *zProc, /* Entry point. Derived from zFile if 0 */
5353: char **pzErrMsg /* Put error message here if not 0 */
5354: );
5355:
5356: /*
5357: ** CAPI3REF: Enable Or Disable Extension Loading
5358: **
5359: ** ^So as not to open security holes in older applications that are
5360: ** unprepared to deal with extension loading, and as a means of disabling
5361: ** extension loading while evaluating user-entered SQL, the following API
5362: ** is provided to turn the [sqlite3_load_extension()] mechanism on and off.
5363: **
5364: ** ^Extension loading is off by default. See ticket #1863.
5365: ** ^Call the sqlite3_enable_load_extension() routine with onoff==1
5366: ** to turn extension loading on and call it with onoff==0 to turn
5367: ** it back off again.
5368: */
5369: SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff);
5370:
5371: /*
5372: ** CAPI3REF: Automatically Load Statically Linked Extensions
5373: **
5374: ** ^This interface causes the xEntryPoint() function to be invoked for
5375: ** each new [database connection] that is created. The idea here is that
5376: ** xEntryPoint() is the entry point for a statically linked SQLite extension
5377: ** that is to be automatically loaded into all new database connections.
5378: **
5379: ** ^(Even though the function prototype shows that xEntryPoint() takes
5380: ** no arguments and returns void, SQLite invokes xEntryPoint() with three
5381: ** arguments and expects and integer result as if the signature of the
5382: ** entry point where as follows:
5383: **
5384: ** <blockquote><pre>
5385: ** int xEntryPoint(
5386: ** sqlite3 *db,
5387: ** const char **pzErrMsg,
5388: ** const struct sqlite3_api_routines *pThunk
5389: ** );
5390: ** </pre></blockquote>)^
5391: **
5392: ** If the xEntryPoint routine encounters an error, it should make *pzErrMsg
5393: ** point to an appropriate error message (obtained from [sqlite3_mprintf()])
5394: ** and return an appropriate [error code]. ^SQLite ensures that *pzErrMsg
5395: ** is NULL before calling the xEntryPoint(). ^SQLite will invoke
5396: ** [sqlite3_free()] on *pzErrMsg after xEntryPoint() returns. ^If any
5397: ** xEntryPoint() returns an error, the [sqlite3_open()], [sqlite3_open16()],
5398: ** or [sqlite3_open_v2()] call that provoked the xEntryPoint() will fail.
5399: **
5400: ** ^Calling sqlite3_auto_extension(X) with an entry point X that is already
5401: ** on the list of automatic extensions is a harmless no-op. ^No entry point
5402: ** will be called more than once for each database connection that is opened.
5403: **
5404: ** See also: [sqlite3_reset_auto_extension()].
5405: */
5406: SQLITE_API int sqlite3_auto_extension(void (*xEntryPoint)(void));
5407:
5408: /*
5409: ** CAPI3REF: Reset Automatic Extension Loading
5410: **
5411: ** ^This interface disables all automatic extensions previously
5412: ** registered using [sqlite3_auto_extension()].
5413: */
5414: SQLITE_API void sqlite3_reset_auto_extension(void);
5415:
5416: /*
5417: ** The interface to the virtual-table mechanism is currently considered
5418: ** to be experimental. The interface might change in incompatible ways.
5419: ** If this is a problem for you, do not use the interface at this time.
5420: **
5421: ** When the virtual-table mechanism stabilizes, we will declare the
5422: ** interface fixed, support it indefinitely, and remove this comment.
5423: */
5424:
5425: /*
5426: ** Structures used by the virtual table interface
5427: */
5428: typedef struct sqlite3_vtab sqlite3_vtab;
5429: typedef struct sqlite3_index_info sqlite3_index_info;
5430: typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor;
5431: typedef struct sqlite3_module sqlite3_module;
5432:
5433: /*
5434: ** CAPI3REF: Virtual Table Object
5435: ** KEYWORDS: sqlite3_module {virtual table module}
5436: **
5437: ** This structure, sometimes called a "virtual table module",
5438: ** defines the implementation of a [virtual tables].
5439: ** This structure consists mostly of methods for the module.
5440: **
5441: ** ^A virtual table module is created by filling in a persistent
5442: ** instance of this structure and passing a pointer to that instance
5443: ** to [sqlite3_create_module()] or [sqlite3_create_module_v2()].
5444: ** ^The registration remains valid until it is replaced by a different
5445: ** module or until the [database connection] closes. The content
5446: ** of this structure must not change while it is registered with
5447: ** any database connection.
5448: */
5449: struct sqlite3_module {
5450: int iVersion;
5451: int (*xCreate)(sqlite3*, void *pAux,
5452: int argc, const char *const*argv,
5453: sqlite3_vtab **ppVTab, char**);
5454: int (*xConnect)(sqlite3*, void *pAux,
5455: int argc, const char *const*argv,
5456: sqlite3_vtab **ppVTab, char**);
5457: int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*);
5458: int (*xDisconnect)(sqlite3_vtab *pVTab);
5459: int (*xDestroy)(sqlite3_vtab *pVTab);
5460: int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
5461: int (*xClose)(sqlite3_vtab_cursor*);
5462: int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr,
5463: int argc, sqlite3_value **argv);
5464: int (*xNext)(sqlite3_vtab_cursor*);
5465: int (*xEof)(sqlite3_vtab_cursor*);
5466: int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int);
5467: int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid);
5468: int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *);
5469: int (*xBegin)(sqlite3_vtab *pVTab);
5470: int (*xSync)(sqlite3_vtab *pVTab);
5471: int (*xCommit)(sqlite3_vtab *pVTab);
5472: int (*xRollback)(sqlite3_vtab *pVTab);
5473: int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
5474: void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
5475: void **ppArg);
5476: int (*xRename)(sqlite3_vtab *pVtab, const char *zNew);
5477: /* The methods above are in version 1 of the sqlite_module object. Those
5478: ** below are for version 2 and greater. */
5479: int (*xSavepoint)(sqlite3_vtab *pVTab, int);
5480: int (*xRelease)(sqlite3_vtab *pVTab, int);
5481: int (*xRollbackTo)(sqlite3_vtab *pVTab, int);
5482: };
5483:
5484: /*
5485: ** CAPI3REF: Virtual Table Indexing Information
5486: ** KEYWORDS: sqlite3_index_info
5487: **
5488: ** The sqlite3_index_info structure and its substructures is used as part
5489: ** of the [virtual table] interface to
5490: ** pass information into and receive the reply from the [xBestIndex]
5491: ** method of a [virtual table module]. The fields under **Inputs** are the
5492: ** inputs to xBestIndex and are read-only. xBestIndex inserts its
5493: ** results into the **Outputs** fields.
5494: **
5495: ** ^(The aConstraint[] array records WHERE clause constraints of the form:
5496: **
5497: ** <blockquote>column OP expr</blockquote>
5498: **
5499: ** where OP is =, <, <=, >, or >=.)^ ^(The particular operator is
5500: ** stored in aConstraint[].op using one of the
5501: ** [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^
5502: ** ^(The index of the column is stored in
5503: ** aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the
5504: ** expr on the right-hand side can be evaluated (and thus the constraint
5505: ** is usable) and false if it cannot.)^
5506: **
5507: ** ^The optimizer automatically inverts terms of the form "expr OP column"
5508: ** and makes other simplifications to the WHERE clause in an attempt to
5509: ** get as many WHERE clause terms into the form shown above as possible.
5510: ** ^The aConstraint[] array only reports WHERE clause terms that are
5511: ** relevant to the particular virtual table being queried.
5512: **
5513: ** ^Information about the ORDER BY clause is stored in aOrderBy[].
5514: ** ^Each term of aOrderBy records a column of the ORDER BY clause.
5515: **
5516: ** The [xBestIndex] method must fill aConstraintUsage[] with information
5517: ** about what parameters to pass to xFilter. ^If argvIndex>0 then
5518: ** the right-hand side of the corresponding aConstraint[] is evaluated
5519: ** and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit
5520: ** is true, then the constraint is assumed to be fully handled by the
5521: ** virtual table and is not checked again by SQLite.)^
5522: **
5523: ** ^The idxNum and idxPtr values are recorded and passed into the
5524: ** [xFilter] method.
5525: ** ^[sqlite3_free()] is used to free idxPtr if and only if
5526: ** needToFreeIdxPtr is true.
5527: **
5528: ** ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in
5529: ** the correct order to satisfy the ORDER BY clause so that no separate
5530: ** sorting step is required.
5531: **
5532: ** ^The estimatedCost value is an estimate of the cost of doing the
5533: ** particular lookup. A full scan of a table with N entries should have
5534: ** a cost of N. A binary search of a table of N entries should have a
5535: ** cost of approximately log(N).
5536: */
5537: struct sqlite3_index_info {
5538: /* Inputs */
5539: int nConstraint; /* Number of entries in aConstraint */
5540: struct sqlite3_index_constraint {
5541: int iColumn; /* Column on left-hand side of constraint */
5542: unsigned char op; /* Constraint operator */
5543: unsigned char usable; /* True if this constraint is usable */
5544: int iTermOffset; /* Used internally - xBestIndex should ignore */
5545: } *aConstraint; /* Table of WHERE clause constraints */
5546: int nOrderBy; /* Number of terms in the ORDER BY clause */
5547: struct sqlite3_index_orderby {
5548: int iColumn; /* Column number */
5549: unsigned char desc; /* True for DESC. False for ASC. */
5550: } *aOrderBy; /* The ORDER BY clause */
5551: /* Outputs */
5552: struct sqlite3_index_constraint_usage {
5553: int argvIndex; /* if >0, constraint is part of argv to xFilter */
5554: unsigned char omit; /* Do not code a test for this constraint */
5555: } *aConstraintUsage;
5556: int idxNum; /* Number used to identify the index */
5557: char *idxStr; /* String, possibly obtained from sqlite3_malloc */
5558: int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */
5559: int orderByConsumed; /* True if output is already ordered */
5560: double estimatedCost; /* Estimated cost of using this index */
5561: };
5562:
5563: /*
5564: ** CAPI3REF: Virtual Table Constraint Operator Codes
5565: **
5566: ** These macros defined the allowed values for the
5567: ** [sqlite3_index_info].aConstraint[].op field. Each value represents
5568: ** an operator that is part of a constraint term in the wHERE clause of
5569: ** a query that uses a [virtual table].
5570: */
5571: #define SQLITE_INDEX_CONSTRAINT_EQ 2
5572: #define SQLITE_INDEX_CONSTRAINT_GT 4
5573: #define SQLITE_INDEX_CONSTRAINT_LE 8
5574: #define SQLITE_INDEX_CONSTRAINT_LT 16
5575: #define SQLITE_INDEX_CONSTRAINT_GE 32
5576: #define SQLITE_INDEX_CONSTRAINT_MATCH 64
5577:
5578: /*
5579: ** CAPI3REF: Register A Virtual Table Implementation
5580: **
5581: ** ^These routines are used to register a new [virtual table module] name.
5582: ** ^Module names must be registered before
5583: ** creating a new [virtual table] using the module and before using a
5584: ** preexisting [virtual table] for the module.
5585: **
5586: ** ^The module name is registered on the [database connection] specified
5587: ** by the first parameter. ^The name of the module is given by the
5588: ** second parameter. ^The third parameter is a pointer to
5589: ** the implementation of the [virtual table module]. ^The fourth
5590: ** parameter is an arbitrary client data pointer that is passed through
5591: ** into the [xCreate] and [xConnect] methods of the virtual table module
5592: ** when a new virtual table is be being created or reinitialized.
5593: **
5594: ** ^The sqlite3_create_module_v2() interface has a fifth parameter which
5595: ** is a pointer to a destructor for the pClientData. ^SQLite will
5596: ** invoke the destructor function (if it is not NULL) when SQLite
5597: ** no longer needs the pClientData pointer. ^The destructor will also
5598: ** be invoked if the call to sqlite3_create_module_v2() fails.
5599: ** ^The sqlite3_create_module()
5600: ** interface is equivalent to sqlite3_create_module_v2() with a NULL
5601: ** destructor.
5602: */
5603: SQLITE_API int sqlite3_create_module(
5604: sqlite3 *db, /* SQLite connection to register module with */
5605: const char *zName, /* Name of the module */
5606: const sqlite3_module *p, /* Methods for the module */
5607: void *pClientData /* Client data for xCreate/xConnect */
5608: );
5609: SQLITE_API int sqlite3_create_module_v2(
5610: sqlite3 *db, /* SQLite connection to register module with */
5611: const char *zName, /* Name of the module */
5612: const sqlite3_module *p, /* Methods for the module */
5613: void *pClientData, /* Client data for xCreate/xConnect */
5614: void(*xDestroy)(void*) /* Module destructor function */
5615: );
5616:
5617: /*
5618: ** CAPI3REF: Virtual Table Instance Object
5619: ** KEYWORDS: sqlite3_vtab
5620: **
5621: ** Every [virtual table module] implementation uses a subclass
5622: ** of this object to describe a particular instance
5623: ** of the [virtual table]. Each subclass will
5624: ** be tailored to the specific needs of the module implementation.
5625: ** The purpose of this superclass is to define certain fields that are
5626: ** common to all module implementations.
5627: **
5628: ** ^Virtual tables methods can set an error message by assigning a
5629: ** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should
5630: ** take care that any prior string is freed by a call to [sqlite3_free()]
5631: ** prior to assigning a new string to zErrMsg. ^After the error message
5632: ** is delivered up to the client application, the string will be automatically
5633: ** freed by sqlite3_free() and the zErrMsg field will be zeroed.
5634: */
5635: struct sqlite3_vtab {
5636: const sqlite3_module *pModule; /* The module for this virtual table */
5637: int nRef; /* NO LONGER USED */
5638: char *zErrMsg; /* Error message from sqlite3_mprintf() */
5639: /* Virtual table implementations will typically add additional fields */
5640: };
5641:
5642: /*
5643: ** CAPI3REF: Virtual Table Cursor Object
5644: ** KEYWORDS: sqlite3_vtab_cursor {virtual table cursor}
5645: **
5646: ** Every [virtual table module] implementation uses a subclass of the
5647: ** following structure to describe cursors that point into the
5648: ** [virtual table] and are used
5649: ** to loop through the virtual table. Cursors are created using the
5650: ** [sqlite3_module.xOpen | xOpen] method of the module and are destroyed
5651: ** by the [sqlite3_module.xClose | xClose] method. Cursors are used
5652: ** by the [xFilter], [xNext], [xEof], [xColumn], and [xRowid] methods
5653: ** of the module. Each module implementation will define
5654: ** the content of a cursor structure to suit its own needs.
5655: **
5656: ** This superclass exists in order to define fields of the cursor that
5657: ** are common to all implementations.
5658: */
5659: struct sqlite3_vtab_cursor {
5660: sqlite3_vtab *pVtab; /* Virtual table of this cursor */
5661: /* Virtual table implementations will typically add additional fields */
5662: };
5663:
5664: /*
5665: ** CAPI3REF: Declare The Schema Of A Virtual Table
5666: **
5667: ** ^The [xCreate] and [xConnect] methods of a
5668: ** [virtual table module] call this interface
5669: ** to declare the format (the names and datatypes of the columns) of
5670: ** the virtual tables they implement.
5671: */
5672: SQLITE_API int sqlite3_declare_vtab(sqlite3*, const char *zSQL);
5673:
5674: /*
5675: ** CAPI3REF: Overload A Function For A Virtual Table
5676: **
5677: ** ^(Virtual tables can provide alternative implementations of functions
5678: ** using the [xFindFunction] method of the [virtual table module].
5679: ** But global versions of those functions
5680: ** must exist in order to be overloaded.)^
5681: **
5682: ** ^(This API makes sure a global version of a function with a particular
5683: ** name and number of parameters exists. If no such function exists
5684: ** before this API is called, a new function is created.)^ ^The implementation
5685: ** of the new function always causes an exception to be thrown. So
5686: ** the new function is not good for anything by itself. Its only
5687: ** purpose is to be a placeholder function that can be overloaded
5688: ** by a [virtual table].
5689: */
5690: SQLITE_API int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);
5691:
5692: /*
5693: ** The interface to the virtual-table mechanism defined above (back up
5694: ** to a comment remarkably similar to this one) is currently considered
5695: ** to be experimental. The interface might change in incompatible ways.
5696: ** If this is a problem for you, do not use the interface at this time.
5697: **
5698: ** When the virtual-table mechanism stabilizes, we will declare the
5699: ** interface fixed, support it indefinitely, and remove this comment.
5700: */
5701:
5702: /*
5703: ** CAPI3REF: A Handle To An Open BLOB
5704: ** KEYWORDS: {BLOB handle} {BLOB handles}
5705: **
5706: ** An instance of this object represents an open BLOB on which
5707: ** [sqlite3_blob_open | incremental BLOB I/O] can be performed.
5708: ** ^Objects of this type are created by [sqlite3_blob_open()]
5709: ** and destroyed by [sqlite3_blob_close()].
5710: ** ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces
5711: ** can be used to read or write small subsections of the BLOB.
5712: ** ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes.
5713: */
5714: typedef struct sqlite3_blob sqlite3_blob;
5715:
5716: /*
5717: ** CAPI3REF: Open A BLOB For Incremental I/O
5718: **
5719: ** ^(This interfaces opens a [BLOB handle | handle] to the BLOB located
5720: ** in row iRow, column zColumn, table zTable in database zDb;
5721: ** in other words, the same BLOB that would be selected by:
5722: **
5723: ** <pre>
5724: ** SELECT zColumn FROM zDb.zTable WHERE [rowid] = iRow;
5725: ** </pre>)^
5726: **
5727: ** ^If the flags parameter is non-zero, then the BLOB is opened for read
5728: ** and write access. ^If it is zero, the BLOB is opened for read access.
5729: ** ^It is not possible to open a column that is part of an index or primary
5730: ** key for writing. ^If [foreign key constraints] are enabled, it is
5731: ** not possible to open a column that is part of a [child key] for writing.
5732: **
5733: ** ^Note that the database name is not the filename that contains
5734: ** the database but rather the symbolic name of the database that
5735: ** appears after the AS keyword when the database is connected using [ATTACH].
5736: ** ^For the main database file, the database name is "main".
5737: ** ^For TEMP tables, the database name is "temp".
5738: **
5739: ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written
5740: ** to *ppBlob. Otherwise an [error code] is returned and *ppBlob is set
5741: ** to be a null pointer.)^
5742: ** ^This function sets the [database connection] error code and message
5743: ** accessible via [sqlite3_errcode()] and [sqlite3_errmsg()] and related
5744: ** functions. ^Note that the *ppBlob variable is always initialized in a
5745: ** way that makes it safe to invoke [sqlite3_blob_close()] on *ppBlob
5746: ** regardless of the success or failure of this routine.
5747: **
5748: ** ^(If the row that a BLOB handle points to is modified by an
5749: ** [UPDATE], [DELETE], or by [ON CONFLICT] side-effects
5750: ** then the BLOB handle is marked as "expired".
5751: ** This is true if any column of the row is changed, even a column
5752: ** other than the one the BLOB handle is open on.)^
5753: ** ^Calls to [sqlite3_blob_read()] and [sqlite3_blob_write()] for
5754: ** an expired BLOB handle fail with a return code of [SQLITE_ABORT].
5755: ** ^(Changes written into a BLOB prior to the BLOB expiring are not
5756: ** rolled back by the expiration of the BLOB. Such changes will eventually
5757: ** commit if the transaction continues to completion.)^
5758: **
5759: ** ^Use the [sqlite3_blob_bytes()] interface to determine the size of
5760: ** the opened blob. ^The size of a blob may not be changed by this
5761: ** interface. Use the [UPDATE] SQL command to change the size of a
5762: ** blob.
5763: **
5764: ** ^The [sqlite3_bind_zeroblob()] and [sqlite3_result_zeroblob()] interfaces
5765: ** and the built-in [zeroblob] SQL function can be used, if desired,
5766: ** to create an empty, zero-filled blob in which to read or write using
5767: ** this interface.
5768: **
5769: ** To avoid a resource leak, every open [BLOB handle] should eventually
5770: ** be released by a call to [sqlite3_blob_close()].
5771: */
5772: SQLITE_API int sqlite3_blob_open(
5773: sqlite3*,
5774: const char *zDb,
5775: const char *zTable,
5776: const char *zColumn,
5777: sqlite3_int64 iRow,
5778: int flags,
5779: sqlite3_blob **ppBlob
5780: );
5781:
5782: /*
5783: ** CAPI3REF: Move a BLOB Handle to a New Row
5784: **
5785: ** ^This function is used to move an existing blob handle so that it points
5786: ** to a different row of the same database table. ^The new row is identified
5787: ** by the rowid value passed as the second argument. Only the row can be
5788: ** changed. ^The database, table and column on which the blob handle is open
5789: ** remain the same. Moving an existing blob handle to a new row can be
5790: ** faster than closing the existing handle and opening a new one.
5791: **
5792: ** ^(The new row must meet the same criteria as for [sqlite3_blob_open()] -
5793: ** it must exist and there must be either a blob or text value stored in
5794: ** the nominated column.)^ ^If the new row is not present in the table, or if
5795: ** it does not contain a blob or text value, or if another error occurs, an
5796: ** SQLite error code is returned and the blob handle is considered aborted.
5797: ** ^All subsequent calls to [sqlite3_blob_read()], [sqlite3_blob_write()] or
5798: ** [sqlite3_blob_reopen()] on an aborted blob handle immediately return
5799: ** SQLITE_ABORT. ^Calling [sqlite3_blob_bytes()] on an aborted blob handle
5800: ** always returns zero.
5801: **
5802: ** ^This function sets the database handle error code and message.
5803: */
5804: SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);
5805:
5806: /*
5807: ** CAPI3REF: Close A BLOB Handle
5808: **
5809: ** ^Closes an open [BLOB handle].
5810: **
5811: ** ^Closing a BLOB shall cause the current transaction to commit
5812: ** if there are no other BLOBs, no pending prepared statements, and the
5813: ** database connection is in [autocommit mode].
5814: ** ^If any writes were made to the BLOB, they might be held in cache
5815: ** until the close operation if they will fit.
5816: **
5817: ** ^(Closing the BLOB often forces the changes
5818: ** out to disk and so if any I/O errors occur, they will likely occur
5819: ** at the time when the BLOB is closed. Any errors that occur during
5820: ** closing are reported as a non-zero return value.)^
5821: **
5822: ** ^(The BLOB is closed unconditionally. Even if this routine returns
5823: ** an error code, the BLOB is still closed.)^
5824: **
5825: ** ^Calling this routine with a null pointer (such as would be returned
5826: ** by a failed call to [sqlite3_blob_open()]) is a harmless no-op.
5827: */
5828: SQLITE_API int sqlite3_blob_close(sqlite3_blob *);
5829:
5830: /*
5831: ** CAPI3REF: Return The Size Of An Open BLOB
5832: **
5833: ** ^Returns the size in bytes of the BLOB accessible via the
5834: ** successfully opened [BLOB handle] in its only argument. ^The
5835: ** incremental blob I/O routines can only read or overwriting existing
5836: ** blob content; they cannot change the size of a blob.
5837: **
5838: ** This routine only works on a [BLOB handle] which has been created
5839: ** by a prior successful call to [sqlite3_blob_open()] and which has not
5840: ** been closed by [sqlite3_blob_close()]. Passing any other pointer in
5841: ** to this routine results in undefined and probably undesirable behavior.
5842: */
5843: SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *);
5844:
5845: /*
5846: ** CAPI3REF: Read Data From A BLOB Incrementally
5847: **
5848: ** ^(This function is used to read data from an open [BLOB handle] into a
5849: ** caller-supplied buffer. N bytes of data are copied into buffer Z
5850: ** from the open BLOB, starting at offset iOffset.)^
5851: **
5852: ** ^If offset iOffset is less than N bytes from the end of the BLOB,
5853: ** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is
5854: ** less than zero, [SQLITE_ERROR] is returned and no data is read.
5855: ** ^The size of the blob (and hence the maximum value of N+iOffset)
5856: ** can be determined using the [sqlite3_blob_bytes()] interface.
5857: **
5858: ** ^An attempt to read from an expired [BLOB handle] fails with an
5859: ** error code of [SQLITE_ABORT].
5860: **
5861: ** ^(On success, sqlite3_blob_read() returns SQLITE_OK.
5862: ** Otherwise, an [error code] or an [extended error code] is returned.)^
5863: **
5864: ** This routine only works on a [BLOB handle] which has been created
5865: ** by a prior successful call to [sqlite3_blob_open()] and which has not
5866: ** been closed by [sqlite3_blob_close()]. Passing any other pointer in
5867: ** to this routine results in undefined and probably undesirable behavior.
5868: **
5869: ** See also: [sqlite3_blob_write()].
5870: */
5871: SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
5872:
5873: /*
5874: ** CAPI3REF: Write Data Into A BLOB Incrementally
5875: **
5876: ** ^This function is used to write data into an open [BLOB handle] from a
5877: ** caller-supplied buffer. ^N bytes of data are copied from the buffer Z
5878: ** into the open BLOB, starting at offset iOffset.
5879: **
5880: ** ^If the [BLOB handle] passed as the first argument was not opened for
5881: ** writing (the flags parameter to [sqlite3_blob_open()] was zero),
5882: ** this function returns [SQLITE_READONLY].
5883: **
5884: ** ^This function may only modify the contents of the BLOB; it is
5885: ** not possible to increase the size of a BLOB using this API.
5886: ** ^If offset iOffset is less than N bytes from the end of the BLOB,
5887: ** [SQLITE_ERROR] is returned and no data is written. ^If N is
5888: ** less than zero [SQLITE_ERROR] is returned and no data is written.
5889: ** The size of the BLOB (and hence the maximum value of N+iOffset)
5890: ** can be determined using the [sqlite3_blob_bytes()] interface.
5891: **
5892: ** ^An attempt to write to an expired [BLOB handle] fails with an
5893: ** error code of [SQLITE_ABORT]. ^Writes to the BLOB that occurred
5894: ** before the [BLOB handle] expired are not rolled back by the
5895: ** expiration of the handle, though of course those changes might
5896: ** have been overwritten by the statement that expired the BLOB handle
5897: ** or by other independent statements.
5898: **
5899: ** ^(On success, sqlite3_blob_write() returns SQLITE_OK.
5900: ** Otherwise, an [error code] or an [extended error code] is returned.)^
5901: **
5902: ** This routine only works on a [BLOB handle] which has been created
5903: ** by a prior successful call to [sqlite3_blob_open()] and which has not
5904: ** been closed by [sqlite3_blob_close()]. Passing any other pointer in
5905: ** to this routine results in undefined and probably undesirable behavior.
5906: **
5907: ** See also: [sqlite3_blob_read()].
5908: */
5909: SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
5910:
5911: /*
5912: ** CAPI3REF: Virtual File System Objects
5913: **
5914: ** A virtual filesystem (VFS) is an [sqlite3_vfs] object
5915: ** that SQLite uses to interact
5916: ** with the underlying operating system. Most SQLite builds come with a
5917: ** single default VFS that is appropriate for the host computer.
5918: ** New VFSes can be registered and existing VFSes can be unregistered.
5919: ** The following interfaces are provided.
5920: **
5921: ** ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name.
5922: ** ^Names are case sensitive.
5923: ** ^Names are zero-terminated UTF-8 strings.
5924: ** ^If there is no match, a NULL pointer is returned.
5925: ** ^If zVfsName is NULL then the default VFS is returned.
5926: **
5927: ** ^New VFSes are registered with sqlite3_vfs_register().
5928: ** ^Each new VFS becomes the default VFS if the makeDflt flag is set.
5929: ** ^The same VFS can be registered multiple times without injury.
5930: ** ^To make an existing VFS into the default VFS, register it again
5931: ** with the makeDflt flag set. If two different VFSes with the
5932: ** same name are registered, the behavior is undefined. If a
5933: ** VFS is registered with a name that is NULL or an empty string,
5934: ** then the behavior is undefined.
5935: **
5936: ** ^Unregister a VFS with the sqlite3_vfs_unregister() interface.
5937: ** ^(If the default VFS is unregistered, another VFS is chosen as
5938: ** the default. The choice for the new VFS is arbitrary.)^
5939: */
5940: SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
5941: SQLITE_API int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
5942: SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs*);
5943:
5944: /*
5945: ** CAPI3REF: Mutexes
5946: **
5947: ** The SQLite core uses these routines for thread
5948: ** synchronization. Though they are intended for internal
5949: ** use by SQLite, code that links against SQLite is
5950: ** permitted to use any of these routines.
5951: **
5952: ** The SQLite source code contains multiple implementations
5953: ** of these mutex routines. An appropriate implementation
5954: ** is selected automatically at compile-time. ^(The following
5955: ** implementations are available in the SQLite core:
5956: **
5957: ** <ul>
5958: ** <li> SQLITE_MUTEX_OS2
5959: ** <li> SQLITE_MUTEX_PTHREADS
5960: ** <li> SQLITE_MUTEX_W32
5961: ** <li> SQLITE_MUTEX_NOOP
5962: ** </ul>)^
5963: **
5964: ** ^The SQLITE_MUTEX_NOOP implementation is a set of routines
5965: ** that does no real locking and is appropriate for use in
5966: ** a single-threaded application. ^The SQLITE_MUTEX_OS2,
5967: ** SQLITE_MUTEX_PTHREADS, and SQLITE_MUTEX_W32 implementations
5968: ** are appropriate for use on OS/2, Unix, and Windows.
5969: **
5970: ** ^(If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
5971: ** macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
5972: ** implementation is included with the library. In this case the
5973: ** application must supply a custom mutex implementation using the
5974: ** [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function
5975: ** before calling sqlite3_initialize() or any other public sqlite3_
5976: ** function that calls sqlite3_initialize().)^
5977: **
5978: ** ^The sqlite3_mutex_alloc() routine allocates a new
5979: ** mutex and returns a pointer to it. ^If it returns NULL
5980: ** that means that a mutex could not be allocated. ^SQLite
5981: ** will unwind its stack and return an error. ^(The argument
5982: ** to sqlite3_mutex_alloc() is one of these integer constants:
5983: **
5984: ** <ul>
5985: ** <li> SQLITE_MUTEX_FAST
5986: ** <li> SQLITE_MUTEX_RECURSIVE
5987: ** <li> SQLITE_MUTEX_STATIC_MASTER
5988: ** <li> SQLITE_MUTEX_STATIC_MEM
5989: ** <li> SQLITE_MUTEX_STATIC_MEM2
5990: ** <li> SQLITE_MUTEX_STATIC_PRNG
5991: ** <li> SQLITE_MUTEX_STATIC_LRU
5992: ** <li> SQLITE_MUTEX_STATIC_LRU2
5993: ** </ul>)^
5994: **
5995: ** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE)
5996: ** cause sqlite3_mutex_alloc() to create
5997: ** a new mutex. ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
5998: ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
5999: ** The mutex implementation does not need to make a distinction
6000: ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
6001: ** not want to. ^SQLite will only request a recursive mutex in
6002: ** cases where it really needs one. ^If a faster non-recursive mutex
6003: ** implementation is available on the host platform, the mutex subsystem
6004: ** might return such a mutex in response to SQLITE_MUTEX_FAST.
6005: **
6006: ** ^The other allowed parameters to sqlite3_mutex_alloc() (anything other
6007: ** than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return
6008: ** a pointer to a static preexisting mutex. ^Six static mutexes are
6009: ** used by the current version of SQLite. Future versions of SQLite
6010: ** may add additional static mutexes. Static mutexes are for internal
6011: ** use by SQLite only. Applications that use SQLite mutexes should
6012: ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
6013: ** SQLITE_MUTEX_RECURSIVE.
6014: **
6015: ** ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
6016: ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
6017: ** returns a different mutex on every call. ^But for the static
6018: ** mutex types, the same mutex is returned on every call that has
6019: ** the same type number.
6020: **
6021: ** ^The sqlite3_mutex_free() routine deallocates a previously
6022: ** allocated dynamic mutex. ^SQLite is careful to deallocate every
6023: ** dynamic mutex that it allocates. The dynamic mutexes must not be in
6024: ** use when they are deallocated. Attempting to deallocate a static
6025: ** mutex results in undefined behavior. ^SQLite never deallocates
6026: ** a static mutex.
6027: **
6028: ** ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
6029: ** to enter a mutex. ^If another thread is already within the mutex,
6030: ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
6031: ** SQLITE_BUSY. ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
6032: ** upon successful entry. ^(Mutexes created using
6033: ** SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread.
6034: ** In such cases the,
6035: ** mutex must be exited an equal number of times before another thread
6036: ** can enter.)^ ^(If the same thread tries to enter any other
6037: ** kind of mutex more than once, the behavior is undefined.
6038: ** SQLite will never exhibit
6039: ** such behavior in its own use of mutexes.)^
6040: **
6041: ** ^(Some systems (for example, Windows 95) do not support the operation
6042: ** implemented by sqlite3_mutex_try(). On those systems, sqlite3_mutex_try()
6043: ** will always return SQLITE_BUSY. The SQLite core only ever uses
6044: ** sqlite3_mutex_try() as an optimization so this is acceptable behavior.)^
6045: **
6046: ** ^The sqlite3_mutex_leave() routine exits a mutex that was
6047: ** previously entered by the same thread. ^(The behavior
6048: ** is undefined if the mutex is not currently entered by the
6049: ** calling thread or is not currently allocated. SQLite will
6050: ** never do either.)^
6051: **
6052: ** ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or
6053: ** sqlite3_mutex_leave() is a NULL pointer, then all three routines
6054: ** behave as no-ops.
6055: **
6056: ** See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
6057: */
6058: SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int);
6059: SQLITE_API void sqlite3_mutex_free(sqlite3_mutex*);
6060: SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex*);
6061: SQLITE_API int sqlite3_mutex_try(sqlite3_mutex*);
6062: SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex*);
6063:
6064: /*
6065: ** CAPI3REF: Mutex Methods Object
6066: **
6067: ** An instance of this structure defines the low-level routines
6068: ** used to allocate and use mutexes.
6069: **
6070: ** Usually, the default mutex implementations provided by SQLite are
6071: ** sufficient, however the user has the option of substituting a custom
6072: ** implementation for specialized deployments or systems for which SQLite
6073: ** does not provide a suitable implementation. In this case, the user
6074: ** creates and populates an instance of this structure to pass
6075: ** to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option.
6076: ** Additionally, an instance of this structure can be used as an
6077: ** output variable when querying the system for the current mutex
6078: ** implementation, using the [SQLITE_CONFIG_GETMUTEX] option.
6079: **
6080: ** ^The xMutexInit method defined by this structure is invoked as
6081: ** part of system initialization by the sqlite3_initialize() function.
6082: ** ^The xMutexInit routine is called by SQLite exactly once for each
6083: ** effective call to [sqlite3_initialize()].
6084: **
6085: ** ^The xMutexEnd method defined by this structure is invoked as
6086: ** part of system shutdown by the sqlite3_shutdown() function. The
6087: ** implementation of this method is expected to release all outstanding
6088: ** resources obtained by the mutex methods implementation, especially
6089: ** those obtained by the xMutexInit method. ^The xMutexEnd()
6090: ** interface is invoked exactly once for each call to [sqlite3_shutdown()].
6091: **
6092: ** ^(The remaining seven methods defined by this structure (xMutexAlloc,
6093: ** xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and
6094: ** xMutexNotheld) implement the following interfaces (respectively):
6095: **
6096: ** <ul>
6097: ** <li> [sqlite3_mutex_alloc()] </li>
6098: ** <li> [sqlite3_mutex_free()] </li>
6099: ** <li> [sqlite3_mutex_enter()] </li>
6100: ** <li> [sqlite3_mutex_try()] </li>
6101: ** <li> [sqlite3_mutex_leave()] </li>
6102: ** <li> [sqlite3_mutex_held()] </li>
6103: ** <li> [sqlite3_mutex_notheld()] </li>
6104: ** </ul>)^
6105: **
6106: ** The only difference is that the public sqlite3_XXX functions enumerated
6107: ** above silently ignore any invocations that pass a NULL pointer instead
6108: ** of a valid mutex handle. The implementations of the methods defined
6109: ** by this structure are not required to handle this case, the results
6110: ** of passing a NULL pointer instead of a valid mutex handle are undefined
6111: ** (i.e. it is acceptable to provide an implementation that segfaults if
6112: ** it is passed a NULL pointer).
6113: **
6114: ** The xMutexInit() method must be threadsafe. ^It must be harmless to
6115: ** invoke xMutexInit() multiple times within the same process and without
6116: ** intervening calls to xMutexEnd(). Second and subsequent calls to
6117: ** xMutexInit() must be no-ops.
6118: **
6119: ** ^xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
6120: ** and its associates). ^Similarly, xMutexAlloc() must not use SQLite memory
6121: ** allocation for a static mutex. ^However xMutexAlloc() may use SQLite
6122: ** memory allocation for a fast or recursive mutex.
6123: **
6124: ** ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is
6125: ** called, but only if the prior call to xMutexInit returned SQLITE_OK.
6126: ** If xMutexInit fails in any way, it is expected to clean up after itself
6127: ** prior to returning.
6128: */
6129: typedef struct sqlite3_mutex_methods sqlite3_mutex_methods;
6130: struct sqlite3_mutex_methods {
6131: int (*xMutexInit)(void);
6132: int (*xMutexEnd)(void);
6133: sqlite3_mutex *(*xMutexAlloc)(int);
6134: void (*xMutexFree)(sqlite3_mutex *);
6135: void (*xMutexEnter)(sqlite3_mutex *);
6136: int (*xMutexTry)(sqlite3_mutex *);
6137: void (*xMutexLeave)(sqlite3_mutex *);
6138: int (*xMutexHeld)(sqlite3_mutex *);
6139: int (*xMutexNotheld)(sqlite3_mutex *);
6140: };
6141:
6142: /*
6143: ** CAPI3REF: Mutex Verification Routines
6144: **
6145: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines
6146: ** are intended for use inside assert() statements. ^The SQLite core
6147: ** never uses these routines except inside an assert() and applications
6148: ** are advised to follow the lead of the core. ^The SQLite core only
6149: ** provides implementations for these routines when it is compiled
6150: ** with the SQLITE_DEBUG flag. ^External mutex implementations
6151: ** are only required to provide these routines if SQLITE_DEBUG is
6152: ** defined and if NDEBUG is not defined.
6153: **
6154: ** ^These routines should return true if the mutex in their argument
6155: ** is held or not held, respectively, by the calling thread.
6156: **
6157: ** ^The implementation is not required to provide versions of these
6158: ** routines that actually work. If the implementation does not provide working
6159: ** versions of these routines, it should at least provide stubs that always
6160: ** return true so that one does not get spurious assertion failures.
6161: **
6162: ** ^If the argument to sqlite3_mutex_held() is a NULL pointer then
6163: ** the routine should return 1. This seems counter-intuitive since
6164: ** clearly the mutex cannot be held if it does not exist. But
6165: ** the reason the mutex does not exist is because the build is not
6166: ** using mutexes. And we do not want the assert() containing the
6167: ** call to sqlite3_mutex_held() to fail, so a non-zero return is
6168: ** the appropriate thing to do. ^The sqlite3_mutex_notheld()
6169: ** interface should also return 1 when given a NULL pointer.
6170: */
6171: #ifndef NDEBUG
6172: SQLITE_API int sqlite3_mutex_held(sqlite3_mutex*);
6173: SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex*);
6174: #endif
6175:
6176: /*
6177: ** CAPI3REF: Mutex Types
6178: **
6179: ** The [sqlite3_mutex_alloc()] interface takes a single argument
6180: ** which is one of these integer constants.
6181: **
6182: ** The set of static mutexes may change from one SQLite release to the
6183: ** next. Applications that override the built-in mutex logic must be
6184: ** prepared to accommodate additional static mutexes.
6185: */
6186: #define SQLITE_MUTEX_FAST 0
6187: #define SQLITE_MUTEX_RECURSIVE 1
6188: #define SQLITE_MUTEX_STATIC_MASTER 2
6189: #define SQLITE_MUTEX_STATIC_MEM 3 /* sqlite3_malloc() */
6190: #define SQLITE_MUTEX_STATIC_MEM2 4 /* NOT USED */
6191: #define SQLITE_MUTEX_STATIC_OPEN 4 /* sqlite3BtreeOpen() */
6192: #define SQLITE_MUTEX_STATIC_PRNG 5 /* sqlite3_random() */
6193: #define SQLITE_MUTEX_STATIC_LRU 6 /* lru page list */
6194: #define SQLITE_MUTEX_STATIC_LRU2 7 /* NOT USED */
6195: #define SQLITE_MUTEX_STATIC_PMEM 7 /* sqlite3PageMalloc() */
6196:
6197: /*
6198: ** CAPI3REF: Retrieve the mutex for a database connection
6199: **
6200: ** ^This interface returns a pointer the [sqlite3_mutex] object that
6201: ** serializes access to the [database connection] given in the argument
6202: ** when the [threading mode] is Serialized.
6203: ** ^If the [threading mode] is Single-thread or Multi-thread then this
6204: ** routine returns a NULL pointer.
6205: */
6206: SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
6207:
6208: /*
6209: ** CAPI3REF: Low-Level Control Of Database Files
6210: **
6211: ** ^The [sqlite3_file_control()] interface makes a direct call to the
6212: ** xFileControl method for the [sqlite3_io_methods] object associated
6213: ** with a particular database identified by the second argument. ^The
6214: ** name of the database is "main" for the main database or "temp" for the
6215: ** TEMP database, or the name that appears after the AS keyword for
6216: ** databases that are added using the [ATTACH] SQL command.
6217: ** ^A NULL pointer can be used in place of "main" to refer to the
6218: ** main database file.
6219: ** ^The third and fourth parameters to this routine
6220: ** are passed directly through to the second and third parameters of
6221: ** the xFileControl method. ^The return value of the xFileControl
6222: ** method becomes the return value of this routine.
6223: **
6224: ** ^The SQLITE_FCNTL_FILE_POINTER value for the op parameter causes
6225: ** a pointer to the underlying [sqlite3_file] object to be written into
6226: ** the space pointed to by the 4th parameter. ^The SQLITE_FCNTL_FILE_POINTER
6227: ** case is a short-circuit path which does not actually invoke the
6228: ** underlying sqlite3_io_methods.xFileControl method.
6229: **
6230: ** ^If the second parameter (zDbName) does not match the name of any
6231: ** open database file, then SQLITE_ERROR is returned. ^This error
6232: ** code is not remembered and will not be recalled by [sqlite3_errcode()]
6233: ** or [sqlite3_errmsg()]. The underlying xFileControl method might
6234: ** also return SQLITE_ERROR. There is no way to distinguish between
6235: ** an incorrect zDbName and an SQLITE_ERROR return from the underlying
6236: ** xFileControl method.
6237: **
6238: ** See also: [SQLITE_FCNTL_LOCKSTATE]
6239: */
6240: SQLITE_API int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
6241:
6242: /*
6243: ** CAPI3REF: Testing Interface
6244: **
6245: ** ^The sqlite3_test_control() interface is used to read out internal
6246: ** state of SQLite and to inject faults into SQLite for testing
6247: ** purposes. ^The first parameter is an operation code that determines
6248: ** the number, meaning, and operation of all subsequent parameters.
6249: **
6250: ** This interface is not for use by applications. It exists solely
6251: ** for verifying the correct operation of the SQLite library. Depending
6252: ** on how the SQLite library is compiled, this interface might not exist.
6253: **
6254: ** The details of the operation codes, their meanings, the parameters
6255: ** they take, and what they do are all subject to change without notice.
6256: ** Unlike most of the SQLite API, this function is not guaranteed to
6257: ** operate consistently from one release to the next.
6258: */
6259: SQLITE_API int sqlite3_test_control(int op, ...);
6260:
6261: /*
6262: ** CAPI3REF: Testing Interface Operation Codes
6263: **
6264: ** These constants are the valid operation code parameters used
6265: ** as the first argument to [sqlite3_test_control()].
6266: **
6267: ** These parameters and their meanings are subject to change
6268: ** without notice. These values are for testing purposes only.
6269: ** Applications should not use any of these parameters or the
6270: ** [sqlite3_test_control()] interface.
6271: */
6272: #define SQLITE_TESTCTRL_FIRST 5
6273: #define SQLITE_TESTCTRL_PRNG_SAVE 5
6274: #define SQLITE_TESTCTRL_PRNG_RESTORE 6
6275: #define SQLITE_TESTCTRL_PRNG_RESET 7
6276: #define SQLITE_TESTCTRL_BITVEC_TEST 8
6277: #define SQLITE_TESTCTRL_FAULT_INSTALL 9
6278: #define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10
6279: #define SQLITE_TESTCTRL_PENDING_BYTE 11
6280: #define SQLITE_TESTCTRL_ASSERT 12
6281: #define SQLITE_TESTCTRL_ALWAYS 13
6282: #define SQLITE_TESTCTRL_RESERVE 14
6283: #define SQLITE_TESTCTRL_OPTIMIZATIONS 15
6284: #define SQLITE_TESTCTRL_ISKEYWORD 16
6285: #define SQLITE_TESTCTRL_SCRATCHMALLOC 17
6286: #define SQLITE_TESTCTRL_LOCALTIME_FAULT 18
6287: #define SQLITE_TESTCTRL_EXPLAIN_STMT 19
6288: #define SQLITE_TESTCTRL_LAST 19
6289:
6290: /*
6291: ** CAPI3REF: SQLite Runtime Status
6292: **
6293: ** ^This interface is used to retrieve runtime status information
6294: ** about the performance of SQLite, and optionally to reset various
6295: ** highwater marks. ^The first argument is an integer code for
6296: ** the specific parameter to measure. ^(Recognized integer codes
6297: ** are of the form [status parameters | SQLITE_STATUS_...].)^
6298: ** ^The current value of the parameter is returned into *pCurrent.
6299: ** ^The highest recorded value is returned in *pHighwater. ^If the
6300: ** resetFlag is true, then the highest record value is reset after
6301: ** *pHighwater is written. ^(Some parameters do not record the highest
6302: ** value. For those parameters
6303: ** nothing is written into *pHighwater and the resetFlag is ignored.)^
6304: ** ^(Other parameters record only the highwater mark and not the current
6305: ** value. For these latter parameters nothing is written into *pCurrent.)^
6306: **
6307: ** ^The sqlite3_status() routine returns SQLITE_OK on success and a
6308: ** non-zero [error code] on failure.
6309: **
6310: ** This routine is threadsafe but is not atomic. This routine can be
6311: ** called while other threads are running the same or different SQLite
6312: ** interfaces. However the values returned in *pCurrent and
6313: ** *pHighwater reflect the status of SQLite at different points in time
6314: ** and it is possible that another thread might change the parameter
6315: ** in between the times when *pCurrent and *pHighwater are written.
6316: **
6317: ** See also: [sqlite3_db_status()]
6318: */
6319: SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
6320:
6321:
6322: /*
6323: ** CAPI3REF: Status Parameters
6324: ** KEYWORDS: {status parameters}
6325: **
6326: ** These integer constants designate various run-time status parameters
6327: ** that can be returned by [sqlite3_status()].
6328: **
6329: ** <dl>
6330: ** [[SQLITE_STATUS_MEMORY_USED]] ^(<dt>SQLITE_STATUS_MEMORY_USED</dt>
6331: ** <dd>This parameter is the current amount of memory checked out
6332: ** using [sqlite3_malloc()], either directly or indirectly. The
6333: ** figure includes calls made to [sqlite3_malloc()] by the application
6334: ** and internal memory usage by the SQLite library. Scratch memory
6335: ** controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache
6336: ** memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in
6337: ** this parameter. The amount returned is the sum of the allocation
6338: ** sizes as reported by the xSize method in [sqlite3_mem_methods].</dd>)^
6339: **
6340: ** [[SQLITE_STATUS_MALLOC_SIZE]] ^(<dt>SQLITE_STATUS_MALLOC_SIZE</dt>
6341: ** <dd>This parameter records the largest memory allocation request
6342: ** handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their
6343: ** internal equivalents). Only the value returned in the
6344: ** *pHighwater parameter to [sqlite3_status()] is of interest.
6345: ** The value written into the *pCurrent parameter is undefined.</dd>)^
6346: **
6347: ** [[SQLITE_STATUS_MALLOC_COUNT]] ^(<dt>SQLITE_STATUS_MALLOC_COUNT</dt>
6348: ** <dd>This parameter records the number of separate memory allocations
6349: ** currently checked out.</dd>)^
6350: **
6351: ** [[SQLITE_STATUS_PAGECACHE_USED]] ^(<dt>SQLITE_STATUS_PAGECACHE_USED</dt>
6352: ** <dd>This parameter returns the number of pages used out of the
6353: ** [pagecache memory allocator] that was configured using
6354: ** [SQLITE_CONFIG_PAGECACHE]. The
6355: ** value returned is in pages, not in bytes.</dd>)^
6356: **
6357: ** [[SQLITE_STATUS_PAGECACHE_OVERFLOW]]
6358: ** ^(<dt>SQLITE_STATUS_PAGECACHE_OVERFLOW</dt>
6359: ** <dd>This parameter returns the number of bytes of page cache
6360: ** allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE]
6361: ** buffer and where forced to overflow to [sqlite3_malloc()]. The
6362: ** returned value includes allocations that overflowed because they
6363: ** where too large (they were larger than the "sz" parameter to
6364: ** [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because
6365: ** no space was left in the page cache.</dd>)^
6366: **
6367: ** [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(<dt>SQLITE_STATUS_PAGECACHE_SIZE</dt>
6368: ** <dd>This parameter records the largest memory allocation request
6369: ** handed to [pagecache memory allocator]. Only the value returned in the
6370: ** *pHighwater parameter to [sqlite3_status()] is of interest.
6371: ** The value written into the *pCurrent parameter is undefined.</dd>)^
6372: **
6373: ** [[SQLITE_STATUS_SCRATCH_USED]] ^(<dt>SQLITE_STATUS_SCRATCH_USED</dt>
6374: ** <dd>This parameter returns the number of allocations used out of the
6375: ** [scratch memory allocator] configured using
6376: ** [SQLITE_CONFIG_SCRATCH]. The value returned is in allocations, not
6377: ** in bytes. Since a single thread may only have one scratch allocation
6378: ** outstanding at time, this parameter also reports the number of threads
6379: ** using scratch memory at the same time.</dd>)^
6380: **
6381: ** [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(<dt>SQLITE_STATUS_SCRATCH_OVERFLOW</dt>
6382: ** <dd>This parameter returns the number of bytes of scratch memory
6383: ** allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH]
6384: ** buffer and where forced to overflow to [sqlite3_malloc()]. The values
6385: ** returned include overflows because the requested allocation was too
6386: ** larger (that is, because the requested allocation was larger than the
6387: ** "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer
6388: ** slots were available.
6389: ** </dd>)^
6390: **
6391: ** [[SQLITE_STATUS_SCRATCH_SIZE]] ^(<dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
6392: ** <dd>This parameter records the largest memory allocation request
6393: ** handed to [scratch memory allocator]. Only the value returned in the
6394: ** *pHighwater parameter to [sqlite3_status()] is of interest.
6395: ** The value written into the *pCurrent parameter is undefined.</dd>)^
6396: **
6397: ** [[SQLITE_STATUS_PARSER_STACK]] ^(<dt>SQLITE_STATUS_PARSER_STACK</dt>
6398: ** <dd>This parameter records the deepest parser stack. It is only
6399: ** meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].</dd>)^
6400: ** </dl>
6401: **
6402: ** New status parameters may be added from time to time.
6403: */
6404: #define SQLITE_STATUS_MEMORY_USED 0
6405: #define SQLITE_STATUS_PAGECACHE_USED 1
6406: #define SQLITE_STATUS_PAGECACHE_OVERFLOW 2
6407: #define SQLITE_STATUS_SCRATCH_USED 3
6408: #define SQLITE_STATUS_SCRATCH_OVERFLOW 4
6409: #define SQLITE_STATUS_MALLOC_SIZE 5
6410: #define SQLITE_STATUS_PARSER_STACK 6
6411: #define SQLITE_STATUS_PAGECACHE_SIZE 7
6412: #define SQLITE_STATUS_SCRATCH_SIZE 8
6413: #define SQLITE_STATUS_MALLOC_COUNT 9
6414:
6415: /*
6416: ** CAPI3REF: Database Connection Status
6417: **
6418: ** ^This interface is used to retrieve runtime status information
6419: ** about a single [database connection]. ^The first argument is the
6420: ** database connection object to be interrogated. ^The second argument
6421: ** is an integer constant, taken from the set of
6422: ** [SQLITE_DBSTATUS options], that
6423: ** determines the parameter to interrogate. The set of
6424: ** [SQLITE_DBSTATUS options] is likely
6425: ** to grow in future releases of SQLite.
6426: **
6427: ** ^The current value of the requested parameter is written into *pCur
6428: ** and the highest instantaneous value is written into *pHiwtr. ^If
6429: ** the resetFlg is true, then the highest instantaneous value is
6430: ** reset back down to the current value.
6431: **
6432: ** ^The sqlite3_db_status() routine returns SQLITE_OK on success and a
6433: ** non-zero [error code] on failure.
6434: **
6435: ** See also: [sqlite3_status()] and [sqlite3_stmt_status()].
6436: */
6437: SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);
6438:
6439: /*
6440: ** CAPI3REF: Status Parameters for database connections
6441: ** KEYWORDS: {SQLITE_DBSTATUS options}
6442: **
6443: ** These constants are the available integer "verbs" that can be passed as
6444: ** the second argument to the [sqlite3_db_status()] interface.
6445: **
6446: ** New verbs may be added in future releases of SQLite. Existing verbs
6447: ** might be discontinued. Applications should check the return code from
6448: ** [sqlite3_db_status()] to make sure that the call worked.
6449: ** The [sqlite3_db_status()] interface will return a non-zero error code
6450: ** if a discontinued or unsupported verb is invoked.
6451: **
6452: ** <dl>
6453: ** [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt>
6454: ** <dd>This parameter returns the number of lookaside memory slots currently
6455: ** checked out.</dd>)^
6456: **
6457: ** [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_HIT</dt>
6458: ** <dd>This parameter returns the number malloc attempts that were
6459: ** satisfied using lookaside memory. Only the high-water value is meaningful;
6460: ** the current value is always zero.)^
6461: **
6462: ** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]]
6463: ** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>
6464: ** <dd>This parameter returns the number malloc attempts that might have
6465: ** been satisfied using lookaside memory but failed due to the amount of
6466: ** memory requested being larger than the lookaside slot size.
6467: ** Only the high-water value is meaningful;
6468: ** the current value is always zero.)^
6469: **
6470: ** [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]]
6471: ** ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL</dt>
6472: ** <dd>This parameter returns the number malloc attempts that might have
6473: ** been satisfied using lookaside memory but failed due to all lookaside
6474: ** memory already being in use.
6475: ** Only the high-water value is meaningful;
6476: ** the current value is always zero.)^
6477: **
6478: ** [[SQLITE_DBSTATUS_CACHE_USED]] ^(<dt>SQLITE_DBSTATUS_CACHE_USED</dt>
6479: ** <dd>This parameter returns the approximate number of of bytes of heap
6480: ** memory used by all pager caches associated with the database connection.)^
6481: ** ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
6482: **
6483: ** [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(<dt>SQLITE_DBSTATUS_SCHEMA_USED</dt>
6484: ** <dd>This parameter returns the approximate number of of bytes of heap
6485: ** memory used to store the schema for all databases associated
6486: ** with the connection - main, temp, and any [ATTACH]-ed databases.)^
6487: ** ^The full amount of memory used by the schemas is reported, even if the
6488: ** schema memory is shared with other database connections due to
6489: ** [shared cache mode] being enabled.
6490: ** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0.
6491: **
6492: ** [[SQLITE_DBSTATUS_STMT_USED]] ^(<dt>SQLITE_DBSTATUS_STMT_USED</dt>
6493: ** <dd>This parameter returns the approximate number of of bytes of heap
6494: ** and lookaside memory used by all prepared statements associated with
6495: ** the database connection.)^
6496: ** ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0.
6497: ** </dd>
6498: **
6499: ** [[SQLITE_DBSTATUS_CACHE_HIT]] ^(<dt>SQLITE_DBSTATUS_CACHE_HIT</dt>
6500: ** <dd>This parameter returns the number of pager cache hits that have
6501: ** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT
6502: ** is always 0.
6503: ** </dd>
6504: **
6505: ** [[SQLITE_DBSTATUS_CACHE_MISS]] ^(<dt>SQLITE_DBSTATUS_CACHE_MISS</dt>
6506: ** <dd>This parameter returns the number of pager cache misses that have
6507: ** occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS
6508: ** is always 0.
6509: ** </dd>
6510: ** </dl>
6511: */
6512: #define SQLITE_DBSTATUS_LOOKASIDE_USED 0
6513: #define SQLITE_DBSTATUS_CACHE_USED 1
6514: #define SQLITE_DBSTATUS_SCHEMA_USED 2
6515: #define SQLITE_DBSTATUS_STMT_USED 3
6516: #define SQLITE_DBSTATUS_LOOKASIDE_HIT 4
6517: #define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5
6518: #define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6
6519: #define SQLITE_DBSTATUS_CACHE_HIT 7
6520: #define SQLITE_DBSTATUS_CACHE_MISS 8
6521: #define SQLITE_DBSTATUS_MAX 8 /* Largest defined DBSTATUS */
6522:
6523:
6524: /*
6525: ** CAPI3REF: Prepared Statement Status
6526: **
6527: ** ^(Each prepared statement maintains various
6528: ** [SQLITE_STMTSTATUS counters] that measure the number
6529: ** of times it has performed specific operations.)^ These counters can
6530: ** be used to monitor the performance characteristics of the prepared
6531: ** statements. For example, if the number of table steps greatly exceeds
6532: ** the number of table searches or result rows, that would tend to indicate
6533: ** that the prepared statement is using a full table scan rather than
6534: ** an index.
6535: **
6536: ** ^(This interface is used to retrieve and reset counter values from
6537: ** a [prepared statement]. The first argument is the prepared statement
6538: ** object to be interrogated. The second argument
6539: ** is an integer code for a specific [SQLITE_STMTSTATUS counter]
6540: ** to be interrogated.)^
6541: ** ^The current value of the requested counter is returned.
6542: ** ^If the resetFlg is true, then the counter is reset to zero after this
6543: ** interface call returns.
6544: **
6545: ** See also: [sqlite3_status()] and [sqlite3_db_status()].
6546: */
6547: SQLITE_API int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
6548:
6549: /*
6550: ** CAPI3REF: Status Parameters for prepared statements
6551: ** KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters}
6552: **
6553: ** These preprocessor macros define integer codes that name counter
6554: ** values associated with the [sqlite3_stmt_status()] interface.
6555: ** The meanings of the various counters are as follows:
6556: **
6557: ** <dl>
6558: ** [[SQLITE_STMTSTATUS_FULLSCAN_STEP]] <dt>SQLITE_STMTSTATUS_FULLSCAN_STEP</dt>
6559: ** <dd>^This is the number of times that SQLite has stepped forward in
6560: ** a table as part of a full table scan. Large numbers for this counter
6561: ** may indicate opportunities for performance improvement through
6562: ** careful use of indices.</dd>
6563: **
6564: ** [[SQLITE_STMTSTATUS_SORT]] <dt>SQLITE_STMTSTATUS_SORT</dt>
6565: ** <dd>^This is the number of sort operations that have occurred.
6566: ** A non-zero value in this counter may indicate an opportunity to
6567: ** improvement performance through careful use of indices.</dd>
6568: **
6569: ** [[SQLITE_STMTSTATUS_AUTOINDEX]] <dt>SQLITE_STMTSTATUS_AUTOINDEX</dt>
6570: ** <dd>^This is the number of rows inserted into transient indices that
6571: ** were created automatically in order to help joins run faster.
6572: ** A non-zero value in this counter may indicate an opportunity to
6573: ** improvement performance by adding permanent indices that do not
6574: ** need to be reinitialized each time the statement is run.</dd>
6575: ** </dl>
6576: */
6577: #define SQLITE_STMTSTATUS_FULLSCAN_STEP 1
6578: #define SQLITE_STMTSTATUS_SORT 2
6579: #define SQLITE_STMTSTATUS_AUTOINDEX 3
6580:
6581: /*
6582: ** CAPI3REF: Custom Page Cache Object
6583: **
6584: ** The sqlite3_pcache type is opaque. It is implemented by
6585: ** the pluggable module. The SQLite core has no knowledge of
6586: ** its size or internal structure and never deals with the
6587: ** sqlite3_pcache object except by holding and passing pointers
6588: ** to the object.
6589: **
6590: ** See [sqlite3_pcache_methods2] for additional information.
6591: */
6592: typedef struct sqlite3_pcache sqlite3_pcache;
6593:
6594: /*
6595: ** CAPI3REF: Custom Page Cache Object
6596: **
6597: ** The sqlite3_pcache_page object represents a single page in the
6598: ** page cache. The page cache will allocate instances of this
6599: ** object. Various methods of the page cache use pointers to instances
6600: ** of this object as parameters or as their return value.
6601: **
6602: ** See [sqlite3_pcache_methods2] for additional information.
6603: */
6604: typedef struct sqlite3_pcache_page sqlite3_pcache_page;
6605: struct sqlite3_pcache_page {
6606: void *pBuf; /* The content of the page */
6607: void *pExtra; /* Extra information associated with the page */
6608: };
6609:
6610: /*
6611: ** CAPI3REF: Application Defined Page Cache.
6612: ** KEYWORDS: {page cache}
6613: **
6614: ** ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can
6615: ** register an alternative page cache implementation by passing in an
6616: ** instance of the sqlite3_pcache_methods2 structure.)^
6617: ** In many applications, most of the heap memory allocated by
6618: ** SQLite is used for the page cache.
6619: ** By implementing a
6620: ** custom page cache using this API, an application can better control
6621: ** the amount of memory consumed by SQLite, the way in which
6622: ** that memory is allocated and released, and the policies used to
6623: ** determine exactly which parts of a database file are cached and for
6624: ** how long.
6625: **
6626: ** The alternative page cache mechanism is an
6627: ** extreme measure that is only needed by the most demanding applications.
6628: ** The built-in page cache is recommended for most uses.
6629: **
6630: ** ^(The contents of the sqlite3_pcache_methods2 structure are copied to an
6631: ** internal buffer by SQLite within the call to [sqlite3_config]. Hence
6632: ** the application may discard the parameter after the call to
6633: ** [sqlite3_config()] returns.)^
6634: **
6635: ** [[the xInit() page cache method]]
6636: ** ^(The xInit() method is called once for each effective
6637: ** call to [sqlite3_initialize()])^
6638: ** (usually only once during the lifetime of the process). ^(The xInit()
6639: ** method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^
6640: ** The intent of the xInit() method is to set up global data structures
6641: ** required by the custom page cache implementation.
6642: ** ^(If the xInit() method is NULL, then the
6643: ** built-in default page cache is used instead of the application defined
6644: ** page cache.)^
6645: **
6646: ** [[the xShutdown() page cache method]]
6647: ** ^The xShutdown() method is called by [sqlite3_shutdown()].
6648: ** It can be used to clean up
6649: ** any outstanding resources before process shutdown, if required.
6650: ** ^The xShutdown() method may be NULL.
6651: **
6652: ** ^SQLite automatically serializes calls to the xInit method,
6653: ** so the xInit method need not be threadsafe. ^The
6654: ** xShutdown method is only called from [sqlite3_shutdown()] so it does
6655: ** not need to be threadsafe either. All other methods must be threadsafe
6656: ** in multithreaded applications.
6657: **
6658: ** ^SQLite will never invoke xInit() more than once without an intervening
6659: ** call to xShutdown().
6660: **
6661: ** [[the xCreate() page cache methods]]
6662: ** ^SQLite invokes the xCreate() method to construct a new cache instance.
6663: ** SQLite will typically create one cache instance for each open database file,
6664: ** though this is not guaranteed. ^The
6665: ** first parameter, szPage, is the size in bytes of the pages that must
6666: ** be allocated by the cache. ^szPage will always a power of two. ^The
6667: ** second parameter szExtra is a number of bytes of extra storage
6668: ** associated with each page cache entry. ^The szExtra parameter will
6669: ** a number less than 250. SQLite will use the
6670: ** extra szExtra bytes on each page to store metadata about the underlying
6671: ** database page on disk. The value passed into szExtra depends
6672: ** on the SQLite version, the target platform, and how SQLite was compiled.
6673: ** ^The third argument to xCreate(), bPurgeable, is true if the cache being
6674: ** created will be used to cache database pages of a file stored on disk, or
6675: ** false if it is used for an in-memory database. The cache implementation
6676: ** does not have to do anything special based with the value of bPurgeable;
6677: ** it is purely advisory. ^On a cache where bPurgeable is false, SQLite will
6678: ** never invoke xUnpin() except to deliberately delete a page.
6679: ** ^In other words, calls to xUnpin() on a cache with bPurgeable set to
6680: ** false will always have the "discard" flag set to true.
6681: ** ^Hence, a cache created with bPurgeable false will
6682: ** never contain any unpinned pages.
6683: **
6684: ** [[the xCachesize() page cache method]]
6685: ** ^(The xCachesize() method may be called at any time by SQLite to set the
6686: ** suggested maximum cache-size (number of pages stored by) the cache
6687: ** instance passed as the first argument. This is the value configured using
6688: ** the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable
6689: ** parameter, the implementation is not required to do anything with this
6690: ** value; it is advisory only.
6691: **
6692: ** [[the xPagecount() page cache methods]]
6693: ** The xPagecount() method must return the number of pages currently
6694: ** stored in the cache, both pinned and unpinned.
6695: **
6696: ** [[the xFetch() page cache methods]]
6697: ** The xFetch() method locates a page in the cache and returns a pointer to
6698: ** an sqlite3_pcache_page object associated with that page, or a NULL pointer.
6699: ** The pBuf element of the returned sqlite3_pcache_page object will be a
6700: ** pointer to a buffer of szPage bytes used to store the content of a
6701: ** single database page. The pExtra element of sqlite3_pcache_page will be
6702: ** a pointer to the szExtra bytes of extra storage that SQLite has requested
6703: ** for each entry in the page cache.
6704: **
6705: ** The page to be fetched is determined by the key. ^The minimum key value
6706: ** is 1. After it has been retrieved using xFetch, the page is considered
6707: ** to be "pinned".
6708: **
6709: ** If the requested page is already in the page cache, then the page cache
6710: ** implementation must return a pointer to the page buffer with its content
6711: ** intact. If the requested page is not already in the cache, then the
6712: ** cache implementation should use the value of the createFlag
6713: ** parameter to help it determined what action to take:
6714: **
6715: ** <table border=1 width=85% align=center>
6716: ** <tr><th> createFlag <th> Behaviour when page is not already in cache
6717: ** <tr><td> 0 <td> Do not allocate a new page. Return NULL.
6718: ** <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so.
6719: ** Otherwise return NULL.
6720: ** <tr><td> 2 <td> Make every effort to allocate a new page. Only return
6721: ** NULL if allocating a new page is effectively impossible.
6722: ** </table>
6723: **
6724: ** ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite
6725: ** will only use a createFlag of 2 after a prior call with a createFlag of 1
6726: ** failed.)^ In between the to xFetch() calls, SQLite may
6727: ** attempt to unpin one or more cache pages by spilling the content of
6728: ** pinned pages to disk and synching the operating system disk cache.
6729: **
6730: ** [[the xUnpin() page cache method]]
6731: ** ^xUnpin() is called by SQLite with a pointer to a currently pinned page
6732: ** as its second argument. If the third parameter, discard, is non-zero,
6733: ** then the page must be evicted from the cache.
6734: ** ^If the discard parameter is
6735: ** zero, then the page may be discarded or retained at the discretion of
6736: ** page cache implementation. ^The page cache implementation
6737: ** may choose to evict unpinned pages at any time.
6738: **
6739: ** The cache must not perform any reference counting. A single
6740: ** call to xUnpin() unpins the page regardless of the number of prior calls
6741: ** to xFetch().
6742: **
6743: ** [[the xRekey() page cache methods]]
6744: ** The xRekey() method is used to change the key value associated with the
6745: ** page passed as the second argument. If the cache
6746: ** previously contains an entry associated with newKey, it must be
6747: ** discarded. ^Any prior cache entry associated with newKey is guaranteed not
6748: ** to be pinned.
6749: **
6750: ** When SQLite calls the xTruncate() method, the cache must discard all
6751: ** existing cache entries with page numbers (keys) greater than or equal
6752: ** to the value of the iLimit parameter passed to xTruncate(). If any
6753: ** of these pages are pinned, they are implicitly unpinned, meaning that
6754: ** they can be safely discarded.
6755: **
6756: ** [[the xDestroy() page cache method]]
6757: ** ^The xDestroy() method is used to delete a cache allocated by xCreate().
6758: ** All resources associated with the specified cache should be freed. ^After
6759: ** calling the xDestroy() method, SQLite considers the [sqlite3_pcache*]
6760: ** handle invalid, and will not use it with any other sqlite3_pcache_methods2
6761: ** functions.
6762: **
6763: ** [[the xShrink() page cache method]]
6764: ** ^SQLite invokes the xShrink() method when it wants the page cache to
6765: ** free up as much of heap memory as possible. The page cache implementation
6766: ** is not obligated to free any memory, but well-behaved implementations should
6767: ** do their best.
6768: */
6769: typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2;
6770: struct sqlite3_pcache_methods2 {
6771: int iVersion;
6772: void *pArg;
6773: int (*xInit)(void*);
6774: void (*xShutdown)(void*);
6775: sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable);
6776: void (*xCachesize)(sqlite3_pcache*, int nCachesize);
6777: int (*xPagecount)(sqlite3_pcache*);
6778: sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
6779: void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard);
6780: void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*,
6781: unsigned oldKey, unsigned newKey);
6782: void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
6783: void (*xDestroy)(sqlite3_pcache*);
6784: void (*xShrink)(sqlite3_pcache*);
6785: };
6786:
6787: /*
6788: ** This is the obsolete pcache_methods object that has now been replaced
6789: ** by sqlite3_pcache_methods2. This object is not used by SQLite. It is
6790: ** retained in the header file for backwards compatibility only.
6791: */
6792: typedef struct sqlite3_pcache_methods sqlite3_pcache_methods;
6793: struct sqlite3_pcache_methods {
6794: void *pArg;
6795: int (*xInit)(void*);
6796: void (*xShutdown)(void*);
6797: sqlite3_pcache *(*xCreate)(int szPage, int bPurgeable);
6798: void (*xCachesize)(sqlite3_pcache*, int nCachesize);
6799: int (*xPagecount)(sqlite3_pcache*);
6800: void *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
6801: void (*xUnpin)(sqlite3_pcache*, void*, int discard);
6802: void (*xRekey)(sqlite3_pcache*, void*, unsigned oldKey, unsigned newKey);
6803: void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
6804: void (*xDestroy)(sqlite3_pcache*);
6805: };
6806:
6807:
6808: /*
6809: ** CAPI3REF: Online Backup Object
6810: **
6811: ** The sqlite3_backup object records state information about an ongoing
6812: ** online backup operation. ^The sqlite3_backup object is created by
6813: ** a call to [sqlite3_backup_init()] and is destroyed by a call to
6814: ** [sqlite3_backup_finish()].
6815: **
6816: ** See Also: [Using the SQLite Online Backup API]
6817: */
6818: typedef struct sqlite3_backup sqlite3_backup;
6819:
6820: /*
6821: ** CAPI3REF: Online Backup API.
6822: **
6823: ** The backup API copies the content of one database into another.
6824: ** It is useful either for creating backups of databases or
6825: ** for copying in-memory databases to or from persistent files.
6826: **
6827: ** See Also: [Using the SQLite Online Backup API]
6828: **
6829: ** ^SQLite holds a write transaction open on the destination database file
6830: ** for the duration of the backup operation.
6831: ** ^The source database is read-locked only while it is being read;
6832: ** it is not locked continuously for the entire backup operation.
6833: ** ^Thus, the backup may be performed on a live source database without
6834: ** preventing other database connections from
6835: ** reading or writing to the source database while the backup is underway.
6836: **
6837: ** ^(To perform a backup operation:
6838: ** <ol>
6839: ** <li><b>sqlite3_backup_init()</b> is called once to initialize the
6840: ** backup,
6841: ** <li><b>sqlite3_backup_step()</b> is called one or more times to transfer
6842: ** the data between the two databases, and finally
6843: ** <li><b>sqlite3_backup_finish()</b> is called to release all resources
6844: ** associated with the backup operation.
6845: ** </ol>)^
6846: ** There should be exactly one call to sqlite3_backup_finish() for each
6847: ** successful call to sqlite3_backup_init().
6848: **
6849: ** [[sqlite3_backup_init()]] <b>sqlite3_backup_init()</b>
6850: **
6851: ** ^The D and N arguments to sqlite3_backup_init(D,N,S,M) are the
6852: ** [database connection] associated with the destination database
6853: ** and the database name, respectively.
6854: ** ^The database name is "main" for the main database, "temp" for the
6855: ** temporary database, or the name specified after the AS keyword in
6856: ** an [ATTACH] statement for an attached database.
6857: ** ^The S and M arguments passed to
6858: ** sqlite3_backup_init(D,N,S,M) identify the [database connection]
6859: ** and database name of the source database, respectively.
6860: ** ^The source and destination [database connections] (parameters S and D)
6861: ** must be different or else sqlite3_backup_init(D,N,S,M) will fail with
6862: ** an error.
6863: **
6864: ** ^If an error occurs within sqlite3_backup_init(D,N,S,M), then NULL is
6865: ** returned and an error code and error message are stored in the
6866: ** destination [database connection] D.
6867: ** ^The error code and message for the failed call to sqlite3_backup_init()
6868: ** can be retrieved using the [sqlite3_errcode()], [sqlite3_errmsg()], and/or
6869: ** [sqlite3_errmsg16()] functions.
6870: ** ^A successful call to sqlite3_backup_init() returns a pointer to an
6871: ** [sqlite3_backup] object.
6872: ** ^The [sqlite3_backup] object may be used with the sqlite3_backup_step() and
6873: ** sqlite3_backup_finish() functions to perform the specified backup
6874: ** operation.
6875: **
6876: ** [[sqlite3_backup_step()]] <b>sqlite3_backup_step()</b>
6877: **
6878: ** ^Function sqlite3_backup_step(B,N) will copy up to N pages between
6879: ** the source and destination databases specified by [sqlite3_backup] object B.
6880: ** ^If N is negative, all remaining source pages are copied.
6881: ** ^If sqlite3_backup_step(B,N) successfully copies N pages and there
6882: ** are still more pages to be copied, then the function returns [SQLITE_OK].
6883: ** ^If sqlite3_backup_step(B,N) successfully finishes copying all pages
6884: ** from source to destination, then it returns [SQLITE_DONE].
6885: ** ^If an error occurs while running sqlite3_backup_step(B,N),
6886: ** then an [error code] is returned. ^As well as [SQLITE_OK] and
6887: ** [SQLITE_DONE], a call to sqlite3_backup_step() may return [SQLITE_READONLY],
6888: ** [SQLITE_NOMEM], [SQLITE_BUSY], [SQLITE_LOCKED], or an
6889: ** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX] extended error code.
6890: **
6891: ** ^(The sqlite3_backup_step() might return [SQLITE_READONLY] if
6892: ** <ol>
6893: ** <li> the destination database was opened read-only, or
6894: ** <li> the destination database is using write-ahead-log journaling
6895: ** and the destination and source page sizes differ, or
6896: ** <li> the destination database is an in-memory database and the
6897: ** destination and source page sizes differ.
6898: ** </ol>)^
6899: **
6900: ** ^If sqlite3_backup_step() cannot obtain a required file-system lock, then
6901: ** the [sqlite3_busy_handler | busy-handler function]
6902: ** is invoked (if one is specified). ^If the
6903: ** busy-handler returns non-zero before the lock is available, then
6904: ** [SQLITE_BUSY] is returned to the caller. ^In this case the call to
6905: ** sqlite3_backup_step() can be retried later. ^If the source
6906: ** [database connection]
6907: ** is being used to write to the source database when sqlite3_backup_step()
6908: ** is called, then [SQLITE_LOCKED] is returned immediately. ^Again, in this
6909: ** case the call to sqlite3_backup_step() can be retried later on. ^(If
6910: ** [SQLITE_IOERR_ACCESS | SQLITE_IOERR_XXX], [SQLITE_NOMEM], or
6911: ** [SQLITE_READONLY] is returned, then
6912: ** there is no point in retrying the call to sqlite3_backup_step(). These
6913: ** errors are considered fatal.)^ The application must accept
6914: ** that the backup operation has failed and pass the backup operation handle
6915: ** to the sqlite3_backup_finish() to release associated resources.
6916: **
6917: ** ^The first call to sqlite3_backup_step() obtains an exclusive lock
6918: ** on the destination file. ^The exclusive lock is not released until either
6919: ** sqlite3_backup_finish() is called or the backup operation is complete
6920: ** and sqlite3_backup_step() returns [SQLITE_DONE]. ^Every call to
6921: ** sqlite3_backup_step() obtains a [shared lock] on the source database that
6922: ** lasts for the duration of the sqlite3_backup_step() call.
6923: ** ^Because the source database is not locked between calls to
6924: ** sqlite3_backup_step(), the source database may be modified mid-way
6925: ** through the backup process. ^If the source database is modified by an
6926: ** external process or via a database connection other than the one being
6927: ** used by the backup operation, then the backup will be automatically
6928: ** restarted by the next call to sqlite3_backup_step(). ^If the source
6929: ** database is modified by the using the same database connection as is used
6930: ** by the backup operation, then the backup database is automatically
6931: ** updated at the same time.
6932: **
6933: ** [[sqlite3_backup_finish()]] <b>sqlite3_backup_finish()</b>
6934: **
6935: ** When sqlite3_backup_step() has returned [SQLITE_DONE], or when the
6936: ** application wishes to abandon the backup operation, the application
6937: ** should destroy the [sqlite3_backup] by passing it to sqlite3_backup_finish().
6938: ** ^The sqlite3_backup_finish() interfaces releases all
6939: ** resources associated with the [sqlite3_backup] object.
6940: ** ^If sqlite3_backup_step() has not yet returned [SQLITE_DONE], then any
6941: ** active write-transaction on the destination database is rolled back.
6942: ** The [sqlite3_backup] object is invalid
6943: ** and may not be used following a call to sqlite3_backup_finish().
6944: **
6945: ** ^The value returned by sqlite3_backup_finish is [SQLITE_OK] if no
6946: ** sqlite3_backup_step() errors occurred, regardless or whether or not
6947: ** sqlite3_backup_step() completed.
6948: ** ^If an out-of-memory condition or IO error occurred during any prior
6949: ** sqlite3_backup_step() call on the same [sqlite3_backup] object, then
6950: ** sqlite3_backup_finish() returns the corresponding [error code].
6951: **
6952: ** ^A return of [SQLITE_BUSY] or [SQLITE_LOCKED] from sqlite3_backup_step()
6953: ** is not a permanent error and does not affect the return value of
6954: ** sqlite3_backup_finish().
6955: **
6956: ** [[sqlite3_backup__remaining()]] [[sqlite3_backup_pagecount()]]
6957: ** <b>sqlite3_backup_remaining() and sqlite3_backup_pagecount()</b>
6958: **
6959: ** ^Each call to sqlite3_backup_step() sets two values inside
6960: ** the [sqlite3_backup] object: the number of pages still to be backed
6961: ** up and the total number of pages in the source database file.
6962: ** The sqlite3_backup_remaining() and sqlite3_backup_pagecount() interfaces
6963: ** retrieve these two values, respectively.
6964: **
6965: ** ^The values returned by these functions are only updated by
6966: ** sqlite3_backup_step(). ^If the source database is modified during a backup
6967: ** operation, then the values are not updated to account for any extra
6968: ** pages that need to be updated or the size of the source database file
6969: ** changing.
6970: **
6971: ** <b>Concurrent Usage of Database Handles</b>
6972: **
6973: ** ^The source [database connection] may be used by the application for other
6974: ** purposes while a backup operation is underway or being initialized.
6975: ** ^If SQLite is compiled and configured to support threadsafe database
6976: ** connections, then the source database connection may be used concurrently
6977: ** from within other threads.
6978: **
6979: ** However, the application must guarantee that the destination
6980: ** [database connection] is not passed to any other API (by any thread) after
6981: ** sqlite3_backup_init() is called and before the corresponding call to
6982: ** sqlite3_backup_finish(). SQLite does not currently check to see
6983: ** if the application incorrectly accesses the destination [database connection]
6984: ** and so no error code is reported, but the operations may malfunction
6985: ** nevertheless. Use of the destination database connection while a
6986: ** backup is in progress might also also cause a mutex deadlock.
6987: **
6988: ** If running in [shared cache mode], the application must
6989: ** guarantee that the shared cache used by the destination database
6990: ** is not accessed while the backup is running. In practice this means
6991: ** that the application must guarantee that the disk file being
6992: ** backed up to is not accessed by any connection within the process,
6993: ** not just the specific connection that was passed to sqlite3_backup_init().
6994: **
6995: ** The [sqlite3_backup] object itself is partially threadsafe. Multiple
6996: ** threads may safely make multiple concurrent calls to sqlite3_backup_step().
6997: ** However, the sqlite3_backup_remaining() and sqlite3_backup_pagecount()
6998: ** APIs are not strictly speaking threadsafe. If they are invoked at the
6999: ** same time as another thread is invoking sqlite3_backup_step() it is
7000: ** possible that they return invalid values.
7001: */
7002: SQLITE_API sqlite3_backup *sqlite3_backup_init(
7003: sqlite3 *pDest, /* Destination database handle */
7004: const char *zDestName, /* Destination database name */
7005: sqlite3 *pSource, /* Source database handle */
7006: const char *zSourceName /* Source database name */
7007: );
7008: SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage);
7009: SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p);
7010: SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p);
7011: SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p);
7012:
7013: /*
7014: ** CAPI3REF: Unlock Notification
7015: **
7016: ** ^When running in shared-cache mode, a database operation may fail with
7017: ** an [SQLITE_LOCKED] error if the required locks on the shared-cache or
7018: ** individual tables within the shared-cache cannot be obtained. See
7019: ** [SQLite Shared-Cache Mode] for a description of shared-cache locking.
7020: ** ^This API may be used to register a callback that SQLite will invoke
7021: ** when the connection currently holding the required lock relinquishes it.
7022: ** ^This API is only available if the library was compiled with the
7023: ** [SQLITE_ENABLE_UNLOCK_NOTIFY] C-preprocessor symbol defined.
7024: **
7025: ** See Also: [Using the SQLite Unlock Notification Feature].
7026: **
7027: ** ^Shared-cache locks are released when a database connection concludes
7028: ** its current transaction, either by committing it or rolling it back.
7029: **
7030: ** ^When a connection (known as the blocked connection) fails to obtain a
7031: ** shared-cache lock and SQLITE_LOCKED is returned to the caller, the
7032: ** identity of the database connection (the blocking connection) that
7033: ** has locked the required resource is stored internally. ^After an
7034: ** application receives an SQLITE_LOCKED error, it may call the
7035: ** sqlite3_unlock_notify() method with the blocked connection handle as
7036: ** the first argument to register for a callback that will be invoked
7037: ** when the blocking connections current transaction is concluded. ^The
7038: ** callback is invoked from within the [sqlite3_step] or [sqlite3_close]
7039: ** call that concludes the blocking connections transaction.
7040: **
7041: ** ^(If sqlite3_unlock_notify() is called in a multi-threaded application,
7042: ** there is a chance that the blocking connection will have already
7043: ** concluded its transaction by the time sqlite3_unlock_notify() is invoked.
7044: ** If this happens, then the specified callback is invoked immediately,
7045: ** from within the call to sqlite3_unlock_notify().)^
7046: **
7047: ** ^If the blocked connection is attempting to obtain a write-lock on a
7048: ** shared-cache table, and more than one other connection currently holds
7049: ** a read-lock on the same table, then SQLite arbitrarily selects one of
7050: ** the other connections to use as the blocking connection.
7051: **
7052: ** ^(There may be at most one unlock-notify callback registered by a
7053: ** blocked connection. If sqlite3_unlock_notify() is called when the
7054: ** blocked connection already has a registered unlock-notify callback,
7055: ** then the new callback replaces the old.)^ ^If sqlite3_unlock_notify() is
7056: ** called with a NULL pointer as its second argument, then any existing
7057: ** unlock-notify callback is canceled. ^The blocked connections
7058: ** unlock-notify callback may also be canceled by closing the blocked
7059: ** connection using [sqlite3_close()].
7060: **
7061: ** The unlock-notify callback is not reentrant. If an application invokes
7062: ** any sqlite3_xxx API functions from within an unlock-notify callback, a
7063: ** crash or deadlock may be the result.
7064: **
7065: ** ^Unless deadlock is detected (see below), sqlite3_unlock_notify() always
7066: ** returns SQLITE_OK.
7067: **
7068: ** <b>Callback Invocation Details</b>
7069: **
7070: ** When an unlock-notify callback is registered, the application provides a
7071: ** single void* pointer that is passed to the callback when it is invoked.
7072: ** However, the signature of the callback function allows SQLite to pass
7073: ** it an array of void* context pointers. The first argument passed to
7074: ** an unlock-notify callback is a pointer to an array of void* pointers,
7075: ** and the second is the number of entries in the array.
7076: **
7077: ** When a blocking connections transaction is concluded, there may be
7078: ** more than one blocked connection that has registered for an unlock-notify
7079: ** callback. ^If two or more such blocked connections have specified the
7080: ** same callback function, then instead of invoking the callback function
7081: ** multiple times, it is invoked once with the set of void* context pointers
7082: ** specified by the blocked connections bundled together into an array.
7083: ** This gives the application an opportunity to prioritize any actions
7084: ** related to the set of unblocked database connections.
7085: **
7086: ** <b>Deadlock Detection</b>
7087: **
7088: ** Assuming that after registering for an unlock-notify callback a
7089: ** database waits for the callback to be issued before taking any further
7090: ** action (a reasonable assumption), then using this API may cause the
7091: ** application to deadlock. For example, if connection X is waiting for
7092: ** connection Y's transaction to be concluded, and similarly connection
7093: ** Y is waiting on connection X's transaction, then neither connection
7094: ** will proceed and the system may remain deadlocked indefinitely.
7095: **
7096: ** To avoid this scenario, the sqlite3_unlock_notify() performs deadlock
7097: ** detection. ^If a given call to sqlite3_unlock_notify() would put the
7098: ** system in a deadlocked state, then SQLITE_LOCKED is returned and no
7099: ** unlock-notify callback is registered. The system is said to be in
7100: ** a deadlocked state if connection A has registered for an unlock-notify
7101: ** callback on the conclusion of connection B's transaction, and connection
7102: ** B has itself registered for an unlock-notify callback when connection
7103: ** A's transaction is concluded. ^Indirect deadlock is also detected, so
7104: ** the system is also considered to be deadlocked if connection B has
7105: ** registered for an unlock-notify callback on the conclusion of connection
7106: ** C's transaction, where connection C is waiting on connection A. ^Any
7107: ** number of levels of indirection are allowed.
7108: **
7109: ** <b>The "DROP TABLE" Exception</b>
7110: **
7111: ** When a call to [sqlite3_step()] returns SQLITE_LOCKED, it is almost
7112: ** always appropriate to call sqlite3_unlock_notify(). There is however,
7113: ** one exception. When executing a "DROP TABLE" or "DROP INDEX" statement,
7114: ** SQLite checks if there are any currently executing SELECT statements
7115: ** that belong to the same connection. If there are, SQLITE_LOCKED is
7116: ** returned. In this case there is no "blocking connection", so invoking
7117: ** sqlite3_unlock_notify() results in the unlock-notify callback being
7118: ** invoked immediately. If the application then re-attempts the "DROP TABLE"
7119: ** or "DROP INDEX" query, an infinite loop might be the result.
7120: **
7121: ** One way around this problem is to check the extended error code returned
7122: ** by an sqlite3_step() call. ^(If there is a blocking connection, then the
7123: ** extended error code is set to SQLITE_LOCKED_SHAREDCACHE. Otherwise, in
7124: ** the special "DROP TABLE/INDEX" case, the extended error code is just
7125: ** SQLITE_LOCKED.)^
7126: */
7127: SQLITE_API int sqlite3_unlock_notify(
7128: sqlite3 *pBlocked, /* Waiting connection */
7129: void (*xNotify)(void **apArg, int nArg), /* Callback function to invoke */
7130: void *pNotifyArg /* Argument to pass to xNotify */
7131: );
7132:
7133:
7134: /*
7135: ** CAPI3REF: String Comparison
7136: **
7137: ** ^The [sqlite3_strnicmp()] API allows applications and extensions to
7138: ** compare the contents of two buffers containing UTF-8 strings in a
7139: ** case-independent fashion, using the same definition of case independence
7140: ** that SQLite uses internally when comparing identifiers.
7141: */
7142: SQLITE_API int sqlite3_strnicmp(const char *, const char *, int);
7143:
7144: /*
7145: ** CAPI3REF: Error Logging Interface
7146: **
7147: ** ^The [sqlite3_log()] interface writes a message into the error log
7148: ** established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()].
7149: ** ^If logging is enabled, the zFormat string and subsequent arguments are
7150: ** used with [sqlite3_snprintf()] to generate the final output string.
7151: **
7152: ** The sqlite3_log() interface is intended for use by extensions such as
7153: ** virtual tables, collating functions, and SQL functions. While there is
7154: ** nothing to prevent an application from calling sqlite3_log(), doing so
7155: ** is considered bad form.
7156: **
7157: ** The zFormat string must not be NULL.
7158: **
7159: ** To avoid deadlocks and other threading problems, the sqlite3_log() routine
7160: ** will not use dynamically allocated memory. The log message is stored in
7161: ** a fixed-length buffer on the stack. If the log message is longer than
7162: ** a few hundred characters, it will be truncated to the length of the
7163: ** buffer.
7164: */
7165: SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...);
7166:
7167: /*
7168: ** CAPI3REF: Write-Ahead Log Commit Hook
7169: **
7170: ** ^The [sqlite3_wal_hook()] function is used to register a callback that
7171: ** will be invoked each time a database connection commits data to a
7172: ** [write-ahead log] (i.e. whenever a transaction is committed in
7173: ** [journal_mode | journal_mode=WAL mode]).
7174: **
7175: ** ^The callback is invoked by SQLite after the commit has taken place and
7176: ** the associated write-lock on the database released, so the implementation
7177: ** may read, write or [checkpoint] the database as required.
7178: **
7179: ** ^The first parameter passed to the callback function when it is invoked
7180: ** is a copy of the third parameter passed to sqlite3_wal_hook() when
7181: ** registering the callback. ^The second is a copy of the database handle.
7182: ** ^The third parameter is the name of the database that was written to -
7183: ** either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter
7184: ** is the number of pages currently in the write-ahead log file,
7185: ** including those that were just committed.
7186: **
7187: ** The callback function should normally return [SQLITE_OK]. ^If an error
7188: ** code is returned, that error will propagate back up through the
7189: ** SQLite code base to cause the statement that provoked the callback
7190: ** to report an error, though the commit will have still occurred. If the
7191: ** callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value
7192: ** that does not correspond to any valid SQLite error code, the results
7193: ** are undefined.
7194: **
7195: ** A single database handle may have at most a single write-ahead log callback
7196: ** registered at one time. ^Calling [sqlite3_wal_hook()] replaces any
7197: ** previously registered write-ahead log callback. ^Note that the
7198: ** [sqlite3_wal_autocheckpoint()] interface and the
7199: ** [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
7200: ** those overwrite any prior [sqlite3_wal_hook()] settings.
7201: */
7202: SQLITE_API void *sqlite3_wal_hook(
7203: sqlite3*,
7204: int(*)(void *,sqlite3*,const char*,int),
7205: void*
7206: );
7207:
7208: /*
7209: ** CAPI3REF: Configure an auto-checkpoint
7210: **
7211: ** ^The [sqlite3_wal_autocheckpoint(D,N)] is a wrapper around
7212: ** [sqlite3_wal_hook()] that causes any database on [database connection] D
7213: ** to automatically [checkpoint]
7214: ** after committing a transaction if there are N or
7215: ** more frames in the [write-ahead log] file. ^Passing zero or
7216: ** a negative value as the nFrame parameter disables automatic
7217: ** checkpoints entirely.
7218: **
7219: ** ^The callback registered by this function replaces any existing callback
7220: ** registered using [sqlite3_wal_hook()]. ^Likewise, registering a callback
7221: ** using [sqlite3_wal_hook()] disables the automatic checkpoint mechanism
7222: ** configured by this function.
7223: **
7224: ** ^The [wal_autocheckpoint pragma] can be used to invoke this interface
7225: ** from SQL.
7226: **
7227: ** ^Every new [database connection] defaults to having the auto-checkpoint
7228: ** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT]
7229: ** pages. The use of this interface
7230: ** is only necessary if the default setting is found to be suboptimal
7231: ** for a particular application.
7232: */
7233: SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);
7234:
7235: /*
7236: ** CAPI3REF: Checkpoint a database
7237: **
7238: ** ^The [sqlite3_wal_checkpoint(D,X)] interface causes database named X
7239: ** on [database connection] D to be [checkpointed]. ^If X is NULL or an
7240: ** empty string, then a checkpoint is run on all databases of
7241: ** connection D. ^If the database connection D is not in
7242: ** [WAL | write-ahead log mode] then this interface is a harmless no-op.
7243: **
7244: ** ^The [wal_checkpoint pragma] can be used to invoke this interface
7245: ** from SQL. ^The [sqlite3_wal_autocheckpoint()] interface and the
7246: ** [wal_autocheckpoint pragma] can be used to cause this interface to be
7247: ** run whenever the WAL reaches a certain size threshold.
7248: **
7249: ** See also: [sqlite3_wal_checkpoint_v2()]
7250: */
7251: SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb);
7252:
7253: /*
7254: ** CAPI3REF: Checkpoint a database
7255: **
7256: ** Run a checkpoint operation on WAL database zDb attached to database
7257: ** handle db. The specific operation is determined by the value of the
7258: ** eMode parameter:
7259: **
7260: ** <dl>
7261: ** <dt>SQLITE_CHECKPOINT_PASSIVE<dd>
7262: ** Checkpoint as many frames as possible without waiting for any database
7263: ** readers or writers to finish. Sync the db file if all frames in the log
7264: ** are checkpointed. This mode is the same as calling
7265: ** sqlite3_wal_checkpoint(). The busy-handler callback is never invoked.
7266: **
7267: ** <dt>SQLITE_CHECKPOINT_FULL<dd>
7268: ** This mode blocks (calls the busy-handler callback) until there is no
7269: ** database writer and all readers are reading from the most recent database
7270: ** snapshot. It then checkpoints all frames in the log file and syncs the
7271: ** database file. This call blocks database writers while it is running,
7272: ** but not database readers.
7273: **
7274: ** <dt>SQLITE_CHECKPOINT_RESTART<dd>
7275: ** This mode works the same way as SQLITE_CHECKPOINT_FULL, except after
7276: ** checkpointing the log file it blocks (calls the busy-handler callback)
7277: ** until all readers are reading from the database file only. This ensures
7278: ** that the next client to write to the database file restarts the log file
7279: ** from the beginning. This call blocks database writers while it is running,
7280: ** but not database readers.
7281: ** </dl>
7282: **
7283: ** If pnLog is not NULL, then *pnLog is set to the total number of frames in
7284: ** the log file before returning. If pnCkpt is not NULL, then *pnCkpt is set to
7285: ** the total number of checkpointed frames (including any that were already
7286: ** checkpointed when this function is called). *pnLog and *pnCkpt may be
7287: ** populated even if sqlite3_wal_checkpoint_v2() returns other than SQLITE_OK.
7288: ** If no values are available because of an error, they are both set to -1
7289: ** before returning to communicate this to the caller.
7290: **
7291: ** All calls obtain an exclusive "checkpoint" lock on the database file. If
7292: ** any other process is running a checkpoint operation at the same time, the
7293: ** lock cannot be obtained and SQLITE_BUSY is returned. Even if there is a
7294: ** busy-handler configured, it will not be invoked in this case.
7295: **
7296: ** The SQLITE_CHECKPOINT_FULL and RESTART modes also obtain the exclusive
7297: ** "writer" lock on the database file. If the writer lock cannot be obtained
7298: ** immediately, and a busy-handler is configured, it is invoked and the writer
7299: ** lock retried until either the busy-handler returns 0 or the lock is
7300: ** successfully obtained. The busy-handler is also invoked while waiting for
7301: ** database readers as described above. If the busy-handler returns 0 before
7302: ** the writer lock is obtained or while waiting for database readers, the
7303: ** checkpoint operation proceeds from that point in the same way as
7304: ** SQLITE_CHECKPOINT_PASSIVE - checkpointing as many frames as possible
7305: ** without blocking any further. SQLITE_BUSY is returned in this case.
7306: **
7307: ** If parameter zDb is NULL or points to a zero length string, then the
7308: ** specified operation is attempted on all WAL databases. In this case the
7309: ** values written to output parameters *pnLog and *pnCkpt are undefined. If
7310: ** an SQLITE_BUSY error is encountered when processing one or more of the
7311: ** attached WAL databases, the operation is still attempted on any remaining
7312: ** attached databases and SQLITE_BUSY is returned to the caller. If any other
7313: ** error occurs while processing an attached database, processing is abandoned
7314: ** and the error code returned to the caller immediately. If no error
7315: ** (SQLITE_BUSY or otherwise) is encountered while processing the attached
7316: ** databases, SQLITE_OK is returned.
7317: **
7318: ** If database zDb is the name of an attached database that is not in WAL
7319: ** mode, SQLITE_OK is returned and both *pnLog and *pnCkpt set to -1. If
7320: ** zDb is not NULL (or a zero length string) and is not the name of any
7321: ** attached database, SQLITE_ERROR is returned to the caller.
7322: */
7323: SQLITE_API int sqlite3_wal_checkpoint_v2(
7324: sqlite3 *db, /* Database handle */
7325: const char *zDb, /* Name of attached database (or NULL) */
7326: int eMode, /* SQLITE_CHECKPOINT_* value */
7327: int *pnLog, /* OUT: Size of WAL log in frames */
7328: int *pnCkpt /* OUT: Total number of frames checkpointed */
7329: );
7330:
7331: /*
7332: ** CAPI3REF: Checkpoint operation parameters
7333: **
7334: ** These constants can be used as the 3rd parameter to
7335: ** [sqlite3_wal_checkpoint_v2()]. See the [sqlite3_wal_checkpoint_v2()]
7336: ** documentation for additional information about the meaning and use of
7337: ** each of these values.
7338: */
7339: #define SQLITE_CHECKPOINT_PASSIVE 0
7340: #define SQLITE_CHECKPOINT_FULL 1
7341: #define SQLITE_CHECKPOINT_RESTART 2
7342:
7343: /*
7344: ** CAPI3REF: Virtual Table Interface Configuration
7345: **
7346: ** This function may be called by either the [xConnect] or [xCreate] method
7347: ** of a [virtual table] implementation to configure
7348: ** various facets of the virtual table interface.
7349: **
7350: ** If this interface is invoked outside the context of an xConnect or
7351: ** xCreate virtual table method then the behavior is undefined.
7352: **
7353: ** At present, there is only one option that may be configured using
7354: ** this function. (See [SQLITE_VTAB_CONSTRAINT_SUPPORT].) Further options
7355: ** may be added in the future.
7356: */
7357: SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);
7358:
7359: /*
7360: ** CAPI3REF: Virtual Table Configuration Options
7361: **
7362: ** These macros define the various options to the
7363: ** [sqlite3_vtab_config()] interface that [virtual table] implementations
7364: ** can use to customize and optimize their behavior.
7365: **
7366: ** <dl>
7367: ** <dt>SQLITE_VTAB_CONSTRAINT_SUPPORT
7368: ** <dd>Calls of the form
7369: ** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported,
7370: ** where X is an integer. If X is zero, then the [virtual table] whose
7371: ** [xCreate] or [xConnect] method invoked [sqlite3_vtab_config()] does not
7372: ** support constraints. In this configuration (which is the default) if
7373: ** a call to the [xUpdate] method returns [SQLITE_CONSTRAINT], then the entire
7374: ** statement is rolled back as if [ON CONFLICT | OR ABORT] had been
7375: ** specified as part of the users SQL statement, regardless of the actual
7376: ** ON CONFLICT mode specified.
7377: **
7378: ** If X is non-zero, then the virtual table implementation guarantees
7379: ** that if [xUpdate] returns [SQLITE_CONSTRAINT], it will do so before
7380: ** any modifications to internal or persistent data structures have been made.
7381: ** If the [ON CONFLICT] mode is ABORT, FAIL, IGNORE or ROLLBACK, SQLite
7382: ** is able to roll back a statement or database transaction, and abandon
7383: ** or continue processing the current SQL statement as appropriate.
7384: ** If the ON CONFLICT mode is REPLACE and the [xUpdate] method returns
7385: ** [SQLITE_CONSTRAINT], SQLite handles this as if the ON CONFLICT mode
7386: ** had been ABORT.
7387: **
7388: ** Virtual table implementations that are required to handle OR REPLACE
7389: ** must do so within the [xUpdate] method. If a call to the
7390: ** [sqlite3_vtab_on_conflict()] function indicates that the current ON
7391: ** CONFLICT policy is REPLACE, the virtual table implementation should
7392: ** silently replace the appropriate rows within the xUpdate callback and
7393: ** return SQLITE_OK. Or, if this is not possible, it may return
7394: ** SQLITE_CONSTRAINT, in which case SQLite falls back to OR ABORT
7395: ** constraint handling.
7396: ** </dl>
7397: */
7398: #define SQLITE_VTAB_CONSTRAINT_SUPPORT 1
7399:
7400: /*
7401: ** CAPI3REF: Determine The Virtual Table Conflict Policy
7402: **
7403: ** This function may only be called from within a call to the [xUpdate] method
7404: ** of a [virtual table] implementation for an INSERT or UPDATE operation. ^The
7405: ** value returned is one of [SQLITE_ROLLBACK], [SQLITE_IGNORE], [SQLITE_FAIL],
7406: ** [SQLITE_ABORT], or [SQLITE_REPLACE], according to the [ON CONFLICT] mode
7407: ** of the SQL statement that triggered the call to the [xUpdate] method of the
7408: ** [virtual table].
7409: */
7410: SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
7411:
7412: /*
7413: ** CAPI3REF: Conflict resolution modes
7414: **
7415: ** These constants are returned by [sqlite3_vtab_on_conflict()] to
7416: ** inform a [virtual table] implementation what the [ON CONFLICT] mode
7417: ** is for the SQL statement being evaluated.
7418: **
7419: ** Note that the [SQLITE_IGNORE] constant is also used as a potential
7420: ** return value from the [sqlite3_set_authorizer()] callback and that
7421: ** [SQLITE_ABORT] is also a [result code].
7422: */
7423: #define SQLITE_ROLLBACK 1
7424: /* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */
7425: #define SQLITE_FAIL 3
7426: /* #define SQLITE_ABORT 4 // Also an error code */
7427: #define SQLITE_REPLACE 5
7428:
7429:
7430:
7431: /*
7432: ** Undo the hack that converts floating point types to integer for
7433: ** builds on processors without floating point support.
7434: */
7435: #ifdef SQLITE_OMIT_FLOATING_POINT
7436: # undef double
7437: #endif
7438:
7439: #if 0
7440: } /* End of the 'extern "C"' block */
7441: #endif
7442: #endif
7443:
7444: /*
7445: ** 2010 August 30
7446: **
7447: ** The author disclaims copyright to this source code. In place of
7448: ** a legal notice, here is a blessing:
7449: **
7450: ** May you do good and not evil.
7451: ** May you find forgiveness for yourself and forgive others.
7452: ** May you share freely, never taking more than you give.
7453: **
7454: *************************************************************************
7455: */
7456:
7457: #ifndef _SQLITE3RTREE_H_
7458: #define _SQLITE3RTREE_H_
7459:
7460:
7461: #if 0
7462: extern "C" {
7463: #endif
7464:
7465: typedef struct sqlite3_rtree_geometry sqlite3_rtree_geometry;
7466:
7467: /*
7468: ** Register a geometry callback named zGeom that can be used as part of an
7469: ** R-Tree geometry query as follows:
7470: **
7471: ** SELECT ... FROM <rtree> WHERE <rtree col> MATCH $zGeom(... params ...)
7472: */
7473: SQLITE_API int sqlite3_rtree_geometry_callback(
7474: sqlite3 *db,
7475: const char *zGeom,
7476: int (*xGeom)(sqlite3_rtree_geometry *, int nCoord, double *aCoord, int *pRes),
7477: void *pContext
7478: );
7479:
7480:
7481: /*
7482: ** A pointer to a structure of the following type is passed as the first
7483: ** argument to callbacks registered using rtree_geometry_callback().
7484: */
7485: struct sqlite3_rtree_geometry {
7486: void *pContext; /* Copy of pContext passed to s_r_g_c() */
7487: int nParam; /* Size of array aParam[] */
7488: double *aParam; /* Parameters passed to SQL geom function */
7489: void *pUser; /* Callback implementation user data */
7490: void (*xDelUser)(void *); /* Called by SQLite to clean up pUser */
7491: };
7492:
7493:
7494: #if 0
7495: } /* end of the 'extern "C"' block */
7496: #endif
7497:
7498: #endif /* ifndef _SQLITE3RTREE_H_ */
7499:
7500:
7501: /************** End of sqlite3.h *********************************************/
7502: /************** Continuing where we left off in sqliteInt.h ******************/
7503: /************** Include hash.h in the middle of sqliteInt.h ******************/
7504: /************** Begin file hash.h ********************************************/
7505: /*
7506: ** 2001 September 22
7507: **
7508: ** The author disclaims copyright to this source code. In place of
7509: ** a legal notice, here is a blessing:
7510: **
7511: ** May you do good and not evil.
7512: ** May you find forgiveness for yourself and forgive others.
7513: ** May you share freely, never taking more than you give.
7514: **
7515: *************************************************************************
7516: ** This is the header file for the generic hash-table implemenation
7517: ** used in SQLite.
7518: */
7519: #ifndef _SQLITE_HASH_H_
7520: #define _SQLITE_HASH_H_
7521:
7522: /* Forward declarations of structures. */
7523: typedef struct Hash Hash;
7524: typedef struct HashElem HashElem;
7525:
7526: /* A complete hash table is an instance of the following structure.
7527: ** The internals of this structure are intended to be opaque -- client
7528: ** code should not attempt to access or modify the fields of this structure
7529: ** directly. Change this structure only by using the routines below.
7530: ** However, some of the "procedures" and "functions" for modifying and
7531: ** accessing this structure are really macros, so we can't really make
7532: ** this structure opaque.
7533: **
7534: ** All elements of the hash table are on a single doubly-linked list.
7535: ** Hash.first points to the head of this list.
7536: **
7537: ** There are Hash.htsize buckets. Each bucket points to a spot in
7538: ** the global doubly-linked list. The contents of the bucket are the
7539: ** element pointed to plus the next _ht.count-1 elements in the list.
7540: **
7541: ** Hash.htsize and Hash.ht may be zero. In that case lookup is done
7542: ** by a linear search of the global list. For small tables, the
7543: ** Hash.ht table is never allocated because if there are few elements
7544: ** in the table, it is faster to do a linear search than to manage
7545: ** the hash table.
7546: */
7547: struct Hash {
7548: unsigned int htsize; /* Number of buckets in the hash table */
7549: unsigned int count; /* Number of entries in this table */
7550: HashElem *first; /* The first element of the array */
7551: struct _ht { /* the hash table */
7552: int count; /* Number of entries with this hash */
7553: HashElem *chain; /* Pointer to first entry with this hash */
7554: } *ht;
7555: };
7556:
7557: /* Each element in the hash table is an instance of the following
7558: ** structure. All elements are stored on a single doubly-linked list.
7559: **
7560: ** Again, this structure is intended to be opaque, but it can't really
7561: ** be opaque because it is used by macros.
7562: */
7563: struct HashElem {
7564: HashElem *next, *prev; /* Next and previous elements in the table */
7565: void *data; /* Data associated with this element */
7566: const char *pKey; int nKey; /* Key associated with this element */
7567: };
7568:
7569: /*
7570: ** Access routines. To delete, insert a NULL pointer.
7571: */
7572: SQLITE_PRIVATE void sqlite3HashInit(Hash*);
7573: SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
7574: SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey);
7575: SQLITE_PRIVATE void sqlite3HashClear(Hash*);
7576:
7577: /*
7578: ** Macros for looping over all elements of a hash table. The idiom is
7579: ** like this:
7580: **
7581: ** Hash h;
7582: ** HashElem *p;
7583: ** ...
7584: ** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){
7585: ** SomeStructure *pData = sqliteHashData(p);
7586: ** // do something with pData
7587: ** }
7588: */
7589: #define sqliteHashFirst(H) ((H)->first)
7590: #define sqliteHashNext(E) ((E)->next)
7591: #define sqliteHashData(E) ((E)->data)
7592: /* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */
7593: /* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */
7594:
7595: /*
7596: ** Number of entries in a hash table
7597: */
7598: /* #define sqliteHashCount(H) ((H)->count) // NOT USED */
7599:
7600: #endif /* _SQLITE_HASH_H_ */
7601:
7602: /************** End of hash.h ************************************************/
7603: /************** Continuing where we left off in sqliteInt.h ******************/
7604: /************** Include parse.h in the middle of sqliteInt.h *****************/
7605: /************** Begin file parse.h *******************************************/
7606: #define TK_SEMI 1
7607: #define TK_EXPLAIN 2
7608: #define TK_QUERY 3
7609: #define TK_PLAN 4
7610: #define TK_BEGIN 5
7611: #define TK_TRANSACTION 6
7612: #define TK_DEFERRED 7
7613: #define TK_IMMEDIATE 8
7614: #define TK_EXCLUSIVE 9
7615: #define TK_COMMIT 10
7616: #define TK_END 11
7617: #define TK_ROLLBACK 12
7618: #define TK_SAVEPOINT 13
7619: #define TK_RELEASE 14
7620: #define TK_TO 15
7621: #define TK_TABLE 16
7622: #define TK_CREATE 17
7623: #define TK_IF 18
7624: #define TK_NOT 19
7625: #define TK_EXISTS 20
7626: #define TK_TEMP 21
7627: #define TK_LP 22
7628: #define TK_RP 23
7629: #define TK_AS 24
7630: #define TK_COMMA 25
7631: #define TK_ID 26
7632: #define TK_INDEXED 27
7633: #define TK_ABORT 28
7634: #define TK_ACTION 29
7635: #define TK_AFTER 30
7636: #define TK_ANALYZE 31
7637: #define TK_ASC 32
7638: #define TK_ATTACH 33
7639: #define TK_BEFORE 34
7640: #define TK_BY 35
7641: #define TK_CASCADE 36
7642: #define TK_CAST 37
7643: #define TK_COLUMNKW 38
7644: #define TK_CONFLICT 39
7645: #define TK_DATABASE 40
7646: #define TK_DESC 41
7647: #define TK_DETACH 42
7648: #define TK_EACH 43
7649: #define TK_FAIL 44
7650: #define TK_FOR 45
7651: #define TK_IGNORE 46
7652: #define TK_INITIALLY 47
7653: #define TK_INSTEAD 48
7654: #define TK_LIKE_KW 49
7655: #define TK_MATCH 50
7656: #define TK_NO 51
7657: #define TK_KEY 52
7658: #define TK_OF 53
7659: #define TK_OFFSET 54
7660: #define TK_PRAGMA 55
7661: #define TK_RAISE 56
7662: #define TK_REPLACE 57
7663: #define TK_RESTRICT 58
7664: #define TK_ROW 59
7665: #define TK_TRIGGER 60
7666: #define TK_VACUUM 61
7667: #define TK_VIEW 62
7668: #define TK_VIRTUAL 63
7669: #define TK_REINDEX 64
7670: #define TK_RENAME 65
7671: #define TK_CTIME_KW 66
7672: #define TK_ANY 67
7673: #define TK_OR 68
7674: #define TK_AND 69
7675: #define TK_IS 70
7676: #define TK_BETWEEN 71
7677: #define TK_IN 72
7678: #define TK_ISNULL 73
7679: #define TK_NOTNULL 74
7680: #define TK_NE 75
7681: #define TK_EQ 76
7682: #define TK_GT 77
7683: #define TK_LE 78
7684: #define TK_LT 79
7685: #define TK_GE 80
7686: #define TK_ESCAPE 81
7687: #define TK_BITAND 82
7688: #define TK_BITOR 83
7689: #define TK_LSHIFT 84
7690: #define TK_RSHIFT 85
7691: #define TK_PLUS 86
7692: #define TK_MINUS 87
7693: #define TK_STAR 88
7694: #define TK_SLASH 89
7695: #define TK_REM 90
7696: #define TK_CONCAT 91
7697: #define TK_COLLATE 92
7698: #define TK_BITNOT 93
7699: #define TK_STRING 94
7700: #define TK_JOIN_KW 95
7701: #define TK_CONSTRAINT 96
7702: #define TK_DEFAULT 97
7703: #define TK_NULL 98
7704: #define TK_PRIMARY 99
7705: #define TK_UNIQUE 100
7706: #define TK_CHECK 101
7707: #define TK_REFERENCES 102
7708: #define TK_AUTOINCR 103
7709: #define TK_ON 104
7710: #define TK_INSERT 105
7711: #define TK_DELETE 106
7712: #define TK_UPDATE 107
7713: #define TK_SET 108
7714: #define TK_DEFERRABLE 109
7715: #define TK_FOREIGN 110
7716: #define TK_DROP 111
7717: #define TK_UNION 112
7718: #define TK_ALL 113
7719: #define TK_EXCEPT 114
7720: #define TK_INTERSECT 115
7721: #define TK_SELECT 116
7722: #define TK_DISTINCT 117
7723: #define TK_DOT 118
7724: #define TK_FROM 119
7725: #define TK_JOIN 120
7726: #define TK_USING 121
7727: #define TK_ORDER 122
7728: #define TK_GROUP 123
7729: #define TK_HAVING 124
7730: #define TK_LIMIT 125
7731: #define TK_WHERE 126
7732: #define TK_INTO 127
7733: #define TK_VALUES 128
7734: #define TK_INTEGER 129
7735: #define TK_FLOAT 130
7736: #define TK_BLOB 131
7737: #define TK_REGISTER 132
7738: #define TK_VARIABLE 133
7739: #define TK_CASE 134
7740: #define TK_WHEN 135
7741: #define TK_THEN 136
7742: #define TK_ELSE 137
7743: #define TK_INDEX 138
7744: #define TK_ALTER 139
7745: #define TK_ADD 140
7746: #define TK_TO_TEXT 141
7747: #define TK_TO_BLOB 142
7748: #define TK_TO_NUMERIC 143
7749: #define TK_TO_INT 144
7750: #define TK_TO_REAL 145
7751: #define TK_ISNOT 146
7752: #define TK_END_OF_FILE 147
7753: #define TK_ILLEGAL 148
7754: #define TK_SPACE 149
7755: #define TK_UNCLOSED_STRING 150
7756: #define TK_FUNCTION 151
7757: #define TK_COLUMN 152
7758: #define TK_AGG_FUNCTION 153
7759: #define TK_AGG_COLUMN 154
7760: #define TK_CONST_FUNC 155
7761: #define TK_UMINUS 156
7762: #define TK_UPLUS 157
7763:
7764: /************** End of parse.h ***********************************************/
7765: /************** Continuing where we left off in sqliteInt.h ******************/
7766: #include <stdio.h>
7767: #include <stdlib.h>
7768: #include <string.h>
7769: #include <assert.h>
7770: #include <stddef.h>
7771:
7772: /*
7773: ** If compiling for a processor that lacks floating point support,
7774: ** substitute integer for floating-point
7775: */
7776: #ifdef SQLITE_OMIT_FLOATING_POINT
7777: # define double sqlite_int64
7778: # define float sqlite_int64
7779: # define LONGDOUBLE_TYPE sqlite_int64
7780: # ifndef SQLITE_BIG_DBL
7781: # define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50)
7782: # endif
7783: # define SQLITE_OMIT_DATETIME_FUNCS 1
7784: # define SQLITE_OMIT_TRACE 1
7785: # undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
7786: # undef SQLITE_HAVE_ISNAN
7787: #else
7788: # ifdef __vax__
7789: # include <float.h>
7790: # define SQLITE_BIG_DBL DBL_MAX
7791: # define SQLITE_HUGE_DBL DBL_MAX
7792: # endif
7793: #endif
7794: #ifndef SQLITE_BIG_DBL
7795: # define SQLITE_BIG_DBL (1e99)
7796: #endif
7797: #ifndef SQLITE_HUGE_DBL
7798: # define SQLITE_HUGE_DBL (1.0e+308)
7799: #endif
7800:
7801: /*
7802: ** OMIT_TEMPDB is set to 1 if SQLITE_OMIT_TEMPDB is defined, or 0
7803: ** afterward. Having this macro allows us to cause the C compiler
7804: ** to omit code used by TEMP tables without messy #ifndef statements.
7805: */
7806: #ifdef SQLITE_OMIT_TEMPDB
7807: #define OMIT_TEMPDB 1
7808: #else
7809: #define OMIT_TEMPDB 0
7810: #endif
7811:
7812: /*
7813: ** The "file format" number is an integer that is incremented whenever
7814: ** the VDBE-level file format changes. The following macros define the
7815: ** the default file format for new databases and the maximum file format
7816: ** that the library can read.
7817: */
7818: #define SQLITE_MAX_FILE_FORMAT 4
7819: #ifndef SQLITE_DEFAULT_FILE_FORMAT
7820: # define SQLITE_DEFAULT_FILE_FORMAT 4
7821: #endif
7822:
7823: /*
7824: ** Determine whether triggers are recursive by default. This can be
7825: ** changed at run-time using a pragma.
7826: */
7827: #ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS
7828: # define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0
7829: #endif
7830:
7831: /*
7832: ** Provide a default value for SQLITE_TEMP_STORE in case it is not specified
7833: ** on the command-line
7834: */
7835: #ifndef SQLITE_TEMP_STORE
7836: # define SQLITE_TEMP_STORE 1
7837: #endif
7838:
7839: /*
7840: ** GCC does not define the offsetof() macro so we'll have to do it
7841: ** ourselves.
7842: */
7843: #ifndef offsetof
7844: #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
7845: #endif
7846:
7847: /*
7848: ** Check to see if this machine uses EBCDIC. (Yes, believe it or
7849: ** not, there are still machines out there that use EBCDIC.)
7850: */
7851: #if 'A' == '\301'
7852: # define SQLITE_EBCDIC 1
7853: #else
7854: # define SQLITE_ASCII 1
7855: #endif
7856:
7857: /*
7858: ** Integers of known sizes. These typedefs might change for architectures
7859: ** where the sizes very. Preprocessor macros are available so that the
7860: ** types can be conveniently redefined at compile-type. Like this:
7861: **
7862: ** cc '-DUINTPTR_TYPE=long long int' ...
7863: */
7864: #ifndef UINT32_TYPE
7865: # ifdef HAVE_UINT32_T
7866: # define UINT32_TYPE uint32_t
7867: # else
7868: # define UINT32_TYPE unsigned int
7869: # endif
7870: #endif
7871: #ifndef UINT16_TYPE
7872: # ifdef HAVE_UINT16_T
7873: # define UINT16_TYPE uint16_t
7874: # else
7875: # define UINT16_TYPE unsigned short int
7876: # endif
7877: #endif
7878: #ifndef INT16_TYPE
7879: # ifdef HAVE_INT16_T
7880: # define INT16_TYPE int16_t
7881: # else
7882: # define INT16_TYPE short int
7883: # endif
7884: #endif
7885: #ifndef UINT8_TYPE
7886: # ifdef HAVE_UINT8_T
7887: # define UINT8_TYPE uint8_t
7888: # else
7889: # define UINT8_TYPE unsigned char
7890: # endif
7891: #endif
7892: #ifndef INT8_TYPE
7893: # ifdef HAVE_INT8_T
7894: # define INT8_TYPE int8_t
7895: # else
7896: # define INT8_TYPE signed char
7897: # endif
7898: #endif
7899: #ifndef LONGDOUBLE_TYPE
7900: # define LONGDOUBLE_TYPE long double
7901: #endif
7902: typedef sqlite_int64 i64; /* 8-byte signed integer */
7903: typedef sqlite_uint64 u64; /* 8-byte unsigned integer */
7904: typedef UINT32_TYPE u32; /* 4-byte unsigned integer */
7905: typedef UINT16_TYPE u16; /* 2-byte unsigned integer */
7906: typedef INT16_TYPE i16; /* 2-byte signed integer */
7907: typedef UINT8_TYPE u8; /* 1-byte unsigned integer */
7908: typedef INT8_TYPE i8; /* 1-byte signed integer */
7909:
7910: /*
7911: ** SQLITE_MAX_U32 is a u64 constant that is the maximum u64 value
7912: ** that can be stored in a u32 without loss of data. The value
7913: ** is 0x00000000ffffffff. But because of quirks of some compilers, we
7914: ** have to specify the value in the less intuitive manner shown:
7915: */
7916: #define SQLITE_MAX_U32 ((((u64)1)<<32)-1)
7917:
7918: /*
7919: ** The datatype used to store estimates of the number of rows in a
7920: ** table or index. This is an unsigned integer type. For 99.9% of
7921: ** the world, a 32-bit integer is sufficient. But a 64-bit integer
7922: ** can be used at compile-time if desired.
7923: */
7924: #ifdef SQLITE_64BIT_STATS
7925: typedef u64 tRowcnt; /* 64-bit only if requested at compile-time */
7926: #else
7927: typedef u32 tRowcnt; /* 32-bit is the default */
7928: #endif
7929:
7930: /*
7931: ** Macros to determine whether the machine is big or little endian,
7932: ** evaluated at runtime.
7933: */
7934: #ifdef SQLITE_AMALGAMATION
7935: SQLITE_PRIVATE const int sqlite3one = 1;
7936: #else
7937: SQLITE_PRIVATE const int sqlite3one;
7938: #endif
7939: #if defined(i386) || defined(__i386__) || defined(_M_IX86)\
7940: || defined(__x86_64) || defined(__x86_64__)
7941: # define SQLITE_BIGENDIAN 0
7942: # define SQLITE_LITTLEENDIAN 1
7943: # define SQLITE_UTF16NATIVE SQLITE_UTF16LE
7944: #else
7945: # define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0)
7946: # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1)
7947: # define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE)
7948: #endif
7949:
7950: /*
7951: ** Constants for the largest and smallest possible 64-bit signed integers.
7952: ** These macros are designed to work correctly on both 32-bit and 64-bit
7953: ** compilers.
7954: */
7955: #define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32))
7956: #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64)
7957:
7958: /*
7959: ** Round up a number to the next larger multiple of 8. This is used
7960: ** to force 8-byte alignment on 64-bit architectures.
7961: */
7962: #define ROUND8(x) (((x)+7)&~7)
7963:
7964: /*
7965: ** Round down to the nearest multiple of 8
7966: */
7967: #define ROUNDDOWN8(x) ((x)&~7)
7968:
7969: /*
7970: ** Assert that the pointer X is aligned to an 8-byte boundary. This
7971: ** macro is used only within assert() to verify that the code gets
7972: ** all alignment restrictions correct.
7973: **
7974: ** Except, if SQLITE_4_BYTE_ALIGNED_MALLOC is defined, then the
7975: ** underlying malloc() implemention might return us 4-byte aligned
7976: ** pointers. In that case, only verify 4-byte alignment.
7977: */
7978: #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
7979: # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0)
7980: #else
7981: # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0)
7982: #endif
7983:
7984:
7985: /*
7986: ** An instance of the following structure is used to store the busy-handler
7987: ** callback for a given sqlite handle.
7988: **
7989: ** The sqlite.busyHandler member of the sqlite struct contains the busy
7990: ** callback for the database handle. Each pager opened via the sqlite
7991: ** handle is passed a pointer to sqlite.busyHandler. The busy-handler
7992: ** callback is currently invoked only from within pager.c.
7993: */
7994: typedef struct BusyHandler BusyHandler;
7995: struct BusyHandler {
7996: int (*xFunc)(void *,int); /* The busy callback */
7997: void *pArg; /* First arg to busy callback */
7998: int nBusy; /* Incremented with each busy call */
7999: };
8000:
8001: /*
8002: ** Name of the master database table. The master database table
8003: ** is a special table that holds the names and attributes of all
8004: ** user tables and indices.
8005: */
8006: #define MASTER_NAME "sqlite_master"
8007: #define TEMP_MASTER_NAME "sqlite_temp_master"
8008:
8009: /*
8010: ** The root-page of the master database table.
8011: */
8012: #define MASTER_ROOT 1
8013:
8014: /*
8015: ** The name of the schema table.
8016: */
8017: #define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME)
8018:
8019: /*
8020: ** A convenience macro that returns the number of elements in
8021: ** an array.
8022: */
8023: #define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0])))
8024:
8025: /*
8026: ** The following value as a destructor means to use sqlite3DbFree().
8027: ** This is an internal extension to SQLITE_STATIC and SQLITE_TRANSIENT.
8028: */
8029: #define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3DbFree)
8030:
8031: /*
8032: ** When SQLITE_OMIT_WSD is defined, it means that the target platform does
8033: ** not support Writable Static Data (WSD) such as global and static variables.
8034: ** All variables must either be on the stack or dynamically allocated from
8035: ** the heap. When WSD is unsupported, the variable declarations scattered
8036: ** throughout the SQLite code must become constants instead. The SQLITE_WSD
8037: ** macro is used for this purpose. And instead of referencing the variable
8038: ** directly, we use its constant as a key to lookup the run-time allocated
8039: ** buffer that holds real variable. The constant is also the initializer
8040: ** for the run-time allocated buffer.
8041: **
8042: ** In the usual case where WSD is supported, the SQLITE_WSD and GLOBAL
8043: ** macros become no-ops and have zero performance impact.
8044: */
8045: #ifdef SQLITE_OMIT_WSD
8046: #define SQLITE_WSD const
8047: #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v)))
8048: #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config)
8049: SQLITE_API int sqlite3_wsd_init(int N, int J);
8050: SQLITE_API void *sqlite3_wsd_find(void *K, int L);
8051: #else
8052: #define SQLITE_WSD
8053: #define GLOBAL(t,v) v
8054: #define sqlite3GlobalConfig sqlite3Config
8055: #endif
8056:
8057: /*
8058: ** The following macros are used to suppress compiler warnings and to
8059: ** make it clear to human readers when a function parameter is deliberately
8060: ** left unused within the body of a function. This usually happens when
8061: ** a function is called via a function pointer. For example the
8062: ** implementation of an SQL aggregate step callback may not use the
8063: ** parameter indicating the number of arguments passed to the aggregate,
8064: ** if it knows that this is enforced elsewhere.
8065: **
8066: ** When a function parameter is not used at all within the body of a function,
8067: ** it is generally named "NotUsed" or "NotUsed2" to make things even clearer.
8068: ** However, these macros may also be used to suppress warnings related to
8069: ** parameters that may or may not be used depending on compilation options.
8070: ** For example those parameters only used in assert() statements. In these
8071: ** cases the parameters are named as per the usual conventions.
8072: */
8073: #define UNUSED_PARAMETER(x) (void)(x)
8074: #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y)
8075:
8076: /*
8077: ** Forward references to structures
8078: */
8079: typedef struct AggInfo AggInfo;
8080: typedef struct AuthContext AuthContext;
8081: typedef struct AutoincInfo AutoincInfo;
8082: typedef struct Bitvec Bitvec;
8083: typedef struct CollSeq CollSeq;
8084: typedef struct Column Column;
8085: typedef struct Db Db;
8086: typedef struct Schema Schema;
8087: typedef struct Expr Expr;
8088: typedef struct ExprList ExprList;
8089: typedef struct ExprSpan ExprSpan;
8090: typedef struct FKey FKey;
8091: typedef struct FuncDestructor FuncDestructor;
8092: typedef struct FuncDef FuncDef;
8093: typedef struct FuncDefHash FuncDefHash;
8094: typedef struct IdList IdList;
8095: typedef struct Index Index;
8096: typedef struct IndexSample IndexSample;
8097: typedef struct KeyClass KeyClass;
8098: typedef struct KeyInfo KeyInfo;
8099: typedef struct Lookaside Lookaside;
8100: typedef struct LookasideSlot LookasideSlot;
8101: typedef struct Module Module;
8102: typedef struct NameContext NameContext;
8103: typedef struct Parse Parse;
8104: typedef struct RowSet RowSet;
8105: typedef struct Savepoint Savepoint;
8106: typedef struct Select Select;
8107: typedef struct SrcList SrcList;
8108: typedef struct StrAccum StrAccum;
8109: typedef struct Table Table;
8110: typedef struct TableLock TableLock;
8111: typedef struct Token Token;
8112: typedef struct Trigger Trigger;
8113: typedef struct TriggerPrg TriggerPrg;
8114: typedef struct TriggerStep TriggerStep;
8115: typedef struct UnpackedRecord UnpackedRecord;
8116: typedef struct VTable VTable;
8117: typedef struct VtabCtx VtabCtx;
8118: typedef struct Walker Walker;
8119: typedef struct WherePlan WherePlan;
8120: typedef struct WhereInfo WhereInfo;
8121: typedef struct WhereLevel WhereLevel;
8122:
8123: /*
8124: ** Defer sourcing vdbe.h and btree.h until after the "u8" and
8125: ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque
8126: ** pointer types (i.e. FuncDef) defined above.
8127: */
8128: /************** Include btree.h in the middle of sqliteInt.h *****************/
8129: /************** Begin file btree.h *******************************************/
8130: /*
8131: ** 2001 September 15
8132: **
8133: ** The author disclaims copyright to this source code. In place of
8134: ** a legal notice, here is a blessing:
8135: **
8136: ** May you do good and not evil.
8137: ** May you find forgiveness for yourself and forgive others.
8138: ** May you share freely, never taking more than you give.
8139: **
8140: *************************************************************************
8141: ** This header file defines the interface that the sqlite B-Tree file
8142: ** subsystem. See comments in the source code for a detailed description
8143: ** of what each interface routine does.
8144: */
8145: #ifndef _BTREE_H_
8146: #define _BTREE_H_
8147:
8148: /* TODO: This definition is just included so other modules compile. It
8149: ** needs to be revisited.
8150: */
8151: #define SQLITE_N_BTREE_META 10
8152:
8153: /*
8154: ** If defined as non-zero, auto-vacuum is enabled by default. Otherwise
8155: ** it must be turned on for each database using "PRAGMA auto_vacuum = 1".
8156: */
8157: #ifndef SQLITE_DEFAULT_AUTOVACUUM
8158: #define SQLITE_DEFAULT_AUTOVACUUM 0
8159: #endif
8160:
8161: #define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */
8162: #define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */
8163: #define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */
8164:
8165: /*
8166: ** Forward declarations of structure
8167: */
8168: typedef struct Btree Btree;
8169: typedef struct BtCursor BtCursor;
8170: typedef struct BtShared BtShared;
8171:
8172:
8173: SQLITE_PRIVATE int sqlite3BtreeOpen(
8174: sqlite3_vfs *pVfs, /* VFS to use with this b-tree */
8175: const char *zFilename, /* Name of database file to open */
8176: sqlite3 *db, /* Associated database connection */
8177: Btree **ppBtree, /* Return open Btree* here */
8178: int flags, /* Flags */
8179: int vfsFlags /* Flags passed through to VFS open */
8180: );
8181:
8182: /* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the
8183: ** following values.
8184: **
8185: ** NOTE: These values must match the corresponding PAGER_ values in
8186: ** pager.h.
8187: */
8188: #define BTREE_OMIT_JOURNAL 1 /* Do not create or use a rollback journal */
8189: #define BTREE_NO_READLOCK 2 /* Omit readlocks on readonly files */
8190: #define BTREE_MEMORY 4 /* This is an in-memory DB */
8191: #define BTREE_SINGLE 8 /* The file contains at most 1 b-tree */
8192: #define BTREE_UNORDERED 16 /* Use of a hash implementation is OK */
8193:
8194: SQLITE_PRIVATE int sqlite3BtreeClose(Btree*);
8195: SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree*,int);
8196: SQLITE_PRIVATE int sqlite3BtreeSetSafetyLevel(Btree*,int,int,int);
8197: SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree*);
8198: SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int nPagesize, int nReserve, int eFix);
8199: SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree*);
8200: SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree*,int);
8201: SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree*);
8202: SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree*,int);
8203: SQLITE_PRIVATE int sqlite3BtreeGetReserve(Btree*);
8204: SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int);
8205: SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *);
8206: SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int);
8207: SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster);
8208: SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*, int);
8209: SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*);
8210: SQLITE_PRIVATE int sqlite3BtreeRollback(Btree*);
8211: SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree*,int);
8212: SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree*, int*, int flags);
8213: SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree*);
8214: SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans(Btree*);
8215: SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree*);
8216: SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *, int, void(*)(void *));
8217: SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *pBtree);
8218: SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock);
8219: SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *, int, int);
8220:
8221: SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *);
8222: SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *);
8223: SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *, Btree *);
8224:
8225: SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *);
8226:
8227: /* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR
8228: ** of the flags shown below.
8229: **
8230: ** Every SQLite table must have either BTREE_INTKEY or BTREE_BLOBKEY set.
8231: ** With BTREE_INTKEY, the table key is a 64-bit integer and arbitrary data
8232: ** is stored in the leaves. (BTREE_INTKEY is used for SQL tables.) With
8233: ** BTREE_BLOBKEY, the key is an arbitrary BLOB and no content is stored
8234: ** anywhere - the key is the content. (BTREE_BLOBKEY is used for SQL
8235: ** indices.)
8236: */
8237: #define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */
8238: #define BTREE_BLOBKEY 2 /* Table has keys only - no data */
8239:
8240: SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree*, int, int*);
8241: SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree*, int, int*);
8242: SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree*, int);
8243:
8244: SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *pBtree, int idx, u32 *pValue);
8245: SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value);
8246:
8247: /*
8248: ** The second parameter to sqlite3BtreeGetMeta or sqlite3BtreeUpdateMeta
8249: ** should be one of the following values. The integer values are assigned
8250: ** to constants so that the offset of the corresponding field in an
8251: ** SQLite database header may be found using the following formula:
8252: **
8253: ** offset = 36 + (idx * 4)
8254: **
8255: ** For example, the free-page-count field is located at byte offset 36 of
8256: ** the database file header. The incr-vacuum-flag field is located at
8257: ** byte offset 64 (== 36+4*7).
8258: */
8259: #define BTREE_FREE_PAGE_COUNT 0
8260: #define BTREE_SCHEMA_VERSION 1
8261: #define BTREE_FILE_FORMAT 2
8262: #define BTREE_DEFAULT_CACHE_SIZE 3
8263: #define BTREE_LARGEST_ROOT_PAGE 4
8264: #define BTREE_TEXT_ENCODING 5
8265: #define BTREE_USER_VERSION 6
8266: #define BTREE_INCR_VACUUM 7
8267:
8268: SQLITE_PRIVATE int sqlite3BtreeCursor(
8269: Btree*, /* BTree containing table to open */
8270: int iTable, /* Index of root page */
8271: int wrFlag, /* 1 for writing. 0 for read-only */
8272: struct KeyInfo*, /* First argument to compare function */
8273: BtCursor *pCursor /* Space to write cursor structure */
8274: );
8275: SQLITE_PRIVATE int sqlite3BtreeCursorSize(void);
8276: SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor*);
8277:
8278: SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor*);
8279: SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
8280: BtCursor*,
8281: UnpackedRecord *pUnKey,
8282: i64 intKey,
8283: int bias,
8284: int *pRes
8285: );
8286: SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*, int*);
8287: SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*);
8288: SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
8289: const void *pData, int nData,
8290: int nZero, int bias, int seekResult);
8291: SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor*, int *pRes);
8292: SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor*, int *pRes);
8293: SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor*, int *pRes);
8294: SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor*);
8295: SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor*, int *pRes);
8296: SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor*, i64 *pSize);
8297: SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
8298: SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt);
8299: SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt);
8300: SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor*, u32 *pSize);
8301: SQLITE_PRIVATE int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*);
8302: SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor*, sqlite3_int64);
8303: SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor*);
8304:
8305: SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*);
8306: SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*);
8307:
8308: SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
8309: SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *);
8310: SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *);
8311:
8312: SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBt, int iVersion);
8313:
8314: #ifndef NDEBUG
8315: SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor*);
8316: #endif
8317:
8318: #ifndef SQLITE_OMIT_BTREECOUNT
8319: SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *, i64 *);
8320: #endif
8321:
8322: #ifdef SQLITE_TEST
8323: SQLITE_PRIVATE int sqlite3BtreeCursorInfo(BtCursor*, int*, int);
8324: SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*);
8325: #endif
8326:
8327: #ifndef SQLITE_OMIT_WAL
8328: SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree*, int, int *, int *);
8329: #endif
8330:
8331: /*
8332: ** If we are not using shared cache, then there is no need to
8333: ** use mutexes to access the BtShared structures. So make the
8334: ** Enter and Leave procedures no-ops.
8335: */
8336: #ifndef SQLITE_OMIT_SHARED_CACHE
8337: SQLITE_PRIVATE void sqlite3BtreeEnter(Btree*);
8338: SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3*);
8339: #else
8340: # define sqlite3BtreeEnter(X)
8341: # define sqlite3BtreeEnterAll(X)
8342: #endif
8343:
8344: #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE
8345: SQLITE_PRIVATE int sqlite3BtreeSharable(Btree*);
8346: SQLITE_PRIVATE void sqlite3BtreeLeave(Btree*);
8347: SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor*);
8348: SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor*);
8349: SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3*);
8350: #ifndef NDEBUG
8351: /* These routines are used inside assert() statements only. */
8352: SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree*);
8353: SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3*);
8354: SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3*,int,Schema*);
8355: #endif
8356: #else
8357:
8358: # define sqlite3BtreeSharable(X) 0
8359: # define sqlite3BtreeLeave(X)
8360: # define sqlite3BtreeEnterCursor(X)
8361: # define sqlite3BtreeLeaveCursor(X)
8362: # define sqlite3BtreeLeaveAll(X)
8363:
8364: # define sqlite3BtreeHoldsMutex(X) 1
8365: # define sqlite3BtreeHoldsAllMutexes(X) 1
8366: # define sqlite3SchemaMutexHeld(X,Y,Z) 1
8367: #endif
8368:
8369:
8370: #endif /* _BTREE_H_ */
8371:
8372: /************** End of btree.h ***********************************************/
8373: /************** Continuing where we left off in sqliteInt.h ******************/
8374: /************** Include vdbe.h in the middle of sqliteInt.h ******************/
8375: /************** Begin file vdbe.h ********************************************/
8376: /*
8377: ** 2001 September 15
8378: **
8379: ** The author disclaims copyright to this source code. In place of
8380: ** a legal notice, here is a blessing:
8381: **
8382: ** May you do good and not evil.
8383: ** May you find forgiveness for yourself and forgive others.
8384: ** May you share freely, never taking more than you give.
8385: **
8386: *************************************************************************
8387: ** Header file for the Virtual DataBase Engine (VDBE)
8388: **
8389: ** This header defines the interface to the virtual database engine
8390: ** or VDBE. The VDBE implements an abstract machine that runs a
8391: ** simple program to access and modify the underlying database.
8392: */
8393: #ifndef _SQLITE_VDBE_H_
8394: #define _SQLITE_VDBE_H_
8395: /* #include <stdio.h> */
8396:
8397: /*
8398: ** A single VDBE is an opaque structure named "Vdbe". Only routines
8399: ** in the source file sqliteVdbe.c are allowed to see the insides
8400: ** of this structure.
8401: */
8402: typedef struct Vdbe Vdbe;
8403:
8404: /*
8405: ** The names of the following types declared in vdbeInt.h are required
8406: ** for the VdbeOp definition.
8407: */
8408: typedef struct VdbeFunc VdbeFunc;
8409: typedef struct Mem Mem;
8410: typedef struct SubProgram SubProgram;
8411:
8412: /*
8413: ** A single instruction of the virtual machine has an opcode
8414: ** and as many as three operands. The instruction is recorded
8415: ** as an instance of the following structure:
8416: */
8417: struct VdbeOp {
8418: u8 opcode; /* What operation to perform */
8419: signed char p4type; /* One of the P4_xxx constants for p4 */
8420: u8 opflags; /* Mask of the OPFLG_* flags in opcodes.h */
8421: u8 p5; /* Fifth parameter is an unsigned character */
8422: int p1; /* First operand */
8423: int p2; /* Second parameter (often the jump destination) */
8424: int p3; /* The third parameter */
8425: union { /* fourth parameter */
8426: int i; /* Integer value if p4type==P4_INT32 */
8427: void *p; /* Generic pointer */
8428: char *z; /* Pointer to data for string (char array) types */
8429: i64 *pI64; /* Used when p4type is P4_INT64 */
8430: double *pReal; /* Used when p4type is P4_REAL */
8431: FuncDef *pFunc; /* Used when p4type is P4_FUNCDEF */
8432: VdbeFunc *pVdbeFunc; /* Used when p4type is P4_VDBEFUNC */
8433: CollSeq *pColl; /* Used when p4type is P4_COLLSEQ */
8434: Mem *pMem; /* Used when p4type is P4_MEM */
8435: VTable *pVtab; /* Used when p4type is P4_VTAB */
8436: KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */
8437: int *ai; /* Used when p4type is P4_INTARRAY */
8438: SubProgram *pProgram; /* Used when p4type is P4_SUBPROGRAM */
8439: int (*xAdvance)(BtCursor *, int *);
8440: } p4;
8441: #ifdef SQLITE_DEBUG
8442: char *zComment; /* Comment to improve readability */
8443: #endif
8444: #ifdef VDBE_PROFILE
8445: int cnt; /* Number of times this instruction was executed */
8446: u64 cycles; /* Total time spent executing this instruction */
8447: #endif
8448: };
8449: typedef struct VdbeOp VdbeOp;
8450:
8451:
8452: /*
8453: ** A sub-routine used to implement a trigger program.
8454: */
8455: struct SubProgram {
8456: VdbeOp *aOp; /* Array of opcodes for sub-program */
8457: int nOp; /* Elements in aOp[] */
8458: int nMem; /* Number of memory cells required */
8459: int nCsr; /* Number of cursors required */
8460: int nOnce; /* Number of OP_Once instructions */
8461: void *token; /* id that may be used to recursive triggers */
8462: SubProgram *pNext; /* Next sub-program already visited */
8463: };
8464:
8465: /*
8466: ** A smaller version of VdbeOp used for the VdbeAddOpList() function because
8467: ** it takes up less space.
8468: */
8469: struct VdbeOpList {
8470: u8 opcode; /* What operation to perform */
8471: signed char p1; /* First operand */
8472: signed char p2; /* Second parameter (often the jump destination) */
8473: signed char p3; /* Third parameter */
8474: };
8475: typedef struct VdbeOpList VdbeOpList;
8476:
8477: /*
8478: ** Allowed values of VdbeOp.p4type
8479: */
8480: #define P4_NOTUSED 0 /* The P4 parameter is not used */
8481: #define P4_DYNAMIC (-1) /* Pointer to a string obtained from sqliteMalloc() */
8482: #define P4_STATIC (-2) /* Pointer to a static string */
8483: #define P4_COLLSEQ (-4) /* P4 is a pointer to a CollSeq structure */
8484: #define P4_FUNCDEF (-5) /* P4 is a pointer to a FuncDef structure */
8485: #define P4_KEYINFO (-6) /* P4 is a pointer to a KeyInfo structure */
8486: #define P4_VDBEFUNC (-7) /* P4 is a pointer to a VdbeFunc structure */
8487: #define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */
8488: #define P4_TRANSIENT 0 /* P4 is a pointer to a transient string */
8489: #define P4_VTAB (-10) /* P4 is a pointer to an sqlite3_vtab structure */
8490: #define P4_MPRINTF (-11) /* P4 is a string obtained from sqlite3_mprintf() */
8491: #define P4_REAL (-12) /* P4 is a 64-bit floating point value */
8492: #define P4_INT64 (-13) /* P4 is a 64-bit signed integer */
8493: #define P4_INT32 (-14) /* P4 is a 32-bit signed integer */
8494: #define P4_INTARRAY (-15) /* P4 is a vector of 32-bit integers */
8495: #define P4_SUBPROGRAM (-18) /* P4 is a pointer to a SubProgram structure */
8496: #define P4_ADVANCE (-19) /* P4 is a pointer to BtreeNext() or BtreePrev() */
8497:
8498: /* When adding a P4 argument using P4_KEYINFO, a copy of the KeyInfo structure
8499: ** is made. That copy is freed when the Vdbe is finalized. But if the
8500: ** argument is P4_KEYINFO_HANDOFF, the passed in pointer is used. It still
8501: ** gets freed when the Vdbe is finalized so it still should be obtained
8502: ** from a single sqliteMalloc(). But no copy is made and the calling
8503: ** function should *not* try to free the KeyInfo.
8504: */
8505: #define P4_KEYINFO_HANDOFF (-16)
8506: #define P4_KEYINFO_STATIC (-17)
8507:
8508: /*
8509: ** The Vdbe.aColName array contains 5n Mem structures, where n is the
8510: ** number of columns of data returned by the statement.
8511: */
8512: #define COLNAME_NAME 0
8513: #define COLNAME_DECLTYPE 1
8514: #define COLNAME_DATABASE 2
8515: #define COLNAME_TABLE 3
8516: #define COLNAME_COLUMN 4
8517: #ifdef SQLITE_ENABLE_COLUMN_METADATA
8518: # define COLNAME_N 5 /* Number of COLNAME_xxx symbols */
8519: #else
8520: # ifdef SQLITE_OMIT_DECLTYPE
8521: # define COLNAME_N 1 /* Store only the name */
8522: # else
8523: # define COLNAME_N 2 /* Store the name and decltype */
8524: # endif
8525: #endif
8526:
8527: /*
8528: ** The following macro converts a relative address in the p2 field
8529: ** of a VdbeOp structure into a negative number so that
8530: ** sqlite3VdbeAddOpList() knows that the address is relative. Calling
8531: ** the macro again restores the address.
8532: */
8533: #define ADDR(X) (-1-(X))
8534:
8535: /*
8536: ** The makefile scans the vdbe.c source file and creates the "opcodes.h"
8537: ** header file that defines a number for each opcode used by the VDBE.
8538: */
8539: /************** Include opcodes.h in the middle of vdbe.h ********************/
8540: /************** Begin file opcodes.h *****************************************/
8541: /* Automatically generated. Do not edit */
8542: /* See the mkopcodeh.awk script for details */
8543: #define OP_Goto 1
8544: #define OP_Gosub 2
8545: #define OP_Return 3
8546: #define OP_Yield 4
8547: #define OP_HaltIfNull 5
8548: #define OP_Halt 6
8549: #define OP_Integer 7
8550: #define OP_Int64 8
8551: #define OP_Real 130 /* same as TK_FLOAT */
8552: #define OP_String8 94 /* same as TK_STRING */
8553: #define OP_String 9
8554: #define OP_Null 10
8555: #define OP_Blob 11
8556: #define OP_Variable 12
8557: #define OP_Move 13
8558: #define OP_Copy 14
8559: #define OP_SCopy 15
8560: #define OP_ResultRow 16
8561: #define OP_Concat 91 /* same as TK_CONCAT */
8562: #define OP_Add 86 /* same as TK_PLUS */
8563: #define OP_Subtract 87 /* same as TK_MINUS */
8564: #define OP_Multiply 88 /* same as TK_STAR */
8565: #define OP_Divide 89 /* same as TK_SLASH */
8566: #define OP_Remainder 90 /* same as TK_REM */
8567: #define OP_CollSeq 17
8568: #define OP_Function 18
8569: #define OP_BitAnd 82 /* same as TK_BITAND */
8570: #define OP_BitOr 83 /* same as TK_BITOR */
8571: #define OP_ShiftLeft 84 /* same as TK_LSHIFT */
8572: #define OP_ShiftRight 85 /* same as TK_RSHIFT */
8573: #define OP_AddImm 20
8574: #define OP_MustBeInt 21
8575: #define OP_RealAffinity 22
8576: #define OP_ToText 141 /* same as TK_TO_TEXT */
8577: #define OP_ToBlob 142 /* same as TK_TO_BLOB */
8578: #define OP_ToNumeric 143 /* same as TK_TO_NUMERIC*/
8579: #define OP_ToInt 144 /* same as TK_TO_INT */
8580: #define OP_ToReal 145 /* same as TK_TO_REAL */
8581: #define OP_Eq 76 /* same as TK_EQ */
8582: #define OP_Ne 75 /* same as TK_NE */
8583: #define OP_Lt 79 /* same as TK_LT */
8584: #define OP_Le 78 /* same as TK_LE */
8585: #define OP_Gt 77 /* same as TK_GT */
8586: #define OP_Ge 80 /* same as TK_GE */
8587: #define OP_Permutation 23
8588: #define OP_Compare 24
8589: #define OP_Jump 25
8590: #define OP_And 69 /* same as TK_AND */
8591: #define OP_Or 68 /* same as TK_OR */
8592: #define OP_Not 19 /* same as TK_NOT */
8593: #define OP_BitNot 93 /* same as TK_BITNOT */
8594: #define OP_Once 26
8595: #define OP_If 27
8596: #define OP_IfNot 28
8597: #define OP_IsNull 73 /* same as TK_ISNULL */
8598: #define OP_NotNull 74 /* same as TK_NOTNULL */
8599: #define OP_Column 29
8600: #define OP_Affinity 30
8601: #define OP_MakeRecord 31
8602: #define OP_Count 32
8603: #define OP_Savepoint 33
8604: #define OP_AutoCommit 34
8605: #define OP_Transaction 35
8606: #define OP_ReadCookie 36
8607: #define OP_SetCookie 37
8608: #define OP_VerifyCookie 38
8609: #define OP_OpenRead 39
8610: #define OP_OpenWrite 40
8611: #define OP_OpenAutoindex 41
8612: #define OP_OpenEphemeral 42
8613: #define OP_SorterOpen 43
8614: #define OP_OpenPseudo 44
8615: #define OP_Close 45
8616: #define OP_SeekLt 46
8617: #define OP_SeekLe 47
8618: #define OP_SeekGe 48
8619: #define OP_SeekGt 49
8620: #define OP_Seek 50
8621: #define OP_NotFound 51
8622: #define OP_Found 52
8623: #define OP_IsUnique 53
8624: #define OP_NotExists 54
8625: #define OP_Sequence 55
8626: #define OP_NewRowid 56
8627: #define OP_Insert 57
8628: #define OP_InsertInt 58
8629: #define OP_Delete 59
8630: #define OP_ResetCount 60
8631: #define OP_SorterCompare 61
8632: #define OP_SorterData 62
8633: #define OP_RowKey 63
8634: #define OP_RowData 64
8635: #define OP_Rowid 65
8636: #define OP_NullRow 66
8637: #define OP_Last 67
8638: #define OP_SorterSort 70
8639: #define OP_Sort 71
8640: #define OP_Rewind 72
8641: #define OP_SorterNext 81
8642: #define OP_Prev 92
8643: #define OP_Next 95
8644: #define OP_SorterInsert 96
8645: #define OP_IdxInsert 97
8646: #define OP_IdxDelete 98
8647: #define OP_IdxRowid 99
8648: #define OP_IdxLT 100
8649: #define OP_IdxGE 101
8650: #define OP_Destroy 102
8651: #define OP_Clear 103
8652: #define OP_CreateIndex 104
8653: #define OP_CreateTable 105
8654: #define OP_ParseSchema 106
8655: #define OP_LoadAnalysis 107
8656: #define OP_DropTable 108
8657: #define OP_DropIndex 109
8658: #define OP_DropTrigger 110
8659: #define OP_IntegrityCk 111
8660: #define OP_RowSetAdd 112
8661: #define OP_RowSetRead 113
8662: #define OP_RowSetTest 114
8663: #define OP_Program 115
8664: #define OP_Param 116
8665: #define OP_FkCounter 117
8666: #define OP_FkIfZero 118
8667: #define OP_MemMax 119
8668: #define OP_IfPos 120
8669: #define OP_IfNeg 121
8670: #define OP_IfZero 122
8671: #define OP_AggStep 123
8672: #define OP_AggFinal 124
8673: #define OP_Checkpoint 125
8674: #define OP_JournalMode 126
8675: #define OP_Vacuum 127
8676: #define OP_IncrVacuum 128
8677: #define OP_Expire 129
8678: #define OP_TableLock 131
8679: #define OP_VBegin 132
8680: #define OP_VCreate 133
8681: #define OP_VDestroy 134
8682: #define OP_VOpen 135
8683: #define OP_VFilter 136
8684: #define OP_VColumn 137
8685: #define OP_VNext 138
8686: #define OP_VRename 139
8687: #define OP_VUpdate 140
8688: #define OP_Pagecount 146
8689: #define OP_MaxPgcnt 147
8690: #define OP_Trace 148
8691: #define OP_Noop 149
8692: #define OP_Explain 150
8693:
8694:
8695: /* Properties such as "out2" or "jump" that are specified in
8696: ** comments following the "case" for each opcode in the vdbe.c
8697: ** are encoded into bitvectors as follows:
8698: */
8699: #define OPFLG_JUMP 0x0001 /* jump: P2 holds jmp target */
8700: #define OPFLG_OUT2_PRERELEASE 0x0002 /* out2-prerelease: */
8701: #define OPFLG_IN1 0x0004 /* in1: P1 is an input */
8702: #define OPFLG_IN2 0x0008 /* in2: P2 is an input */
8703: #define OPFLG_IN3 0x0010 /* in3: P3 is an input */
8704: #define OPFLG_OUT2 0x0020 /* out2: P2 is an output */
8705: #define OPFLG_OUT3 0x0040 /* out3: P3 is an output */
8706: #define OPFLG_INITIALIZER {\
8707: /* 0 */ 0x00, 0x01, 0x01, 0x04, 0x04, 0x10, 0x00, 0x02,\
8708: /* 8 */ 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x24, 0x24,\
8709: /* 16 */ 0x00, 0x00, 0x00, 0x24, 0x04, 0x05, 0x04, 0x00,\
8710: /* 24 */ 0x00, 0x01, 0x01, 0x05, 0x05, 0x00, 0x00, 0x00,\
8711: /* 32 */ 0x02, 0x00, 0x00, 0x00, 0x02, 0x10, 0x00, 0x00,\
8712: /* 40 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11,\
8713: /* 48 */ 0x11, 0x11, 0x08, 0x11, 0x11, 0x11, 0x11, 0x02,\
8714: /* 56 */ 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
8715: /* 64 */ 0x00, 0x02, 0x00, 0x01, 0x4c, 0x4c, 0x01, 0x01,\
8716: /* 72 */ 0x01, 0x05, 0x05, 0x15, 0x15, 0x15, 0x15, 0x15,\
8717: /* 80 */ 0x15, 0x01, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,\
8718: /* 88 */ 0x4c, 0x4c, 0x4c, 0x4c, 0x01, 0x24, 0x02, 0x01,\
8719: /* 96 */ 0x08, 0x08, 0x00, 0x02, 0x01, 0x01, 0x02, 0x00,\
8720: /* 104 */ 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
8721: /* 112 */ 0x0c, 0x45, 0x15, 0x01, 0x02, 0x00, 0x01, 0x08,\
8722: /* 120 */ 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x02, 0x00,\
8723: /* 128 */ 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,\
8724: /* 136 */ 0x01, 0x00, 0x01, 0x00, 0x00, 0x04, 0x04, 0x04,\
8725: /* 144 */ 0x04, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00,}
8726:
8727: /************** End of opcodes.h *********************************************/
8728: /************** Continuing where we left off in vdbe.h ***********************/
8729:
8730: /*
8731: ** Prototypes for the VDBE interface. See comments on the implementation
8732: ** for a description of what each of these routines does.
8733: */
8734: SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3*);
8735: SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int);
8736: SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int);
8737: SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int);
8738: SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int);
8739: SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int);
8740: SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int);
8741: SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp);
8742: SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*);
8743: SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1);
8744: SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);
8745: SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3);
8746: SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
8747: SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr);
8748: SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr);
8749: SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
8750: SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int);
8751: SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int);
8752: SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe*);
8753: SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*);
8754: SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*);
8755: SQLITE_PRIVATE void sqlite3VdbeDeleteObject(sqlite3*,Vdbe*);
8756: SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,Parse*);
8757: SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*);
8758: SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int);
8759: SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*);
8760: #ifdef SQLITE_DEBUG
8761: SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *, int);
8762: SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe*,FILE*);
8763: #endif
8764: SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*);
8765: SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe*);
8766: SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*);
8767: SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int);
8768: SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));
8769: SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*);
8770: SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*);
8771: SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int);
8772: SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*);
8773: SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*);
8774: SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe*, int, u8);
8775: SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int);
8776: #ifndef SQLITE_OMIT_TRACE
8777: SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*);
8778: #endif
8779:
8780: SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,UnpackedRecord*);
8781: SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*);
8782: SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(KeyInfo *, char *, int, char **);
8783:
8784: #ifndef SQLITE_OMIT_TRIGGER
8785: SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *);
8786: #endif
8787:
8788:
8789: #ifndef NDEBUG
8790: SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...);
8791: # define VdbeComment(X) sqlite3VdbeComment X
8792: SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...);
8793: # define VdbeNoopComment(X) sqlite3VdbeNoopComment X
8794: #else
8795: # define VdbeComment(X)
8796: # define VdbeNoopComment(X)
8797: #endif
8798:
8799: #endif
8800:
8801: /************** End of vdbe.h ************************************************/
8802: /************** Continuing where we left off in sqliteInt.h ******************/
8803: /************** Include pager.h in the middle of sqliteInt.h *****************/
8804: /************** Begin file pager.h *******************************************/
8805: /*
8806: ** 2001 September 15
8807: **
8808: ** The author disclaims copyright to this source code. In place of
8809: ** a legal notice, here is a blessing:
8810: **
8811: ** May you do good and not evil.
8812: ** May you find forgiveness for yourself and forgive others.
8813: ** May you share freely, never taking more than you give.
8814: **
8815: *************************************************************************
8816: ** This header file defines the interface that the sqlite page cache
8817: ** subsystem. The page cache subsystem reads and writes a file a page
8818: ** at a time and provides a journal for rollback.
8819: */
8820:
8821: #ifndef _PAGER_H_
8822: #define _PAGER_H_
8823:
8824: /*
8825: ** Default maximum size for persistent journal files. A negative
8826: ** value means no limit. This value may be overridden using the
8827: ** sqlite3PagerJournalSizeLimit() API. See also "PRAGMA journal_size_limit".
8828: */
8829: #ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT
8830: #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1
8831: #endif
8832:
8833: /*
8834: ** The type used to represent a page number. The first page in a file
8835: ** is called page 1. 0 is used to represent "not a page".
8836: */
8837: typedef u32 Pgno;
8838:
8839: /*
8840: ** Each open file is managed by a separate instance of the "Pager" structure.
8841: */
8842: typedef struct Pager Pager;
8843:
8844: /*
8845: ** Handle type for pages.
8846: */
8847: typedef struct PgHdr DbPage;
8848:
8849: /*
8850: ** Page number PAGER_MJ_PGNO is never used in an SQLite database (it is
8851: ** reserved for working around a windows/posix incompatibility). It is
8852: ** used in the journal to signify that the remainder of the journal file
8853: ** is devoted to storing a master journal name - there are no more pages to
8854: ** roll back. See comments for function writeMasterJournal() in pager.c
8855: ** for details.
8856: */
8857: #define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1))
8858:
8859: /*
8860: ** Allowed values for the flags parameter to sqlite3PagerOpen().
8861: **
8862: ** NOTE: These values must match the corresponding BTREE_ values in btree.h.
8863: */
8864: #define PAGER_OMIT_JOURNAL 0x0001 /* Do not use a rollback journal */
8865: #define PAGER_NO_READLOCK 0x0002 /* Omit readlocks on readonly files */
8866: #define PAGER_MEMORY 0x0004 /* In-memory database */
8867:
8868: /*
8869: ** Valid values for the second argument to sqlite3PagerLockingMode().
8870: */
8871: #define PAGER_LOCKINGMODE_QUERY -1
8872: #define PAGER_LOCKINGMODE_NORMAL 0
8873: #define PAGER_LOCKINGMODE_EXCLUSIVE 1
8874:
8875: /*
8876: ** Numeric constants that encode the journalmode.
8877: */
8878: #define PAGER_JOURNALMODE_QUERY (-1) /* Query the value of journalmode */
8879: #define PAGER_JOURNALMODE_DELETE 0 /* Commit by deleting journal file */
8880: #define PAGER_JOURNALMODE_PERSIST 1 /* Commit by zeroing journal header */
8881: #define PAGER_JOURNALMODE_OFF 2 /* Journal omitted. */
8882: #define PAGER_JOURNALMODE_TRUNCATE 3 /* Commit by truncating journal */
8883: #define PAGER_JOURNALMODE_MEMORY 4 /* In-memory journal file */
8884: #define PAGER_JOURNALMODE_WAL 5 /* Use write-ahead logging */
8885:
8886: /*
8887: ** The remainder of this file contains the declarations of the functions
8888: ** that make up the Pager sub-system API. See source code comments for
8889: ** a detailed description of each routine.
8890: */
8891:
8892: /* Open and close a Pager connection. */
8893: SQLITE_PRIVATE int sqlite3PagerOpen(
8894: sqlite3_vfs*,
8895: Pager **ppPager,
8896: const char*,
8897: int,
8898: int,
8899: int,
8900: void(*)(DbPage*)
8901: );
8902: SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager);
8903: SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager*, int, unsigned char*);
8904:
8905: /* Functions used to configure a Pager object. */
8906: SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(Pager*, int(*)(void *), void *);
8907: SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager*, u32*, int);
8908: SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager*, int);
8909: SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager*, int);
8910: SQLITE_PRIVATE void sqlite3PagerShrink(Pager*);
8911: SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(Pager*,int,int,int);
8912: SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *, int);
8913: SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *, int);
8914: SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager*);
8915: SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager*);
8916: SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64);
8917: SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager*);
8918:
8919: /* Functions used to obtain and release page references. */
8920: SQLITE_PRIVATE int sqlite3PagerAcquire(Pager *pPager, Pgno pgno, DbPage **ppPage, int clrFlag);
8921: #define sqlite3PagerGet(A,B,C) sqlite3PagerAcquire(A,B,C,0)
8922: SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
8923: SQLITE_PRIVATE void sqlite3PagerRef(DbPage*);
8924: SQLITE_PRIVATE void sqlite3PagerUnref(DbPage*);
8925:
8926: /* Operations on page references. */
8927: SQLITE_PRIVATE int sqlite3PagerWrite(DbPage*);
8928: SQLITE_PRIVATE void sqlite3PagerDontWrite(DbPage*);
8929: SQLITE_PRIVATE int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,int);
8930: SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage*);
8931: SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *);
8932: SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *);
8933:
8934: /* Functions used to manage pager transactions and savepoints. */
8935: SQLITE_PRIVATE void sqlite3PagerPagecount(Pager*, int*);
8936: SQLITE_PRIVATE int sqlite3PagerBegin(Pager*, int exFlag, int);
8937: SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(Pager*,const char *zMaster, int);
8938: SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager*);
8939: SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager);
8940: SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager*);
8941: SQLITE_PRIVATE int sqlite3PagerRollback(Pager*);
8942: SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int n);
8943: SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
8944: SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager);
8945:
8946: SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int, int*, int*);
8947: SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager);
8948: SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager);
8949: SQLITE_PRIVATE int sqlite3PagerOpenWal(Pager *pPager, int *pisOpen);
8950: SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager);
8951:
8952: /* Functions used to query pager state and configuration. */
8953: SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*);
8954: SQLITE_PRIVATE int sqlite3PagerRefcount(Pager*);
8955: SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager*);
8956: SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager*);
8957: SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager*);
8958: SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager*);
8959: SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager*);
8960: SQLITE_PRIVATE int sqlite3PagerNosync(Pager*);
8961: SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager*);
8962: SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager*);
8963: SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *, int, int, int *);
8964: SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *);
8965:
8966: /* Functions used to truncate the database file. */
8967: SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager*,Pgno);
8968:
8969: #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_WAL)
8970: SQLITE_PRIVATE void *sqlite3PagerCodec(DbPage *);
8971: #endif
8972:
8973: /* Functions to support testing and debugging. */
8974: #if !defined(NDEBUG) || defined(SQLITE_TEST)
8975: SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*);
8976: SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage*);
8977: #endif
8978: #ifdef SQLITE_TEST
8979: SQLITE_PRIVATE int *sqlite3PagerStats(Pager*);
8980: SQLITE_PRIVATE void sqlite3PagerRefdump(Pager*);
8981: void disable_simulated_io_errors(void);
8982: void enable_simulated_io_errors(void);
8983: #else
8984: # define disable_simulated_io_errors()
8985: # define enable_simulated_io_errors()
8986: #endif
8987:
8988: #endif /* _PAGER_H_ */
8989:
8990: /************** End of pager.h ***********************************************/
8991: /************** Continuing where we left off in sqliteInt.h ******************/
8992: /************** Include pcache.h in the middle of sqliteInt.h ****************/
8993: /************** Begin file pcache.h ******************************************/
8994: /*
8995: ** 2008 August 05
8996: **
8997: ** The author disclaims copyright to this source code. In place of
8998: ** a legal notice, here is a blessing:
8999: **
9000: ** May you do good and not evil.
9001: ** May you find forgiveness for yourself and forgive others.
9002: ** May you share freely, never taking more than you give.
9003: **
9004: *************************************************************************
9005: ** This header file defines the interface that the sqlite page cache
9006: ** subsystem.
9007: */
9008:
9009: #ifndef _PCACHE_H_
9010:
9011: typedef struct PgHdr PgHdr;
9012: typedef struct PCache PCache;
9013:
9014: /*
9015: ** Every page in the cache is controlled by an instance of the following
9016: ** structure.
9017: */
9018: struct PgHdr {
9019: sqlite3_pcache_page *pPage; /* Pcache object page handle */
9020: void *pData; /* Page data */
9021: void *pExtra; /* Extra content */
9022: PgHdr *pDirty; /* Transient list of dirty pages */
9023: Pgno pgno; /* Page number for this page */
9024: Pager *pPager; /* The pager this page is part of */
9025: #ifdef SQLITE_CHECK_PAGES
9026: u32 pageHash; /* Hash of page content */
9027: #endif
9028: u16 flags; /* PGHDR flags defined below */
9029:
9030: /**********************************************************************
9031: ** Elements above are public. All that follows is private to pcache.c
9032: ** and should not be accessed by other modules.
9033: */
9034: i16 nRef; /* Number of users of this page */
9035: PCache *pCache; /* Cache that owns this page */
9036:
9037: PgHdr *pDirtyNext; /* Next element in list of dirty pages */
9038: PgHdr *pDirtyPrev; /* Previous element in list of dirty pages */
9039: };
9040:
9041: /* Bit values for PgHdr.flags */
9042: #define PGHDR_DIRTY 0x002 /* Page has changed */
9043: #define PGHDR_NEED_SYNC 0x004 /* Fsync the rollback journal before
9044: ** writing this page to the database */
9045: #define PGHDR_NEED_READ 0x008 /* Content is unread */
9046: #define PGHDR_REUSE_UNLIKELY 0x010 /* A hint that reuse is unlikely */
9047: #define PGHDR_DONT_WRITE 0x020 /* Do not write content to disk */
9048:
9049: /* Initialize and shutdown the page cache subsystem */
9050: SQLITE_PRIVATE int sqlite3PcacheInitialize(void);
9051: SQLITE_PRIVATE void sqlite3PcacheShutdown(void);
9052:
9053: /* Page cache buffer management:
9054: ** These routines implement SQLITE_CONFIG_PAGECACHE.
9055: */
9056: SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *, int sz, int n);
9057:
9058: /* Create a new pager cache.
9059: ** Under memory stress, invoke xStress to try to make pages clean.
9060: ** Only clean and unpinned pages can be reclaimed.
9061: */
9062: SQLITE_PRIVATE void sqlite3PcacheOpen(
9063: int szPage, /* Size of every page */
9064: int szExtra, /* Extra space associated with each page */
9065: int bPurgeable, /* True if pages are on backing store */
9066: int (*xStress)(void*, PgHdr*), /* Call to try to make pages clean */
9067: void *pStress, /* Argument to xStress */
9068: PCache *pToInit /* Preallocated space for the PCache */
9069: );
9070:
9071: /* Modify the page-size after the cache has been created. */
9072: SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *, int);
9073:
9074: /* Return the size in bytes of a PCache object. Used to preallocate
9075: ** storage space.
9076: */
9077: SQLITE_PRIVATE int sqlite3PcacheSize(void);
9078:
9079: /* One release per successful fetch. Page is pinned until released.
9080: ** Reference counted.
9081: */
9082: SQLITE_PRIVATE int sqlite3PcacheFetch(PCache*, Pgno, int createFlag, PgHdr**);
9083: SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr*);
9084:
9085: SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr*); /* Remove page from cache */
9086: SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr*); /* Make sure page is marked dirty */
9087: SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr*); /* Mark a single page as clean */
9088: SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache*); /* Mark all dirty list pages as clean */
9089:
9090: /* Change a page number. Used by incr-vacuum. */
9091: SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr*, Pgno);
9092:
9093: /* Remove all pages with pgno>x. Reset the cache if x==0 */
9094: SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache*, Pgno x);
9095:
9096: /* Get a list of all dirty pages in the cache, sorted by page number */
9097: SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*);
9098:
9099: /* Reset and close the cache object */
9100: SQLITE_PRIVATE void sqlite3PcacheClose(PCache*);
9101:
9102: /* Clear flags from pages of the page cache */
9103: SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *);
9104:
9105: /* Discard the contents of the cache */
9106: SQLITE_PRIVATE void sqlite3PcacheClear(PCache*);
9107:
9108: /* Return the total number of outstanding page references */
9109: SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache*);
9110:
9111: /* Increment the reference count of an existing page */
9112: SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr*);
9113:
9114: SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr*);
9115:
9116: /* Return the total number of pages stored in the cache */
9117: SQLITE_PRIVATE int sqlite3PcachePagecount(PCache*);
9118:
9119: #if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG)
9120: /* Iterate through all dirty pages currently stored in the cache. This
9121: ** interface is only available if SQLITE_CHECK_PAGES is defined when the
9122: ** library is built.
9123: */
9124: SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *));
9125: #endif
9126:
9127: /* Set and get the suggested cache-size for the specified pager-cache.
9128: **
9129: ** If no global maximum is configured, then the system attempts to limit
9130: ** the total number of pages cached by purgeable pager-caches to the sum
9131: ** of the suggested cache-sizes.
9132: */
9133: SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *, int);
9134: #ifdef SQLITE_TEST
9135: SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *);
9136: #endif
9137:
9138: /* Free up as much memory as possible from the page cache */
9139: SQLITE_PRIVATE void sqlite3PcacheShrink(PCache*);
9140:
9141: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
9142: /* Try to return memory used by the pcache module to the main memory heap */
9143: SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int);
9144: #endif
9145:
9146: #ifdef SQLITE_TEST
9147: SQLITE_PRIVATE void sqlite3PcacheStats(int*,int*,int*,int*);
9148: #endif
9149:
9150: SQLITE_PRIVATE void sqlite3PCacheSetDefault(void);
9151:
9152: #endif /* _PCACHE_H_ */
9153:
9154: /************** End of pcache.h **********************************************/
9155: /************** Continuing where we left off in sqliteInt.h ******************/
9156:
9157: /************** Include os.h in the middle of sqliteInt.h ********************/
9158: /************** Begin file os.h **********************************************/
9159: /*
9160: ** 2001 September 16
9161: **
9162: ** The author disclaims copyright to this source code. In place of
9163: ** a legal notice, here is a blessing:
9164: **
9165: ** May you do good and not evil.
9166: ** May you find forgiveness for yourself and forgive others.
9167: ** May you share freely, never taking more than you give.
9168: **
9169: ******************************************************************************
9170: **
9171: ** This header file (together with is companion C source-code file
9172: ** "os.c") attempt to abstract the underlying operating system so that
9173: ** the SQLite library will work on both POSIX and windows systems.
9174: **
9175: ** This header file is #include-ed by sqliteInt.h and thus ends up
9176: ** being included by every source file.
9177: */
9178: #ifndef _SQLITE_OS_H_
9179: #define _SQLITE_OS_H_
9180:
9181: /*
9182: ** Figure out if we are dealing with Unix, Windows, or some other
9183: ** operating system. After the following block of preprocess macros,
9184: ** all of SQLITE_OS_UNIX, SQLITE_OS_WIN, SQLITE_OS_OS2, and SQLITE_OS_OTHER
9185: ** will defined to either 1 or 0. One of the four will be 1. The other
9186: ** three will be 0.
9187: */
9188: #if defined(SQLITE_OS_OTHER)
9189: # if SQLITE_OS_OTHER==1
9190: # undef SQLITE_OS_UNIX
9191: # define SQLITE_OS_UNIX 0
9192: # undef SQLITE_OS_WIN
9193: # define SQLITE_OS_WIN 0
9194: # undef SQLITE_OS_OS2
9195: # define SQLITE_OS_OS2 0
9196: # else
9197: # undef SQLITE_OS_OTHER
9198: # endif
9199: #endif
9200: #if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER)
9201: # define SQLITE_OS_OTHER 0
9202: # ifndef SQLITE_OS_WIN
9203: # if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__)
9204: # define SQLITE_OS_WIN 1
9205: # define SQLITE_OS_UNIX 0
9206: # define SQLITE_OS_OS2 0
9207: # elif defined(__EMX__) || defined(_OS2) || defined(OS2) || defined(_OS2_) || defined(__OS2__)
9208: # define SQLITE_OS_WIN 0
9209: # define SQLITE_OS_UNIX 0
9210: # define SQLITE_OS_OS2 1
9211: # else
9212: # define SQLITE_OS_WIN 0
9213: # define SQLITE_OS_UNIX 1
9214: # define SQLITE_OS_OS2 0
9215: # endif
9216: # else
9217: # define SQLITE_OS_UNIX 0
9218: # define SQLITE_OS_OS2 0
9219: # endif
9220: #else
9221: # ifndef SQLITE_OS_WIN
9222: # define SQLITE_OS_WIN 0
9223: # endif
9224: #endif
9225:
9226: /*
9227: ** Define the maximum size of a temporary filename
9228: */
9229: #if SQLITE_OS_WIN
9230: # include <windows.h>
9231: # define SQLITE_TEMPNAME_SIZE (MAX_PATH+50)
9232: #elif SQLITE_OS_OS2
9233: # if (__GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3) && defined(OS2_HIGH_MEMORY)
9234: # include <os2safe.h> /* has to be included before os2.h for linking to work */
9235: # endif
9236: # define INCL_DOSDATETIME
9237: # define INCL_DOSFILEMGR
9238: # define INCL_DOSERRORS
9239: # define INCL_DOSMISC
9240: # define INCL_DOSPROCESS
9241: # define INCL_DOSMODULEMGR
9242: # define INCL_DOSSEMAPHORES
9243: # include <os2.h>
9244: # include <uconv.h>
9245: # define SQLITE_TEMPNAME_SIZE (CCHMAXPATHCOMP)
9246: #else
9247: # define SQLITE_TEMPNAME_SIZE 200
9248: #endif
9249:
9250: /*
9251: ** Determine if we are dealing with Windows NT.
9252: */
9253: #if defined(_WIN32_WINNT)
9254: # define SQLITE_OS_WINNT 1
9255: #else
9256: # define SQLITE_OS_WINNT 0
9257: #endif
9258:
9259: /*
9260: ** Determine if we are dealing with WindowsCE - which has a much
9261: ** reduced API.
9262: */
9263: #if defined(_WIN32_WCE)
9264: # define SQLITE_OS_WINCE 1
9265: #else
9266: # define SQLITE_OS_WINCE 0
9267: #endif
9268:
9269: /* If the SET_FULLSYNC macro is not defined above, then make it
9270: ** a no-op
9271: */
9272: #ifndef SET_FULLSYNC
9273: # define SET_FULLSYNC(x,y)
9274: #endif
9275:
9276: /*
9277: ** The default size of a disk sector
9278: */
9279: #ifndef SQLITE_DEFAULT_SECTOR_SIZE
9280: # define SQLITE_DEFAULT_SECTOR_SIZE 4096
9281: #endif
9282:
9283: /*
9284: ** Temporary files are named starting with this prefix followed by 16 random
9285: ** alphanumeric characters, and no file extension. They are stored in the
9286: ** OS's standard temporary file directory, and are deleted prior to exit.
9287: ** If sqlite is being embedded in another program, you may wish to change the
9288: ** prefix to reflect your program's name, so that if your program exits
9289: ** prematurely, old temporary files can be easily identified. This can be done
9290: ** using -DSQLITE_TEMP_FILE_PREFIX=myprefix_ on the compiler command line.
9291: **
9292: ** 2006-10-31: The default prefix used to be "sqlite_". But then
9293: ** Mcafee started using SQLite in their anti-virus product and it
9294: ** started putting files with the "sqlite" name in the c:/temp folder.
9295: ** This annoyed many windows users. Those users would then do a
9296: ** Google search for "sqlite", find the telephone numbers of the
9297: ** developers and call to wake them up at night and complain.
9298: ** For this reason, the default name prefix is changed to be "sqlite"
9299: ** spelled backwards. So the temp files are still identified, but
9300: ** anybody smart enough to figure out the code is also likely smart
9301: ** enough to know that calling the developer will not help get rid
9302: ** of the file.
9303: */
9304: #ifndef SQLITE_TEMP_FILE_PREFIX
9305: # define SQLITE_TEMP_FILE_PREFIX "etilqs_"
9306: #endif
9307:
9308: /*
9309: ** The following values may be passed as the second argument to
9310: ** sqlite3OsLock(). The various locks exhibit the following semantics:
9311: **
9312: ** SHARED: Any number of processes may hold a SHARED lock simultaneously.
9313: ** RESERVED: A single process may hold a RESERVED lock on a file at
9314: ** any time. Other processes may hold and obtain new SHARED locks.
9315: ** PENDING: A single process may hold a PENDING lock on a file at
9316: ** any one time. Existing SHARED locks may persist, but no new
9317: ** SHARED locks may be obtained by other processes.
9318: ** EXCLUSIVE: An EXCLUSIVE lock precludes all other locks.
9319: **
9320: ** PENDING_LOCK may not be passed directly to sqlite3OsLock(). Instead, a
9321: ** process that requests an EXCLUSIVE lock may actually obtain a PENDING
9322: ** lock. This can be upgraded to an EXCLUSIVE lock by a subsequent call to
9323: ** sqlite3OsLock().
9324: */
9325: #define NO_LOCK 0
9326: #define SHARED_LOCK 1
9327: #define RESERVED_LOCK 2
9328: #define PENDING_LOCK 3
9329: #define EXCLUSIVE_LOCK 4
9330:
9331: /*
9332: ** File Locking Notes: (Mostly about windows but also some info for Unix)
9333: **
9334: ** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because
9335: ** those functions are not available. So we use only LockFile() and
9336: ** UnlockFile().
9337: **
9338: ** LockFile() prevents not just writing but also reading by other processes.
9339: ** A SHARED_LOCK is obtained by locking a single randomly-chosen
9340: ** byte out of a specific range of bytes. The lock byte is obtained at
9341: ** random so two separate readers can probably access the file at the
9342: ** same time, unless they are unlucky and choose the same lock byte.
9343: ** An EXCLUSIVE_LOCK is obtained by locking all bytes in the range.
9344: ** There can only be one writer. A RESERVED_LOCK is obtained by locking
9345: ** a single byte of the file that is designated as the reserved lock byte.
9346: ** A PENDING_LOCK is obtained by locking a designated byte different from
9347: ** the RESERVED_LOCK byte.
9348: **
9349: ** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available,
9350: ** which means we can use reader/writer locks. When reader/writer locks
9351: ** are used, the lock is placed on the same range of bytes that is used
9352: ** for probabilistic locking in Win95/98/ME. Hence, the locking scheme
9353: ** will support two or more Win95 readers or two or more WinNT readers.
9354: ** But a single Win95 reader will lock out all WinNT readers and a single
9355: ** WinNT reader will lock out all other Win95 readers.
9356: **
9357: ** The following #defines specify the range of bytes used for locking.
9358: ** SHARED_SIZE is the number of bytes available in the pool from which
9359: ** a random byte is selected for a shared lock. The pool of bytes for
9360: ** shared locks begins at SHARED_FIRST.
9361: **
9362: ** The same locking strategy and
9363: ** byte ranges are used for Unix. This leaves open the possiblity of having
9364: ** clients on win95, winNT, and unix all talking to the same shared file
9365: ** and all locking correctly. To do so would require that samba (or whatever
9366: ** tool is being used for file sharing) implements locks correctly between
9367: ** windows and unix. I'm guessing that isn't likely to happen, but by
9368: ** using the same locking range we are at least open to the possibility.
9369: **
9370: ** Locking in windows is manditory. For this reason, we cannot store
9371: ** actual data in the bytes used for locking. The pager never allocates
9372: ** the pages involved in locking therefore. SHARED_SIZE is selected so
9373: ** that all locks will fit on a single page even at the minimum page size.
9374: ** PENDING_BYTE defines the beginning of the locks. By default PENDING_BYTE
9375: ** is set high so that we don't have to allocate an unused page except
9376: ** for very large databases. But one should test the page skipping logic
9377: ** by setting PENDING_BYTE low and running the entire regression suite.
9378: **
9379: ** Changing the value of PENDING_BYTE results in a subtly incompatible
9380: ** file format. Depending on how it is changed, you might not notice
9381: ** the incompatibility right away, even running a full regression test.
9382: ** The default location of PENDING_BYTE is the first byte past the
9383: ** 1GB boundary.
9384: **
9385: */
9386: #ifdef SQLITE_OMIT_WSD
9387: # define PENDING_BYTE (0x40000000)
9388: #else
9389: # define PENDING_BYTE sqlite3PendingByte
9390: #endif
9391: #define RESERVED_BYTE (PENDING_BYTE+1)
9392: #define SHARED_FIRST (PENDING_BYTE+2)
9393: #define SHARED_SIZE 510
9394:
9395: /*
9396: ** Wrapper around OS specific sqlite3_os_init() function.
9397: */
9398: SQLITE_PRIVATE int sqlite3OsInit(void);
9399:
9400: /*
9401: ** Functions for accessing sqlite3_file methods
9402: */
9403: SQLITE_PRIVATE int sqlite3OsClose(sqlite3_file*);
9404: SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset);
9405: SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset);
9406: SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file*, i64 size);
9407: SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file*, int);
9408: SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file*, i64 *pSize);
9409: SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file*, int);
9410: SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file*, int);
9411: SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut);
9412: SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file*,int,void*);
9413: SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file*,int,void*);
9414: #define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0
9415: SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id);
9416: SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id);
9417: SQLITE_PRIVATE int sqlite3OsShmMap(sqlite3_file *,int,int,int,void volatile **);
9418: SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int, int, int);
9419: SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id);
9420: SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int);
9421:
9422:
9423: /*
9424: ** Functions for accessing sqlite3_vfs methods
9425: */
9426: SQLITE_PRIVATE int sqlite3OsOpen(sqlite3_vfs *, const char *, sqlite3_file*, int, int *);
9427: SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *, const char *, int);
9428: SQLITE_PRIVATE int sqlite3OsAccess(sqlite3_vfs *, const char *, int, int *pResOut);
9429: SQLITE_PRIVATE int sqlite3OsFullPathname(sqlite3_vfs *, const char *, int, char *);
9430: #ifndef SQLITE_OMIT_LOAD_EXTENSION
9431: SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *, const char *);
9432: SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *, int, char *);
9433: SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *, void *, const char *))(void);
9434: SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *, void *);
9435: #endif /* SQLITE_OMIT_LOAD_EXTENSION */
9436: SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *, int, char *);
9437: SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *, int);
9438: SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *, sqlite3_int64*);
9439:
9440: /*
9441: ** Convenience functions for opening and closing files using
9442: ** sqlite3_malloc() to obtain space for the file-handle structure.
9443: */
9444: SQLITE_PRIVATE int sqlite3OsOpenMalloc(sqlite3_vfs *, const char *, sqlite3_file **, int,int*);
9445: SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *);
9446:
9447: #endif /* _SQLITE_OS_H_ */
9448:
9449: /************** End of os.h **************************************************/
9450: /************** Continuing where we left off in sqliteInt.h ******************/
9451: /************** Include mutex.h in the middle of sqliteInt.h *****************/
9452: /************** Begin file mutex.h *******************************************/
9453: /*
9454: ** 2007 August 28
9455: **
9456: ** The author disclaims copyright to this source code. In place of
9457: ** a legal notice, here is a blessing:
9458: **
9459: ** May you do good and not evil.
9460: ** May you find forgiveness for yourself and forgive others.
9461: ** May you share freely, never taking more than you give.
9462: **
9463: *************************************************************************
9464: **
9465: ** This file contains the common header for all mutex implementations.
9466: ** The sqliteInt.h header #includes this file so that it is available
9467: ** to all source files. We break it out in an effort to keep the code
9468: ** better organized.
9469: **
9470: ** NOTE: source files should *not* #include this header file directly.
9471: ** Source files should #include the sqliteInt.h file and let that file
9472: ** include this one indirectly.
9473: */
9474:
9475:
9476: /*
9477: ** Figure out what version of the code to use. The choices are
9478: **
9479: ** SQLITE_MUTEX_OMIT No mutex logic. Not even stubs. The
9480: ** mutexes implemention cannot be overridden
9481: ** at start-time.
9482: **
9483: ** SQLITE_MUTEX_NOOP For single-threaded applications. No
9484: ** mutual exclusion is provided. But this
9485: ** implementation can be overridden at
9486: ** start-time.
9487: **
9488: ** SQLITE_MUTEX_PTHREADS For multi-threaded applications on Unix.
9489: **
9490: ** SQLITE_MUTEX_W32 For multi-threaded applications on Win32.
9491: **
9492: ** SQLITE_MUTEX_OS2 For multi-threaded applications on OS/2.
9493: */
9494: #if !SQLITE_THREADSAFE
9495: # define SQLITE_MUTEX_OMIT
9496: #endif
9497: #if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP)
9498: # if SQLITE_OS_UNIX
9499: # define SQLITE_MUTEX_PTHREADS
9500: # elif SQLITE_OS_WIN
9501: # define SQLITE_MUTEX_W32
9502: # elif SQLITE_OS_OS2
9503: # define SQLITE_MUTEX_OS2
9504: # else
9505: # define SQLITE_MUTEX_NOOP
9506: # endif
9507: #endif
9508:
9509: #ifdef SQLITE_MUTEX_OMIT
9510: /*
9511: ** If this is a no-op implementation, implement everything as macros.
9512: */
9513: #define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8)
9514: #define sqlite3_mutex_free(X)
9515: #define sqlite3_mutex_enter(X)
9516: #define sqlite3_mutex_try(X) SQLITE_OK
9517: #define sqlite3_mutex_leave(X)
9518: #define sqlite3_mutex_held(X) ((void)(X),1)
9519: #define sqlite3_mutex_notheld(X) ((void)(X),1)
9520: #define sqlite3MutexAlloc(X) ((sqlite3_mutex*)8)
9521: #define sqlite3MutexInit() SQLITE_OK
9522: #define sqlite3MutexEnd()
9523: #define MUTEX_LOGIC(X)
9524: #else
9525: #define MUTEX_LOGIC(X) X
9526: #endif /* defined(SQLITE_MUTEX_OMIT) */
9527:
9528: /************** End of mutex.h ***********************************************/
9529: /************** Continuing where we left off in sqliteInt.h ******************/
9530:
9531:
9532: /*
9533: ** Each database file to be accessed by the system is an instance
9534: ** of the following structure. There are normally two of these structures
9535: ** in the sqlite.aDb[] array. aDb[0] is the main database file and
9536: ** aDb[1] is the database file used to hold temporary tables. Additional
9537: ** databases may be attached.
9538: */
9539: struct Db {
9540: char *zName; /* Name of this database */
9541: Btree *pBt; /* The B*Tree structure for this database file */
9542: u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */
9543: u8 safety_level; /* How aggressive at syncing data to disk */
9544: Schema *pSchema; /* Pointer to database schema (possibly shared) */
9545: };
9546:
9547: /*
9548: ** An instance of the following structure stores a database schema.
9549: **
9550: ** Most Schema objects are associated with a Btree. The exception is
9551: ** the Schema for the TEMP databaes (sqlite3.aDb[1]) which is free-standing.
9552: ** In shared cache mode, a single Schema object can be shared by multiple
9553: ** Btrees that refer to the same underlying BtShared object.
9554: **
9555: ** Schema objects are automatically deallocated when the last Btree that
9556: ** references them is destroyed. The TEMP Schema is manually freed by
9557: ** sqlite3_close().
9558: *
9559: ** A thread must be holding a mutex on the corresponding Btree in order
9560: ** to access Schema content. This implies that the thread must also be
9561: ** holding a mutex on the sqlite3 connection pointer that owns the Btree.
9562: ** For a TEMP Schema, only the connection mutex is required.
9563: */
9564: struct Schema {
9565: int schema_cookie; /* Database schema version number for this file */
9566: int iGeneration; /* Generation counter. Incremented with each change */
9567: Hash tblHash; /* All tables indexed by name */
9568: Hash idxHash; /* All (named) indices indexed by name */
9569: Hash trigHash; /* All triggers indexed by name */
9570: Hash fkeyHash; /* All foreign keys by referenced table name */
9571: Table *pSeqTab; /* The sqlite_sequence table used by AUTOINCREMENT */
9572: u8 file_format; /* Schema format version for this file */
9573: u8 enc; /* Text encoding used by this database */
9574: u16 flags; /* Flags associated with this schema */
9575: int cache_size; /* Number of pages to use in the cache */
9576: };
9577:
9578: /*
9579: ** These macros can be used to test, set, or clear bits in the
9580: ** Db.pSchema->flags field.
9581: */
9582: #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))==(P))
9583: #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->flags&(P))!=0)
9584: #define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->flags|=(P)
9585: #define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->flags&=~(P)
9586:
9587: /*
9588: ** Allowed values for the DB.pSchema->flags field.
9589: **
9590: ** The DB_SchemaLoaded flag is set after the database schema has been
9591: ** read into internal hash tables.
9592: **
9593: ** DB_UnresetViews means that one or more views have column names that
9594: ** have been filled out. If the schema changes, these column names might
9595: ** changes and so the view will need to be reset.
9596: */
9597: #define DB_SchemaLoaded 0x0001 /* The schema has been loaded */
9598: #define DB_UnresetViews 0x0002 /* Some views have defined column names */
9599: #define DB_Empty 0x0004 /* The file is empty (length 0 bytes) */
9600:
9601: /*
9602: ** The number of different kinds of things that can be limited
9603: ** using the sqlite3_limit() interface.
9604: */
9605: #define SQLITE_N_LIMIT (SQLITE_LIMIT_TRIGGER_DEPTH+1)
9606:
9607: /*
9608: ** Lookaside malloc is a set of fixed-size buffers that can be used
9609: ** to satisfy small transient memory allocation requests for objects
9610: ** associated with a particular database connection. The use of
9611: ** lookaside malloc provides a significant performance enhancement
9612: ** (approx 10%) by avoiding numerous malloc/free requests while parsing
9613: ** SQL statements.
9614: **
9615: ** The Lookaside structure holds configuration information about the
9616: ** lookaside malloc subsystem. Each available memory allocation in
9617: ** the lookaside subsystem is stored on a linked list of LookasideSlot
9618: ** objects.
9619: **
9620: ** Lookaside allocations are only allowed for objects that are associated
9621: ** with a particular database connection. Hence, schema information cannot
9622: ** be stored in lookaside because in shared cache mode the schema information
9623: ** is shared by multiple database connections. Therefore, while parsing
9624: ** schema information, the Lookaside.bEnabled flag is cleared so that
9625: ** lookaside allocations are not used to construct the schema objects.
9626: */
9627: struct Lookaside {
9628: u16 sz; /* Size of each buffer in bytes */
9629: u8 bEnabled; /* False to disable new lookaside allocations */
9630: u8 bMalloced; /* True if pStart obtained from sqlite3_malloc() */
9631: int nOut; /* Number of buffers currently checked out */
9632: int mxOut; /* Highwater mark for nOut */
9633: int anStat[3]; /* 0: hits. 1: size misses. 2: full misses */
9634: LookasideSlot *pFree; /* List of available buffers */
9635: void *pStart; /* First byte of available memory space */
9636: void *pEnd; /* First byte past end of available space */
9637: };
9638: struct LookasideSlot {
9639: LookasideSlot *pNext; /* Next buffer in the list of free buffers */
9640: };
9641:
9642: /*
9643: ** A hash table for function definitions.
9644: **
9645: ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
9646: ** Collisions are on the FuncDef.pHash chain.
9647: */
9648: struct FuncDefHash {
9649: FuncDef *a[23]; /* Hash table for functions */
9650: };
9651:
9652: /*
9653: ** Each database connection is an instance of the following structure.
9654: **
9655: ** The sqlite.lastRowid records the last insert rowid generated by an
9656: ** insert statement. Inserts on views do not affect its value. Each
9657: ** trigger has its own context, so that lastRowid can be updated inside
9658: ** triggers as usual. The previous value will be restored once the trigger
9659: ** exits. Upon entering a before or instead of trigger, lastRowid is no
9660: ** longer (since after version 2.8.12) reset to -1.
9661: **
9662: ** The sqlite.nChange does not count changes within triggers and keeps no
9663: ** context. It is reset at start of sqlite3_exec.
9664: ** The sqlite.lsChange represents the number of changes made by the last
9665: ** insert, update, or delete statement. It remains constant throughout the
9666: ** length of a statement and is then updated by OP_SetCounts. It keeps a
9667: ** context stack just like lastRowid so that the count of changes
9668: ** within a trigger is not seen outside the trigger. Changes to views do not
9669: ** affect the value of lsChange.
9670: ** The sqlite.csChange keeps track of the number of current changes (since
9671: ** the last statement) and is used to update sqlite_lsChange.
9672: **
9673: ** The member variables sqlite.errCode, sqlite.zErrMsg and sqlite.zErrMsg16
9674: ** store the most recent error code and, if applicable, string. The
9675: ** internal function sqlite3Error() is used to set these variables
9676: ** consistently.
9677: */
9678: struct sqlite3 {
9679: sqlite3_vfs *pVfs; /* OS Interface */
9680: int nDb; /* Number of backends currently in use */
9681: Db *aDb; /* All backends */
9682: int flags; /* Miscellaneous flags. See below */
9683: unsigned int openFlags; /* Flags passed to sqlite3_vfs.xOpen() */
9684: int errCode; /* Most recent error code (SQLITE_*) */
9685: int errMask; /* & result codes with this before returning */
9686: u8 autoCommit; /* The auto-commit flag. */
9687: u8 temp_store; /* 1: file 2: memory 0: default */
9688: u8 mallocFailed; /* True if we have seen a malloc failure */
9689: u8 dfltLockMode; /* Default locking-mode for attached dbs */
9690: signed char nextAutovac; /* Autovac setting after VACUUM if >=0 */
9691: u8 suppressErr; /* Do not issue error messages if true */
9692: u8 vtabOnConflict; /* Value to return for s3_vtab_on_conflict() */
9693: int nextPagesize; /* Pagesize after VACUUM if >0 */
9694: int nTable; /* Number of tables in the database */
9695: CollSeq *pDfltColl; /* The default collating sequence (BINARY) */
9696: i64 lastRowid; /* ROWID of most recent insert (see above) */
9697: u32 magic; /* Magic number for detect library misuse */
9698: int nChange; /* Value returned by sqlite3_changes() */
9699: int nTotalChange; /* Value returned by sqlite3_total_changes() */
9700: sqlite3_mutex *mutex; /* Connection mutex */
9701: int aLimit[SQLITE_N_LIMIT]; /* Limits */
9702: struct sqlite3InitInfo { /* Information used during initialization */
9703: int iDb; /* When back is being initialized */
9704: int newTnum; /* Rootpage of table being initialized */
9705: u8 busy; /* TRUE if currently initializing */
9706: u8 orphanTrigger; /* Last statement is orphaned TEMP trigger */
9707: } init;
9708: int nExtension; /* Number of loaded extensions */
9709: void **aExtension; /* Array of shared library handles */
9710: struct Vdbe *pVdbe; /* List of active virtual machines */
9711: int activeVdbeCnt; /* Number of VDBEs currently executing */
9712: int writeVdbeCnt; /* Number of active VDBEs that are writing */
9713: int vdbeExecCnt; /* Number of nested calls to VdbeExec() */
9714: void (*xTrace)(void*,const char*); /* Trace function */
9715: void *pTraceArg; /* Argument to the trace function */
9716: void (*xProfile)(void*,const char*,u64); /* Profiling function */
9717: void *pProfileArg; /* Argument to profile function */
9718: void *pCommitArg; /* Argument to xCommitCallback() */
9719: int (*xCommitCallback)(void*); /* Invoked at every commit. */
9720: void *pRollbackArg; /* Argument to xRollbackCallback() */
9721: void (*xRollbackCallback)(void*); /* Invoked at every commit. */
9722: void *pUpdateArg;
9723: void (*xUpdateCallback)(void*,int, const char*,const char*,sqlite_int64);
9724: #ifndef SQLITE_OMIT_WAL
9725: int (*xWalCallback)(void *, sqlite3 *, const char *, int);
9726: void *pWalArg;
9727: #endif
9728: void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*);
9729: void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*);
9730: void *pCollNeededArg;
9731: sqlite3_value *pErr; /* Most recent error message */
9732: char *zErrMsg; /* Most recent error message (UTF-8 encoded) */
9733: char *zErrMsg16; /* Most recent error message (UTF-16 encoded) */
9734: union {
9735: volatile int isInterrupted; /* True if sqlite3_interrupt has been called */
9736: double notUsed1; /* Spacer */
9737: } u1;
9738: Lookaside lookaside; /* Lookaside malloc configuration */
9739: #ifndef SQLITE_OMIT_AUTHORIZATION
9740: int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
9741: /* Access authorization function */
9742: void *pAuthArg; /* 1st argument to the access auth function */
9743: #endif
9744: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
9745: int (*xProgress)(void *); /* The progress callback */
9746: void *pProgressArg; /* Argument to the progress callback */
9747: int nProgressOps; /* Number of opcodes for progress callback */
9748: #endif
9749: #ifndef SQLITE_OMIT_VIRTUALTABLE
9750: Hash aModule; /* populated by sqlite3_create_module() */
9751: VtabCtx *pVtabCtx; /* Context for active vtab connect/create */
9752: VTable **aVTrans; /* Virtual tables with open transactions */
9753: int nVTrans; /* Allocated size of aVTrans */
9754: VTable *pDisconnect; /* Disconnect these in next sqlite3_prepare() */
9755: #endif
9756: FuncDefHash aFunc; /* Hash table of connection functions */
9757: Hash aCollSeq; /* All collating sequences */
9758: BusyHandler busyHandler; /* Busy callback */
9759: int busyTimeout; /* Busy handler timeout, in msec */
9760: Db aDbStatic[2]; /* Static space for the 2 default backends */
9761: Savepoint *pSavepoint; /* List of active savepoints */
9762: int nSavepoint; /* Number of non-transaction savepoints */
9763: int nStatement; /* Number of nested statement-transactions */
9764: u8 isTransactionSavepoint; /* True if the outermost savepoint is a TS */
9765: i64 nDeferredCons; /* Net deferred constraints this transaction. */
9766: int *pnBytesFreed; /* If not NULL, increment this in DbFree() */
9767:
9768: #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
9769: /* The following variables are all protected by the STATIC_MASTER
9770: ** mutex, not by sqlite3.mutex. They are used by code in notify.c.
9771: **
9772: ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
9773: ** unlock so that it can proceed.
9774: **
9775: ** When X.pBlockingConnection==Y, that means that something that X tried
9776: ** tried to do recently failed with an SQLITE_LOCKED error due to locks
9777: ** held by Y.
9778: */
9779: sqlite3 *pBlockingConnection; /* Connection that caused SQLITE_LOCKED */
9780: sqlite3 *pUnlockConnection; /* Connection to watch for unlock */
9781: void *pUnlockArg; /* Argument to xUnlockNotify */
9782: void (*xUnlockNotify)(void **, int); /* Unlock notify callback */
9783: sqlite3 *pNextBlocked; /* Next in list of all blocked connections */
9784: #endif
9785: };
9786:
9787: /*
9788: ** A macro to discover the encoding of a database.
9789: */
9790: #define ENC(db) ((db)->aDb[0].pSchema->enc)
9791:
9792: /*
9793: ** Possible values for the sqlite3.flags.
9794: */
9795: #define SQLITE_VdbeTrace 0x00000100 /* True to trace VDBE execution */
9796: #define SQLITE_InternChanges 0x00000200 /* Uncommitted Hash table changes */
9797: #define SQLITE_FullColNames 0x00000400 /* Show full column names on SELECT */
9798: #define SQLITE_ShortColNames 0x00000800 /* Show short columns names */
9799: #define SQLITE_CountRows 0x00001000 /* Count rows changed by INSERT, */
9800: /* DELETE, or UPDATE and return */
9801: /* the count using a callback. */
9802: #define SQLITE_NullCallback 0x00002000 /* Invoke the callback once if the */
9803: /* result set is empty */
9804: #define SQLITE_SqlTrace 0x00004000 /* Debug print SQL as it executes */
9805: #define SQLITE_VdbeListing 0x00008000 /* Debug listings of VDBE programs */
9806: #define SQLITE_WriteSchema 0x00010000 /* OK to update SQLITE_MASTER */
9807: #define SQLITE_NoReadlock 0x00020000 /* Readlocks are omitted when
9808: ** accessing read-only databases */
9809: #define SQLITE_IgnoreChecks 0x00040000 /* Do not enforce check constraints */
9810: #define SQLITE_ReadUncommitted 0x0080000 /* For shared-cache mode */
9811: #define SQLITE_LegacyFileFmt 0x00100000 /* Create new databases in format 1 */
9812: #define SQLITE_FullFSync 0x00200000 /* Use full fsync on the backend */
9813: #define SQLITE_CkptFullFSync 0x00400000 /* Use full fsync for checkpoint */
9814: #define SQLITE_RecoveryMode 0x00800000 /* Ignore schema errors */
9815: #define SQLITE_ReverseOrder 0x01000000 /* Reverse unordered SELECTs */
9816: #define SQLITE_RecTriggers 0x02000000 /* Enable recursive triggers */
9817: #define SQLITE_ForeignKeys 0x04000000 /* Enforce foreign key constraints */
9818: #define SQLITE_AutoIndex 0x08000000 /* Enable automatic indexes */
9819: #define SQLITE_PreferBuiltin 0x10000000 /* Preference to built-in funcs */
9820: #define SQLITE_LoadExtension 0x20000000 /* Enable load_extension */
9821: #define SQLITE_EnableTrigger 0x40000000 /* True to enable triggers */
9822:
9823: /*
9824: ** Bits of the sqlite3.flags field that are used by the
9825: ** sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS,...) interface.
9826: ** These must be the low-order bits of the flags field.
9827: */
9828: #define SQLITE_QueryFlattener 0x01 /* Disable query flattening */
9829: #define SQLITE_ColumnCache 0x02 /* Disable the column cache */
9830: #define SQLITE_IndexSort 0x04 /* Disable indexes for sorting */
9831: #define SQLITE_IndexSearch 0x08 /* Disable indexes for searching */
9832: #define SQLITE_IndexCover 0x10 /* Disable index covering table */
9833: #define SQLITE_GroupByOrder 0x20 /* Disable GROUPBY cover of ORDERBY */
9834: #define SQLITE_FactorOutConst 0x40 /* Disable factoring out constants */
9835: #define SQLITE_IdxRealAsInt 0x80 /* Store REAL as INT in indices */
9836: #define SQLITE_DistinctOpt 0x80 /* DISTINCT using indexes */
9837: #define SQLITE_OptMask 0xff /* Mask of all disablable opts */
9838:
9839: /*
9840: ** Possible values for the sqlite.magic field.
9841: ** The numbers are obtained at random and have no special meaning, other
9842: ** than being distinct from one another.
9843: */
9844: #define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */
9845: #define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */
9846: #define SQLITE_MAGIC_SICK 0x4b771290 /* Error and awaiting close */
9847: #define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */
9848: #define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */
9849:
9850: /*
9851: ** Each SQL function is defined by an instance of the following
9852: ** structure. A pointer to this structure is stored in the sqlite.aFunc
9853: ** hash table. When multiple functions have the same name, the hash table
9854: ** points to a linked list of these structures.
9855: */
9856: struct FuncDef {
9857: i16 nArg; /* Number of arguments. -1 means unlimited */
9858: u8 iPrefEnc; /* Preferred text encoding (SQLITE_UTF8, 16LE, 16BE) */
9859: u8 flags; /* Some combination of SQLITE_FUNC_* */
9860: void *pUserData; /* User data parameter */
9861: FuncDef *pNext; /* Next function with same name */
9862: void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */
9863: void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */
9864: void (*xFinalize)(sqlite3_context*); /* Aggregate finalizer */
9865: char *zName; /* SQL name of the function. */
9866: FuncDef *pHash; /* Next with a different name but the same hash */
9867: FuncDestructor *pDestructor; /* Reference counted destructor function */
9868: };
9869:
9870: /*
9871: ** This structure encapsulates a user-function destructor callback (as
9872: ** configured using create_function_v2()) and a reference counter. When
9873: ** create_function_v2() is called to create a function with a destructor,
9874: ** a single object of this type is allocated. FuncDestructor.nRef is set to
9875: ** the number of FuncDef objects created (either 1 or 3, depending on whether
9876: ** or not the specified encoding is SQLITE_ANY). The FuncDef.pDestructor
9877: ** member of each of the new FuncDef objects is set to point to the allocated
9878: ** FuncDestructor.
9879: **
9880: ** Thereafter, when one of the FuncDef objects is deleted, the reference
9881: ** count on this object is decremented. When it reaches 0, the destructor
9882: ** is invoked and the FuncDestructor structure freed.
9883: */
9884: struct FuncDestructor {
9885: int nRef;
9886: void (*xDestroy)(void *);
9887: void *pUserData;
9888: };
9889:
9890: /*
9891: ** Possible values for FuncDef.flags
9892: */
9893: #define SQLITE_FUNC_LIKE 0x01 /* Candidate for the LIKE optimization */
9894: #define SQLITE_FUNC_CASE 0x02 /* Case-sensitive LIKE-type function */
9895: #define SQLITE_FUNC_EPHEM 0x04 /* Ephemeral. Delete with VDBE */
9896: #define SQLITE_FUNC_NEEDCOLL 0x08 /* sqlite3GetFuncCollSeq() might be called */
9897: #define SQLITE_FUNC_PRIVATE 0x10 /* Allowed for internal use only */
9898: #define SQLITE_FUNC_COUNT 0x20 /* Built-in count(*) aggregate */
9899: #define SQLITE_FUNC_COALESCE 0x40 /* Built-in coalesce() or ifnull() function */
9900:
9901: /*
9902: ** The following three macros, FUNCTION(), LIKEFUNC() and AGGREGATE() are
9903: ** used to create the initializers for the FuncDef structures.
9904: **
9905: ** FUNCTION(zName, nArg, iArg, bNC, xFunc)
9906: ** Used to create a scalar function definition of a function zName
9907: ** implemented by C function xFunc that accepts nArg arguments. The
9908: ** value passed as iArg is cast to a (void*) and made available
9909: ** as the user-data (sqlite3_user_data()) for the function. If
9910: ** argument bNC is true, then the SQLITE_FUNC_NEEDCOLL flag is set.
9911: **
9912: ** AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)
9913: ** Used to create an aggregate function definition implemented by
9914: ** the C functions xStep and xFinal. The first four parameters
9915: ** are interpreted in the same way as the first 4 parameters to
9916: ** FUNCTION().
9917: **
9918: ** LIKEFUNC(zName, nArg, pArg, flags)
9919: ** Used to create a scalar function definition of a function zName
9920: ** that accepts nArg arguments and is implemented by a call to C
9921: ** function likeFunc. Argument pArg is cast to a (void *) and made
9922: ** available as the function user-data (sqlite3_user_data()). The
9923: ** FuncDef.flags variable is set to the value passed as the flags
9924: ** parameter.
9925: */
9926: #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
9927: {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \
9928: SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
9929: #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
9930: {nArg, SQLITE_UTF8, bNC*SQLITE_FUNC_NEEDCOLL, \
9931: pArg, 0, xFunc, 0, 0, #zName, 0, 0}
9932: #define LIKEFUNC(zName, nArg, arg, flags) \
9933: {nArg, SQLITE_UTF8, flags, (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}
9934: #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
9935: {nArg, SQLITE_UTF8, nc*SQLITE_FUNC_NEEDCOLL, \
9936: SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
9937:
9938: /*
9939: ** All current savepoints are stored in a linked list starting at
9940: ** sqlite3.pSavepoint. The first element in the list is the most recently
9941: ** opened savepoint. Savepoints are added to the list by the vdbe
9942: ** OP_Savepoint instruction.
9943: */
9944: struct Savepoint {
9945: char *zName; /* Savepoint name (nul-terminated) */
9946: i64 nDeferredCons; /* Number of deferred fk violations */
9947: Savepoint *pNext; /* Parent savepoint (if any) */
9948: };
9949:
9950: /*
9951: ** The following are used as the second parameter to sqlite3Savepoint(),
9952: ** and as the P1 argument to the OP_Savepoint instruction.
9953: */
9954: #define SAVEPOINT_BEGIN 0
9955: #define SAVEPOINT_RELEASE 1
9956: #define SAVEPOINT_ROLLBACK 2
9957:
9958:
9959: /*
9960: ** Each SQLite module (virtual table definition) is defined by an
9961: ** instance of the following structure, stored in the sqlite3.aModule
9962: ** hash table.
9963: */
9964: struct Module {
9965: const sqlite3_module *pModule; /* Callback pointers */
9966: const char *zName; /* Name passed to create_module() */
9967: void *pAux; /* pAux passed to create_module() */
9968: void (*xDestroy)(void *); /* Module destructor function */
9969: };
9970:
9971: /*
9972: ** information about each column of an SQL table is held in an instance
9973: ** of this structure.
9974: */
9975: struct Column {
9976: char *zName; /* Name of this column */
9977: Expr *pDflt; /* Default value of this column */
9978: char *zDflt; /* Original text of the default value */
9979: char *zType; /* Data type for this column */
9980: char *zColl; /* Collating sequence. If NULL, use the default */
9981: u8 notNull; /* True if there is a NOT NULL constraint */
9982: u8 isPrimKey; /* True if this column is part of the PRIMARY KEY */
9983: char affinity; /* One of the SQLITE_AFF_... values */
9984: #ifndef SQLITE_OMIT_VIRTUALTABLE
9985: u8 isHidden; /* True if this column is 'hidden' */
9986: #endif
9987: };
9988:
9989: /*
9990: ** A "Collating Sequence" is defined by an instance of the following
9991: ** structure. Conceptually, a collating sequence consists of a name and
9992: ** a comparison routine that defines the order of that sequence.
9993: **
9994: ** There may two separate implementations of the collation function, one
9995: ** that processes text in UTF-8 encoding (CollSeq.xCmp) and another that
9996: ** processes text encoded in UTF-16 (CollSeq.xCmp16), using the machine
9997: ** native byte order. When a collation sequence is invoked, SQLite selects
9998: ** the version that will require the least expensive encoding
9999: ** translations, if any.
10000: **
10001: ** The CollSeq.pUser member variable is an extra parameter that passed in
10002: ** as the first argument to the UTF-8 comparison function, xCmp.
10003: ** CollSeq.pUser16 is the equivalent for the UTF-16 comparison function,
10004: ** xCmp16.
10005: **
10006: ** If both CollSeq.xCmp and CollSeq.xCmp16 are NULL, it means that the
10007: ** collating sequence is undefined. Indices built on an undefined
10008: ** collating sequence may not be read or written.
10009: */
10010: struct CollSeq {
10011: char *zName; /* Name of the collating sequence, UTF-8 encoded */
10012: u8 enc; /* Text encoding handled by xCmp() */
10013: void *pUser; /* First argument to xCmp() */
10014: int (*xCmp)(void*,int, const void*, int, const void*);
10015: void (*xDel)(void*); /* Destructor for pUser */
10016: };
10017:
10018: /*
10019: ** A sort order can be either ASC or DESC.
10020: */
10021: #define SQLITE_SO_ASC 0 /* Sort in ascending order */
10022: #define SQLITE_SO_DESC 1 /* Sort in ascending order */
10023:
10024: /*
10025: ** Column affinity types.
10026: **
10027: ** These used to have mnemonic name like 'i' for SQLITE_AFF_INTEGER and
10028: ** 't' for SQLITE_AFF_TEXT. But we can save a little space and improve
10029: ** the speed a little by numbering the values consecutively.
10030: **
10031: ** But rather than start with 0 or 1, we begin with 'a'. That way,
10032: ** when multiple affinity types are concatenated into a string and
10033: ** used as the P4 operand, they will be more readable.
10034: **
10035: ** Note also that the numeric types are grouped together so that testing
10036: ** for a numeric type is a single comparison.
10037: */
10038: #define SQLITE_AFF_TEXT 'a'
10039: #define SQLITE_AFF_NONE 'b'
10040: #define SQLITE_AFF_NUMERIC 'c'
10041: #define SQLITE_AFF_INTEGER 'd'
10042: #define SQLITE_AFF_REAL 'e'
10043:
10044: #define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC)
10045:
10046: /*
10047: ** The SQLITE_AFF_MASK values masks off the significant bits of an
10048: ** affinity value.
10049: */
10050: #define SQLITE_AFF_MASK 0x67
10051:
10052: /*
10053: ** Additional bit values that can be ORed with an affinity without
10054: ** changing the affinity.
10055: */
10056: #define SQLITE_JUMPIFNULL 0x08 /* jumps if either operand is NULL */
10057: #define SQLITE_STOREP2 0x10 /* Store result in reg[P2] rather than jump */
10058: #define SQLITE_NULLEQ 0x80 /* NULL=NULL */
10059:
10060: /*
10061: ** An object of this type is created for each virtual table present in
10062: ** the database schema.
10063: **
10064: ** If the database schema is shared, then there is one instance of this
10065: ** structure for each database connection (sqlite3*) that uses the shared
10066: ** schema. This is because each database connection requires its own unique
10067: ** instance of the sqlite3_vtab* handle used to access the virtual table
10068: ** implementation. sqlite3_vtab* handles can not be shared between
10069: ** database connections, even when the rest of the in-memory database
10070: ** schema is shared, as the implementation often stores the database
10071: ** connection handle passed to it via the xConnect() or xCreate() method
10072: ** during initialization internally. This database connection handle may
10073: ** then be used by the virtual table implementation to access real tables
10074: ** within the database. So that they appear as part of the callers
10075: ** transaction, these accesses need to be made via the same database
10076: ** connection as that used to execute SQL operations on the virtual table.
10077: **
10078: ** All VTable objects that correspond to a single table in a shared
10079: ** database schema are initially stored in a linked-list pointed to by
10080: ** the Table.pVTable member variable of the corresponding Table object.
10081: ** When an sqlite3_prepare() operation is required to access the virtual
10082: ** table, it searches the list for the VTable that corresponds to the
10083: ** database connection doing the preparing so as to use the correct
10084: ** sqlite3_vtab* handle in the compiled query.
10085: **
10086: ** When an in-memory Table object is deleted (for example when the
10087: ** schema is being reloaded for some reason), the VTable objects are not
10088: ** deleted and the sqlite3_vtab* handles are not xDisconnect()ed
10089: ** immediately. Instead, they are moved from the Table.pVTable list to
10090: ** another linked list headed by the sqlite3.pDisconnect member of the
10091: ** corresponding sqlite3 structure. They are then deleted/xDisconnected
10092: ** next time a statement is prepared using said sqlite3*. This is done
10093: ** to avoid deadlock issues involving multiple sqlite3.mutex mutexes.
10094: ** Refer to comments above function sqlite3VtabUnlockList() for an
10095: ** explanation as to why it is safe to add an entry to an sqlite3.pDisconnect
10096: ** list without holding the corresponding sqlite3.mutex mutex.
10097: **
10098: ** The memory for objects of this type is always allocated by
10099: ** sqlite3DbMalloc(), using the connection handle stored in VTable.db as
10100: ** the first argument.
10101: */
10102: struct VTable {
10103: sqlite3 *db; /* Database connection associated with this table */
10104: Module *pMod; /* Pointer to module implementation */
10105: sqlite3_vtab *pVtab; /* Pointer to vtab instance */
10106: int nRef; /* Number of pointers to this structure */
10107: u8 bConstraint; /* True if constraints are supported */
10108: int iSavepoint; /* Depth of the SAVEPOINT stack */
10109: VTable *pNext; /* Next in linked list (see above) */
10110: };
10111:
10112: /*
10113: ** Each SQL table is represented in memory by an instance of the
10114: ** following structure.
10115: **
10116: ** Table.zName is the name of the table. The case of the original
10117: ** CREATE TABLE statement is stored, but case is not significant for
10118: ** comparisons.
10119: **
10120: ** Table.nCol is the number of columns in this table. Table.aCol is a
10121: ** pointer to an array of Column structures, one for each column.
10122: **
10123: ** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of
10124: ** the column that is that key. Otherwise Table.iPKey is negative. Note
10125: ** that the datatype of the PRIMARY KEY must be INTEGER for this field to
10126: ** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of
10127: ** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid
10128: ** is generated for each row of the table. TF_HasPrimaryKey is set if
10129: ** the table has any PRIMARY KEY, INTEGER or otherwise.
10130: **
10131: ** Table.tnum is the page number for the root BTree page of the table in the
10132: ** database file. If Table.iDb is the index of the database table backend
10133: ** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that
10134: ** holds temporary tables and indices. If TF_Ephemeral is set
10135: ** then the table is stored in a file that is automatically deleted
10136: ** when the VDBE cursor to the table is closed. In this case Table.tnum
10137: ** refers VDBE cursor number that holds the table open, not to the root
10138: ** page number. Transient tables are used to hold the results of a
10139: ** sub-query that appears instead of a real table name in the FROM clause
10140: ** of a SELECT statement.
10141: */
10142: struct Table {
10143: char *zName; /* Name of the table or view */
10144: int iPKey; /* If not negative, use aCol[iPKey] as the primary key */
10145: int nCol; /* Number of columns in this table */
10146: Column *aCol; /* Information about each column */
10147: Index *pIndex; /* List of SQL indexes on this table. */
10148: int tnum; /* Root BTree node for this table (see note above) */
10149: tRowcnt nRowEst; /* Estimated rows in table - from sqlite_stat1 table */
10150: Select *pSelect; /* NULL for tables. Points to definition if a view. */
10151: u16 nRef; /* Number of pointers to this Table */
10152: u8 tabFlags; /* Mask of TF_* values */
10153: u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */
10154: FKey *pFKey; /* Linked list of all foreign keys in this table */
10155: char *zColAff; /* String defining the affinity of each column */
10156: #ifndef SQLITE_OMIT_CHECK
10157: Expr *pCheck; /* The AND of all CHECK constraints */
10158: #endif
10159: #ifndef SQLITE_OMIT_ALTERTABLE
10160: int addColOffset; /* Offset in CREATE TABLE stmt to add a new column */
10161: #endif
10162: #ifndef SQLITE_OMIT_VIRTUALTABLE
10163: VTable *pVTable; /* List of VTable objects. */
10164: int nModuleArg; /* Number of arguments to the module */
10165: char **azModuleArg; /* Text of all module args. [0] is module name */
10166: #endif
10167: Trigger *pTrigger; /* List of triggers stored in pSchema */
10168: Schema *pSchema; /* Schema that contains this table */
10169: Table *pNextZombie; /* Next on the Parse.pZombieTab list */
10170: };
10171:
10172: /*
10173: ** Allowed values for Tabe.tabFlags.
10174: */
10175: #define TF_Readonly 0x01 /* Read-only system table */
10176: #define TF_Ephemeral 0x02 /* An ephemeral table */
10177: #define TF_HasPrimaryKey 0x04 /* Table has a primary key */
10178: #define TF_Autoincrement 0x08 /* Integer primary key is autoincrement */
10179: #define TF_Virtual 0x10 /* Is a virtual table */
10180: #define TF_NeedMetadata 0x20 /* aCol[].zType and aCol[].pColl missing */
10181:
10182:
10183:
10184: /*
10185: ** Test to see whether or not a table is a virtual table. This is
10186: ** done as a macro so that it will be optimized out when virtual
10187: ** table support is omitted from the build.
10188: */
10189: #ifndef SQLITE_OMIT_VIRTUALTABLE
10190: # define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0)
10191: # define IsHiddenColumn(X) ((X)->isHidden)
10192: #else
10193: # define IsVirtual(X) 0
10194: # define IsHiddenColumn(X) 0
10195: #endif
10196:
10197: /*
10198: ** Each foreign key constraint is an instance of the following structure.
10199: **
10200: ** A foreign key is associated with two tables. The "from" table is
10201: ** the table that contains the REFERENCES clause that creates the foreign
10202: ** key. The "to" table is the table that is named in the REFERENCES clause.
10203: ** Consider this example:
10204: **
10205: ** CREATE TABLE ex1(
10206: ** a INTEGER PRIMARY KEY,
10207: ** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x)
10208: ** );
10209: **
10210: ** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2".
10211: **
10212: ** Each REFERENCES clause generates an instance of the following structure
10213: ** which is attached to the from-table. The to-table need not exist when
10214: ** the from-table is created. The existence of the to-table is not checked.
10215: */
10216: struct FKey {
10217: Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */
10218: FKey *pNextFrom; /* Next foreign key in pFrom */
10219: char *zTo; /* Name of table that the key points to (aka: Parent) */
10220: FKey *pNextTo; /* Next foreign key on table named zTo */
10221: FKey *pPrevTo; /* Previous foreign key on table named zTo */
10222: int nCol; /* Number of columns in this key */
10223: /* EV: R-30323-21917 */
10224: u8 isDeferred; /* True if constraint checking is deferred till COMMIT */
10225: u8 aAction[2]; /* ON DELETE and ON UPDATE actions, respectively */
10226: Trigger *apTrigger[2]; /* Triggers for aAction[] actions */
10227: struct sColMap { /* Mapping of columns in pFrom to columns in zTo */
10228: int iFrom; /* Index of column in pFrom */
10229: char *zCol; /* Name of column in zTo. If 0 use PRIMARY KEY */
10230: } aCol[1]; /* One entry for each of nCol column s */
10231: };
10232:
10233: /*
10234: ** SQLite supports many different ways to resolve a constraint
10235: ** error. ROLLBACK processing means that a constraint violation
10236: ** causes the operation in process to fail and for the current transaction
10237: ** to be rolled back. ABORT processing means the operation in process
10238: ** fails and any prior changes from that one operation are backed out,
10239: ** but the transaction is not rolled back. FAIL processing means that
10240: ** the operation in progress stops and returns an error code. But prior
10241: ** changes due to the same operation are not backed out and no rollback
10242: ** occurs. IGNORE means that the particular row that caused the constraint
10243: ** error is not inserted or updated. Processing continues and no error
10244: ** is returned. REPLACE means that preexisting database rows that caused
10245: ** a UNIQUE constraint violation are removed so that the new insert or
10246: ** update can proceed. Processing continues and no error is reported.
10247: **
10248: ** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys.
10249: ** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
10250: ** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign
10251: ** key is set to NULL. CASCADE means that a DELETE or UPDATE of the
10252: ** referenced table row is propagated into the row that holds the
10253: ** foreign key.
10254: **
10255: ** The following symbolic values are used to record which type
10256: ** of action to take.
10257: */
10258: #define OE_None 0 /* There is no constraint to check */
10259: #define OE_Rollback 1 /* Fail the operation and rollback the transaction */
10260: #define OE_Abort 2 /* Back out changes but do no rollback transaction */
10261: #define OE_Fail 3 /* Stop the operation but leave all prior changes */
10262: #define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */
10263: #define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */
10264:
10265: #define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
10266: #define OE_SetNull 7 /* Set the foreign key value to NULL */
10267: #define OE_SetDflt 8 /* Set the foreign key value to its default */
10268: #define OE_Cascade 9 /* Cascade the changes */
10269:
10270: #define OE_Default 99 /* Do whatever the default action is */
10271:
10272:
10273: /*
10274: ** An instance of the following structure is passed as the first
10275: ** argument to sqlite3VdbeKeyCompare and is used to control the
10276: ** comparison of the two index keys.
10277: */
10278: struct KeyInfo {
10279: sqlite3 *db; /* The database connection */
10280: u8 enc; /* Text encoding - one of the SQLITE_UTF* values */
10281: u16 nField; /* Number of entries in aColl[] */
10282: u8 *aSortOrder; /* Sort order for each column. May be NULL */
10283: CollSeq *aColl[1]; /* Collating sequence for each term of the key */
10284: };
10285:
10286: /*
10287: ** An instance of the following structure holds information about a
10288: ** single index record that has already been parsed out into individual
10289: ** values.
10290: **
10291: ** A record is an object that contains one or more fields of data.
10292: ** Records are used to store the content of a table row and to store
10293: ** the key of an index. A blob encoding of a record is created by
10294: ** the OP_MakeRecord opcode of the VDBE and is disassembled by the
10295: ** OP_Column opcode.
10296: **
10297: ** This structure holds a record that has already been disassembled
10298: ** into its constituent fields.
10299: */
10300: struct UnpackedRecord {
10301: KeyInfo *pKeyInfo; /* Collation and sort-order information */
10302: u16 nField; /* Number of entries in apMem[] */
10303: u8 flags; /* Boolean settings. UNPACKED_... below */
10304: i64 rowid; /* Used by UNPACKED_PREFIX_SEARCH */
10305: Mem *aMem; /* Values */
10306: };
10307:
10308: /*
10309: ** Allowed values of UnpackedRecord.flags
10310: */
10311: #define UNPACKED_INCRKEY 0x01 /* Make this key an epsilon larger */
10312: #define UNPACKED_PREFIX_MATCH 0x02 /* A prefix match is considered OK */
10313: #define UNPACKED_PREFIX_SEARCH 0x04 /* Ignore final (rowid) field */
10314:
10315: /*
10316: ** Each SQL index is represented in memory by an
10317: ** instance of the following structure.
10318: **
10319: ** The columns of the table that are to be indexed are described
10320: ** by the aiColumn[] field of this structure. For example, suppose
10321: ** we have the following table and index:
10322: **
10323: ** CREATE TABLE Ex1(c1 int, c2 int, c3 text);
10324: ** CREATE INDEX Ex2 ON Ex1(c3,c1);
10325: **
10326: ** In the Table structure describing Ex1, nCol==3 because there are
10327: ** three columns in the table. In the Index structure describing
10328: ** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed.
10329: ** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the
10330: ** first column to be indexed (c3) has an index of 2 in Ex1.aCol[].
10331: ** The second column to be indexed (c1) has an index of 0 in
10332: ** Ex1.aCol[], hence Ex2.aiColumn[1]==0.
10333: **
10334: ** The Index.onError field determines whether or not the indexed columns
10335: ** must be unique and what to do if they are not. When Index.onError=OE_None,
10336: ** it means this is not a unique index. Otherwise it is a unique index
10337: ** and the value of Index.onError indicate the which conflict resolution
10338: ** algorithm to employ whenever an attempt is made to insert a non-unique
10339: ** element.
10340: */
10341: struct Index {
10342: char *zName; /* Name of this index */
10343: int nColumn; /* Number of columns in the table used by this index */
10344: int *aiColumn; /* Which columns are used by this index. 1st is 0 */
10345: tRowcnt *aiRowEst; /* Result of ANALYZE: Est. rows selected by each column */
10346: Table *pTable; /* The SQL table being indexed */
10347: int tnum; /* Page containing root of this index in database file */
10348: u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
10349: u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */
10350: u8 bUnordered; /* Use this index for == or IN queries only */
10351: char *zColAff; /* String defining the affinity of each column */
10352: Index *pNext; /* The next index associated with the same table */
10353: Schema *pSchema; /* Schema containing this index */
10354: u8 *aSortOrder; /* Array of size Index.nColumn. True==DESC, False==ASC */
10355: char **azColl; /* Array of collation sequence names for index */
10356: #ifdef SQLITE_ENABLE_STAT3
10357: int nSample; /* Number of elements in aSample[] */
10358: tRowcnt avgEq; /* Average nEq value for key values not in aSample */
10359: IndexSample *aSample; /* Samples of the left-most key */
10360: #endif
10361: };
10362:
10363: /*
10364: ** Each sample stored in the sqlite_stat3 table is represented in memory
10365: ** using a structure of this type. See documentation at the top of the
10366: ** analyze.c source file for additional information.
10367: */
10368: struct IndexSample {
10369: union {
10370: char *z; /* Value if eType is SQLITE_TEXT or SQLITE_BLOB */
10371: double r; /* Value if eType is SQLITE_FLOAT */
10372: i64 i; /* Value if eType is SQLITE_INTEGER */
10373: } u;
10374: u8 eType; /* SQLITE_NULL, SQLITE_INTEGER ... etc. */
10375: int nByte; /* Size in byte of text or blob. */
10376: tRowcnt nEq; /* Est. number of rows where the key equals this sample */
10377: tRowcnt nLt; /* Est. number of rows where key is less than this sample */
10378: tRowcnt nDLt; /* Est. number of distinct keys less than this sample */
10379: };
10380:
10381: /*
10382: ** Each token coming out of the lexer is an instance of
10383: ** this structure. Tokens are also used as part of an expression.
10384: **
10385: ** Note if Token.z==0 then Token.dyn and Token.n are undefined and
10386: ** may contain random values. Do not make any assumptions about Token.dyn
10387: ** and Token.n when Token.z==0.
10388: */
10389: struct Token {
10390: const char *z; /* Text of the token. Not NULL-terminated! */
10391: unsigned int n; /* Number of characters in this token */
10392: };
10393:
10394: /*
10395: ** An instance of this structure contains information needed to generate
10396: ** code for a SELECT that contains aggregate functions.
10397: **
10398: ** If Expr.op==TK_AGG_COLUMN or TK_AGG_FUNCTION then Expr.pAggInfo is a
10399: ** pointer to this structure. The Expr.iColumn field is the index in
10400: ** AggInfo.aCol[] or AggInfo.aFunc[] of information needed to generate
10401: ** code for that node.
10402: **
10403: ** AggInfo.pGroupBy and AggInfo.aFunc.pExpr point to fields within the
10404: ** original Select structure that describes the SELECT statement. These
10405: ** fields do not need to be freed when deallocating the AggInfo structure.
10406: */
10407: struct AggInfo {
10408: u8 directMode; /* Direct rendering mode means take data directly
10409: ** from source tables rather than from accumulators */
10410: u8 useSortingIdx; /* In direct mode, reference the sorting index rather
10411: ** than the source table */
10412: int sortingIdx; /* Cursor number of the sorting index */
10413: int sortingIdxPTab; /* Cursor number of pseudo-table */
10414: ExprList *pGroupBy; /* The group by clause */
10415: int nSortingColumn; /* Number of columns in the sorting index */
10416: struct AggInfo_col { /* For each column used in source tables */
10417: Table *pTab; /* Source table */
10418: int iTable; /* Cursor number of the source table */
10419: int iColumn; /* Column number within the source table */
10420: int iSorterColumn; /* Column number in the sorting index */
10421: int iMem; /* Memory location that acts as accumulator */
10422: Expr *pExpr; /* The original expression */
10423: } *aCol;
10424: int nColumn; /* Number of used entries in aCol[] */
10425: int nColumnAlloc; /* Number of slots allocated for aCol[] */
10426: int nAccumulator; /* Number of columns that show through to the output.
10427: ** Additional columns are used only as parameters to
10428: ** aggregate functions */
10429: struct AggInfo_func { /* For each aggregate function */
10430: Expr *pExpr; /* Expression encoding the function */
10431: FuncDef *pFunc; /* The aggregate function implementation */
10432: int iMem; /* Memory location that acts as accumulator */
10433: int iDistinct; /* Ephemeral table used to enforce DISTINCT */
10434: } *aFunc;
10435: int nFunc; /* Number of entries in aFunc[] */
10436: int nFuncAlloc; /* Number of slots allocated for aFunc[] */
10437: };
10438:
10439: /*
10440: ** The datatype ynVar is a signed integer, either 16-bit or 32-bit.
10441: ** Usually it is 16-bits. But if SQLITE_MAX_VARIABLE_NUMBER is greater
10442: ** than 32767 we have to make it 32-bit. 16-bit is preferred because
10443: ** it uses less memory in the Expr object, which is a big memory user
10444: ** in systems with lots of prepared statements. And few applications
10445: ** need more than about 10 or 20 variables. But some extreme users want
10446: ** to have prepared statements with over 32767 variables, and for them
10447: ** the option is available (at compile-time).
10448: */
10449: #if SQLITE_MAX_VARIABLE_NUMBER<=32767
10450: typedef i16 ynVar;
10451: #else
10452: typedef int ynVar;
10453: #endif
10454:
10455: /*
10456: ** Each node of an expression in the parse tree is an instance
10457: ** of this structure.
10458: **
10459: ** Expr.op is the opcode. The integer parser token codes are reused
10460: ** as opcodes here. For example, the parser defines TK_GE to be an integer
10461: ** code representing the ">=" operator. This same integer code is reused
10462: ** to represent the greater-than-or-equal-to operator in the expression
10463: ** tree.
10464: **
10465: ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
10466: ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
10467: ** the expression is a variable (TK_VARIABLE), then Expr.token contains the
10468: ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
10469: ** then Expr.token contains the name of the function.
10470: **
10471: ** Expr.pRight and Expr.pLeft are the left and right subexpressions of a
10472: ** binary operator. Either or both may be NULL.
10473: **
10474: ** Expr.x.pList is a list of arguments if the expression is an SQL function,
10475: ** a CASE expression or an IN expression of the form "<lhs> IN (<y>, <z>...)".
10476: ** Expr.x.pSelect is used if the expression is a sub-select or an expression of
10477: ** the form "<lhs> IN (SELECT ...)". If the EP_xIsSelect bit is set in the
10478: ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
10479: ** valid.
10480: **
10481: ** An expression of the form ID or ID.ID refers to a column in a table.
10482: ** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is
10483: ** the integer cursor number of a VDBE cursor pointing to that table and
10484: ** Expr.iColumn is the column number for the specific column. If the
10485: ** expression is used as a result in an aggregate SELECT, then the
10486: ** value is also stored in the Expr.iAgg column in the aggregate so that
10487: ** it can be accessed after all aggregates are computed.
10488: **
10489: ** If the expression is an unbound variable marker (a question mark
10490: ** character '?' in the original SQL) then the Expr.iTable holds the index
10491: ** number for that variable.
10492: **
10493: ** If the expression is a subquery then Expr.iColumn holds an integer
10494: ** register number containing the result of the subquery. If the
10495: ** subquery gives a constant result, then iTable is -1. If the subquery
10496: ** gives a different answer at different times during statement processing
10497: ** then iTable is the address of a subroutine that computes the subquery.
10498: **
10499: ** If the Expr is of type OP_Column, and the table it is selecting from
10500: ** is a disk table or the "old.*" pseudo-table, then pTab points to the
10501: ** corresponding table definition.
10502: **
10503: ** ALLOCATION NOTES:
10504: **
10505: ** Expr objects can use a lot of memory space in database schema. To
10506: ** help reduce memory requirements, sometimes an Expr object will be
10507: ** truncated. And to reduce the number of memory allocations, sometimes
10508: ** two or more Expr objects will be stored in a single memory allocation,
10509: ** together with Expr.zToken strings.
10510: **
10511: ** If the EP_Reduced and EP_TokenOnly flags are set when
10512: ** an Expr object is truncated. When EP_Reduced is set, then all
10513: ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
10514: ** are contained within the same memory allocation. Note, however, that
10515: ** the subtrees in Expr.x.pList or Expr.x.pSelect are always separately
10516: ** allocated, regardless of whether or not EP_Reduced is set.
10517: */
10518: struct Expr {
10519: u8 op; /* Operation performed by this node */
10520: char affinity; /* The affinity of the column or 0 if not a column */
10521: u16 flags; /* Various flags. EP_* See below */
10522: union {
10523: char *zToken; /* Token value. Zero terminated and dequoted */
10524: int iValue; /* Non-negative integer value if EP_IntValue */
10525: } u;
10526:
10527: /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
10528: ** space is allocated for the fields below this point. An attempt to
10529: ** access them will result in a segfault or malfunction.
10530: *********************************************************************/
10531:
10532: Expr *pLeft; /* Left subnode */
10533: Expr *pRight; /* Right subnode */
10534: union {
10535: ExprList *pList; /* Function arguments or in "<expr> IN (<expr-list)" */
10536: Select *pSelect; /* Used for sub-selects and "<expr> IN (<select>)" */
10537: } x;
10538: CollSeq *pColl; /* The collation type of the column or 0 */
10539:
10540: /* If the EP_Reduced flag is set in the Expr.flags mask, then no
10541: ** space is allocated for the fields below this point. An attempt to
10542: ** access them will result in a segfault or malfunction.
10543: *********************************************************************/
10544:
10545: int iTable; /* TK_COLUMN: cursor number of table holding column
10546: ** TK_REGISTER: register number
10547: ** TK_TRIGGER: 1 -> new, 0 -> old */
10548: ynVar iColumn; /* TK_COLUMN: column index. -1 for rowid.
10549: ** TK_VARIABLE: variable number (always >= 1). */
10550: i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
10551: i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */
10552: u8 flags2; /* Second set of flags. EP2_... */
10553: u8 op2; /* If a TK_REGISTER, the original value of Expr.op */
10554: AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
10555: Table *pTab; /* Table for TK_COLUMN expressions. */
10556: #if SQLITE_MAX_EXPR_DEPTH>0
10557: int nHeight; /* Height of the tree headed by this node */
10558: #endif
10559: };
10560:
10561: /*
10562: ** The following are the meanings of bits in the Expr.flags field.
10563: */
10564: #define EP_FromJoin 0x0001 /* Originated in ON or USING clause of a join */
10565: #define EP_Agg 0x0002 /* Contains one or more aggregate functions */
10566: #define EP_Resolved 0x0004 /* IDs have been resolved to COLUMNs */
10567: #define EP_Error 0x0008 /* Expression contains one or more errors */
10568: #define EP_Distinct 0x0010 /* Aggregate function with DISTINCT keyword */
10569: #define EP_VarSelect 0x0020 /* pSelect is correlated, not constant */
10570: #define EP_DblQuoted 0x0040 /* token.z was originally in "..." */
10571: #define EP_InfixFunc 0x0080 /* True for an infix function: LIKE, GLOB, etc */
10572: #define EP_ExpCollate 0x0100 /* Collating sequence specified explicitly */
10573: #define EP_FixedDest 0x0200 /* Result needed in a specific register */
10574: #define EP_IntValue 0x0400 /* Integer value contained in u.iValue */
10575: #define EP_xIsSelect 0x0800 /* x.pSelect is valid (otherwise x.pList is) */
10576: #define EP_Hint 0x1000 /* Optimizer hint. Not required for correctness */
10577: #define EP_Reduced 0x2000 /* Expr struct is EXPR_REDUCEDSIZE bytes only */
10578: #define EP_TokenOnly 0x4000 /* Expr struct is EXPR_TOKENONLYSIZE bytes only */
10579: #define EP_Static 0x8000 /* Held in memory not obtained from malloc() */
10580:
10581: /*
10582: ** The following are the meanings of bits in the Expr.flags2 field.
10583: */
10584: #define EP2_MallocedToken 0x0001 /* Need to sqlite3DbFree() Expr.zToken */
10585: #define EP2_Irreducible 0x0002 /* Cannot EXPRDUP_REDUCE this Expr */
10586:
10587: /*
10588: ** The pseudo-routine sqlite3ExprSetIrreducible sets the EP2_Irreducible
10589: ** flag on an expression structure. This flag is used for VV&A only. The
10590: ** routine is implemented as a macro that only works when in debugging mode,
10591: ** so as not to burden production code.
10592: */
10593: #ifdef SQLITE_DEBUG
10594: # define ExprSetIrreducible(X) (X)->flags2 |= EP2_Irreducible
10595: #else
10596: # define ExprSetIrreducible(X)
10597: #endif
10598:
10599: /*
10600: ** These macros can be used to test, set, or clear bits in the
10601: ** Expr.flags field.
10602: */
10603: #define ExprHasProperty(E,P) (((E)->flags&(P))==(P))
10604: #define ExprHasAnyProperty(E,P) (((E)->flags&(P))!=0)
10605: #define ExprSetProperty(E,P) (E)->flags|=(P)
10606: #define ExprClearProperty(E,P) (E)->flags&=~(P)
10607:
10608: /*
10609: ** Macros to determine the number of bytes required by a normal Expr
10610: ** struct, an Expr struct with the EP_Reduced flag set in Expr.flags
10611: ** and an Expr struct with the EP_TokenOnly flag set.
10612: */
10613: #define EXPR_FULLSIZE sizeof(Expr) /* Full size */
10614: #define EXPR_REDUCEDSIZE offsetof(Expr,iTable) /* Common features */
10615: #define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) /* Fewer features */
10616:
10617: /*
10618: ** Flags passed to the sqlite3ExprDup() function. See the header comment
10619: ** above sqlite3ExprDup() for details.
10620: */
10621: #define EXPRDUP_REDUCE 0x0001 /* Used reduced-size Expr nodes */
10622:
10623: /*
10624: ** A list of expressions. Each expression may optionally have a
10625: ** name. An expr/name combination can be used in several ways, such
10626: ** as the list of "expr AS ID" fields following a "SELECT" or in the
10627: ** list of "ID = expr" items in an UPDATE. A list of expressions can
10628: ** also be used as the argument to a function, in which case the a.zName
10629: ** field is not used.
10630: */
10631: struct ExprList {
10632: int nExpr; /* Number of expressions on the list */
10633: int nAlloc; /* Number of entries allocated below */
10634: int iECursor; /* VDBE Cursor associated with this ExprList */
10635: struct ExprList_item {
10636: Expr *pExpr; /* The list of expressions */
10637: char *zName; /* Token associated with this expression */
10638: char *zSpan; /* Original text of the expression */
10639: u8 sortOrder; /* 1 for DESC or 0 for ASC */
10640: u8 done; /* A flag to indicate when processing is finished */
10641: u16 iOrderByCol; /* For ORDER BY, column number in result set */
10642: u16 iAlias; /* Index into Parse.aAlias[] for zName */
10643: } *a; /* One entry for each expression */
10644: };
10645:
10646: /*
10647: ** An instance of this structure is used by the parser to record both
10648: ** the parse tree for an expression and the span of input text for an
10649: ** expression.
10650: */
10651: struct ExprSpan {
10652: Expr *pExpr; /* The expression parse tree */
10653: const char *zStart; /* First character of input text */
10654: const char *zEnd; /* One character past the end of input text */
10655: };
10656:
10657: /*
10658: ** An instance of this structure can hold a simple list of identifiers,
10659: ** such as the list "a,b,c" in the following statements:
10660: **
10661: ** INSERT INTO t(a,b,c) VALUES ...;
10662: ** CREATE INDEX idx ON t(a,b,c);
10663: ** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...;
10664: **
10665: ** The IdList.a.idx field is used when the IdList represents the list of
10666: ** column names after a table name in an INSERT statement. In the statement
10667: **
10668: ** INSERT INTO t(a,b,c) ...
10669: **
10670: ** If "a" is the k-th column of table "t", then IdList.a[0].idx==k.
10671: */
10672: struct IdList {
10673: struct IdList_item {
10674: char *zName; /* Name of the identifier */
10675: int idx; /* Index in some Table.aCol[] of a column named zName */
10676: } *a;
10677: int nId; /* Number of identifiers on the list */
10678: int nAlloc; /* Number of entries allocated for a[] below */
10679: };
10680:
10681: /*
10682: ** The bitmask datatype defined below is used for various optimizations.
10683: **
10684: ** Changing this from a 64-bit to a 32-bit type limits the number of
10685: ** tables in a join to 32 instead of 64. But it also reduces the size
10686: ** of the library by 738 bytes on ix86.
10687: */
10688: typedef u64 Bitmask;
10689:
10690: /*
10691: ** The number of bits in a Bitmask. "BMS" means "BitMask Size".
10692: */
10693: #define BMS ((int)(sizeof(Bitmask)*8))
10694:
10695: /*
10696: ** The following structure describes the FROM clause of a SELECT statement.
10697: ** Each table or subquery in the FROM clause is a separate element of
10698: ** the SrcList.a[] array.
10699: **
10700: ** With the addition of multiple database support, the following structure
10701: ** can also be used to describe a particular table such as the table that
10702: ** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL,
10703: ** such a table must be a simple name: ID. But in SQLite, the table can
10704: ** now be identified by a database name, a dot, then the table name: ID.ID.
10705: **
10706: ** The jointype starts out showing the join type between the current table
10707: ** and the next table on the list. The parser builds the list this way.
10708: ** But sqlite3SrcListShiftJoinType() later shifts the jointypes so that each
10709: ** jointype expresses the join between the table and the previous table.
10710: **
10711: ** In the colUsed field, the high-order bit (bit 63) is set if the table
10712: ** contains more than 63 columns and the 64-th or later column is used.
10713: */
10714: struct SrcList {
10715: i16 nSrc; /* Number of tables or subqueries in the FROM clause */
10716: i16 nAlloc; /* Number of entries allocated in a[] below */
10717: struct SrcList_item {
10718: char *zDatabase; /* Name of database holding this table */
10719: char *zName; /* Name of the table */
10720: char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */
10721: Table *pTab; /* An SQL table corresponding to zName */
10722: Select *pSelect; /* A SELECT statement used in place of a table name */
10723: int addrFillSub; /* Address of subroutine to manifest a subquery */
10724: int regReturn; /* Register holding return address of addrFillSub */
10725: u8 jointype; /* Type of join between this able and the previous */
10726: u8 notIndexed; /* True if there is a NOT INDEXED clause */
10727: u8 isCorrelated; /* True if sub-query is correlated */
10728: #ifndef SQLITE_OMIT_EXPLAIN
10729: u8 iSelectId; /* If pSelect!=0, the id of the sub-select in EQP */
10730: #endif
10731: int iCursor; /* The VDBE cursor number used to access this table */
10732: Expr *pOn; /* The ON clause of a join */
10733: IdList *pUsing; /* The USING clause of a join */
10734: Bitmask colUsed; /* Bit N (1<<N) set if column N of pTab is used */
10735: char *zIndex; /* Identifier from "INDEXED BY <zIndex>" clause */
10736: Index *pIndex; /* Index structure corresponding to zIndex, if any */
10737: } a[1]; /* One entry for each identifier on the list */
10738: };
10739:
10740: /*
10741: ** Permitted values of the SrcList.a.jointype field
10742: */
10743: #define JT_INNER 0x0001 /* Any kind of inner or cross join */
10744: #define JT_CROSS 0x0002 /* Explicit use of the CROSS keyword */
10745: #define JT_NATURAL 0x0004 /* True for a "natural" join */
10746: #define JT_LEFT 0x0008 /* Left outer join */
10747: #define JT_RIGHT 0x0010 /* Right outer join */
10748: #define JT_OUTER 0x0020 /* The "OUTER" keyword is present */
10749: #define JT_ERROR 0x0040 /* unknown or unsupported join type */
10750:
10751:
10752: /*
10753: ** A WherePlan object holds information that describes a lookup
10754: ** strategy.
10755: **
10756: ** This object is intended to be opaque outside of the where.c module.
10757: ** It is included here only so that that compiler will know how big it
10758: ** is. None of the fields in this object should be used outside of
10759: ** the where.c module.
10760: **
10761: ** Within the union, pIdx is only used when wsFlags&WHERE_INDEXED is true.
10762: ** pTerm is only used when wsFlags&WHERE_MULTI_OR is true. And pVtabIdx
10763: ** is only used when wsFlags&WHERE_VIRTUALTABLE is true. It is never the
10764: ** case that more than one of these conditions is true.
10765: */
10766: struct WherePlan {
10767: u32 wsFlags; /* WHERE_* flags that describe the strategy */
10768: u32 nEq; /* Number of == constraints */
10769: double nRow; /* Estimated number of rows (for EQP) */
10770: union {
10771: Index *pIdx; /* Index when WHERE_INDEXED is true */
10772: struct WhereTerm *pTerm; /* WHERE clause term for OR-search */
10773: sqlite3_index_info *pVtabIdx; /* Virtual table index to use */
10774: } u;
10775: };
10776:
10777: /*
10778: ** For each nested loop in a WHERE clause implementation, the WhereInfo
10779: ** structure contains a single instance of this structure. This structure
10780: ** is intended to be private the the where.c module and should not be
10781: ** access or modified by other modules.
10782: **
10783: ** The pIdxInfo field is used to help pick the best index on a
10784: ** virtual table. The pIdxInfo pointer contains indexing
10785: ** information for the i-th table in the FROM clause before reordering.
10786: ** All the pIdxInfo pointers are freed by whereInfoFree() in where.c.
10787: ** All other information in the i-th WhereLevel object for the i-th table
10788: ** after FROM clause ordering.
10789: */
10790: struct WhereLevel {
10791: WherePlan plan; /* query plan for this element of the FROM clause */
10792: int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */
10793: int iTabCur; /* The VDBE cursor used to access the table */
10794: int iIdxCur; /* The VDBE cursor used to access pIdx */
10795: int addrBrk; /* Jump here to break out of the loop */
10796: int addrNxt; /* Jump here to start the next IN combination */
10797: int addrCont; /* Jump here to continue with the next loop cycle */
10798: int addrFirst; /* First instruction of interior of the loop */
10799: u8 iFrom; /* Which entry in the FROM clause */
10800: u8 op, p5; /* Opcode and P5 of the opcode that ends the loop */
10801: int p1, p2; /* Operands of the opcode used to ends the loop */
10802: union { /* Information that depends on plan.wsFlags */
10803: struct {
10804: int nIn; /* Number of entries in aInLoop[] */
10805: struct InLoop {
10806: int iCur; /* The VDBE cursor used by this IN operator */
10807: int addrInTop; /* Top of the IN loop */
10808: } *aInLoop; /* Information about each nested IN operator */
10809: } in; /* Used when plan.wsFlags&WHERE_IN_ABLE */
10810: } u;
10811:
10812: /* The following field is really not part of the current level. But
10813: ** we need a place to cache virtual table index information for each
10814: ** virtual table in the FROM clause and the WhereLevel structure is
10815: ** a convenient place since there is one WhereLevel for each FROM clause
10816: ** element.
10817: */
10818: sqlite3_index_info *pIdxInfo; /* Index info for n-th source table */
10819: };
10820:
10821: /*
10822: ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin()
10823: ** and the WhereInfo.wctrlFlags member.
10824: */
10825: #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */
10826: #define WHERE_ORDERBY_MIN 0x0001 /* ORDER BY processing for min() func */
10827: #define WHERE_ORDERBY_MAX 0x0002 /* ORDER BY processing for max() func */
10828: #define WHERE_ONEPASS_DESIRED 0x0004 /* Want to do one-pass UPDATE/DELETE */
10829: #define WHERE_DUPLICATES_OK 0x0008 /* Ok to return a row more than once */
10830: #define WHERE_OMIT_OPEN_CLOSE 0x0010 /* Table cursors are already open */
10831: #define WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */
10832: #define WHERE_ONETABLE_ONLY 0x0040 /* Only code the 1st table in pTabList */
10833: #define WHERE_AND_ONLY 0x0080 /* Don't use indices for OR terms */
10834:
10835: /*
10836: ** The WHERE clause processing routine has two halves. The
10837: ** first part does the start of the WHERE loop and the second
10838: ** half does the tail of the WHERE loop. An instance of
10839: ** this structure is returned by the first half and passed
10840: ** into the second half to give some continuity.
10841: */
10842: struct WhereInfo {
10843: Parse *pParse; /* Parsing and code generating context */
10844: u16 wctrlFlags; /* Flags originally passed to sqlite3WhereBegin() */
10845: u8 okOnePass; /* Ok to use one-pass algorithm for UPDATE or DELETE */
10846: u8 untestedTerms; /* Not all WHERE terms resolved by outer loop */
10847: u8 eDistinct;
10848: SrcList *pTabList; /* List of tables in the join */
10849: int iTop; /* The very beginning of the WHERE loop */
10850: int iContinue; /* Jump here to continue with next record */
10851: int iBreak; /* Jump here to break out of the loop */
10852: int nLevel; /* Number of nested loop */
10853: struct WhereClause *pWC; /* Decomposition of the WHERE clause */
10854: double savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */
10855: double nRowOut; /* Estimated number of output rows */
10856: WhereLevel a[1]; /* Information about each nest loop in WHERE */
10857: };
10858:
10859: #define WHERE_DISTINCT_UNIQUE 1
10860: #define WHERE_DISTINCT_ORDERED 2
10861:
10862: /*
10863: ** A NameContext defines a context in which to resolve table and column
10864: ** names. The context consists of a list of tables (the pSrcList) field and
10865: ** a list of named expression (pEList). The named expression list may
10866: ** be NULL. The pSrc corresponds to the FROM clause of a SELECT or
10867: ** to the table being operated on by INSERT, UPDATE, or DELETE. The
10868: ** pEList corresponds to the result set of a SELECT and is NULL for
10869: ** other statements.
10870: **
10871: ** NameContexts can be nested. When resolving names, the inner-most
10872: ** context is searched first. If no match is found, the next outer
10873: ** context is checked. If there is still no match, the next context
10874: ** is checked. This process continues until either a match is found
10875: ** or all contexts are check. When a match is found, the nRef member of
10876: ** the context containing the match is incremented.
10877: **
10878: ** Each subquery gets a new NameContext. The pNext field points to the
10879: ** NameContext in the parent query. Thus the process of scanning the
10880: ** NameContext list corresponds to searching through successively outer
10881: ** subqueries looking for a match.
10882: */
10883: struct NameContext {
10884: Parse *pParse; /* The parser */
10885: SrcList *pSrcList; /* One or more tables used to resolve names */
10886: ExprList *pEList; /* Optional list of named expressions */
10887: int nRef; /* Number of names resolved by this context */
10888: int nErr; /* Number of errors encountered while resolving names */
10889: u8 allowAgg; /* Aggregate functions allowed here */
10890: u8 hasAgg; /* True if aggregates are seen */
10891: u8 isCheck; /* True if resolving names in a CHECK constraint */
10892: int nDepth; /* Depth of subquery recursion. 1 for no recursion */
10893: AggInfo *pAggInfo; /* Information about aggregates at this level */
10894: NameContext *pNext; /* Next outer name context. NULL for outermost */
10895: };
10896:
10897: /*
10898: ** An instance of the following structure contains all information
10899: ** needed to generate code for a single SELECT statement.
10900: **
10901: ** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0.
10902: ** If there is a LIMIT clause, the parser sets nLimit to the value of the
10903: ** limit and nOffset to the value of the offset (or 0 if there is not
10904: ** offset). But later on, nLimit and nOffset become the memory locations
10905: ** in the VDBE that record the limit and offset counters.
10906: **
10907: ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
10908: ** These addresses must be stored so that we can go back and fill in
10909: ** the P4_KEYINFO and P2 parameters later. Neither the KeyInfo nor
10910: ** the number of columns in P2 can be computed at the same time
10911: ** as the OP_OpenEphm instruction is coded because not
10912: ** enough information about the compound query is known at that point.
10913: ** The KeyInfo for addrOpenTran[0] and [1] contains collating sequences
10914: ** for the result set. The KeyInfo for addrOpenTran[2] contains collating
10915: ** sequences for the ORDER BY clause.
10916: */
10917: struct Select {
10918: ExprList *pEList; /* The fields of the result */
10919: u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */
10920: char affinity; /* MakeRecord with this affinity for SRT_Set */
10921: u16 selFlags; /* Various SF_* values */
10922: SrcList *pSrc; /* The FROM clause */
10923: Expr *pWhere; /* The WHERE clause */
10924: ExprList *pGroupBy; /* The GROUP BY clause */
10925: Expr *pHaving; /* The HAVING clause */
10926: ExprList *pOrderBy; /* The ORDER BY clause */
10927: Select *pPrior; /* Prior select in a compound select statement */
10928: Select *pNext; /* Next select to the left in a compound */
10929: Select *pRightmost; /* Right-most select in a compound select statement */
10930: Expr *pLimit; /* LIMIT expression. NULL means not used. */
10931: Expr *pOffset; /* OFFSET expression. NULL means not used. */
10932: int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */
10933: int addrOpenEphm[3]; /* OP_OpenEphem opcodes related to this select */
10934: double nSelectRow; /* Estimated number of result rows */
10935: };
10936:
10937: /*
10938: ** Allowed values for Select.selFlags. The "SF" prefix stands for
10939: ** "Select Flag".
10940: */
10941: #define SF_Distinct 0x01 /* Output should be DISTINCT */
10942: #define SF_Resolved 0x02 /* Identifiers have been resolved */
10943: #define SF_Aggregate 0x04 /* Contains aggregate functions */
10944: #define SF_UsesEphemeral 0x08 /* Uses the OpenEphemeral opcode */
10945: #define SF_Expanded 0x10 /* sqlite3SelectExpand() called on this */
10946: #define SF_HasTypeInfo 0x20 /* FROM subqueries have Table metadata */
10947: #define SF_UseSorter 0x40 /* Sort using a sorter */
10948:
10949:
10950: /*
10951: ** The results of a select can be distributed in several ways. The
10952: ** "SRT" prefix means "SELECT Result Type".
10953: */
10954: #define SRT_Union 1 /* Store result as keys in an index */
10955: #define SRT_Except 2 /* Remove result from a UNION index */
10956: #define SRT_Exists 3 /* Store 1 if the result is not empty */
10957: #define SRT_Discard 4 /* Do not save the results anywhere */
10958:
10959: /* The ORDER BY clause is ignored for all of the above */
10960: #define IgnorableOrderby(X) ((X->eDest)<=SRT_Discard)
10961:
10962: #define SRT_Output 5 /* Output each row of result */
10963: #define SRT_Mem 6 /* Store result in a memory cell */
10964: #define SRT_Set 7 /* Store results as keys in an index */
10965: #define SRT_Table 8 /* Store result as data with an automatic rowid */
10966: #define SRT_EphemTab 9 /* Create transient tab and store like SRT_Table */
10967: #define SRT_Coroutine 10 /* Generate a single row of result */
10968:
10969: /*
10970: ** A structure used to customize the behavior of sqlite3Select(). See
10971: ** comments above sqlite3Select() for details.
10972: */
10973: typedef struct SelectDest SelectDest;
10974: struct SelectDest {
10975: u8 eDest; /* How to dispose of the results */
10976: u8 affinity; /* Affinity used when eDest==SRT_Set */
10977: int iParm; /* A parameter used by the eDest disposal method */
10978: int iMem; /* Base register where results are written */
10979: int nMem; /* Number of registers allocated */
10980: };
10981:
10982: /*
10983: ** During code generation of statements that do inserts into AUTOINCREMENT
10984: ** tables, the following information is attached to the Table.u.autoInc.p
10985: ** pointer of each autoincrement table to record some side information that
10986: ** the code generator needs. We have to keep per-table autoincrement
10987: ** information in case inserts are down within triggers. Triggers do not
10988: ** normally coordinate their activities, but we do need to coordinate the
10989: ** loading and saving of autoincrement information.
10990: */
10991: struct AutoincInfo {
10992: AutoincInfo *pNext; /* Next info block in a list of them all */
10993: Table *pTab; /* Table this info block refers to */
10994: int iDb; /* Index in sqlite3.aDb[] of database holding pTab */
10995: int regCtr; /* Memory register holding the rowid counter */
10996: };
10997:
10998: /*
10999: ** Size of the column cache
11000: */
11001: #ifndef SQLITE_N_COLCACHE
11002: # define SQLITE_N_COLCACHE 10
11003: #endif
11004:
11005: /*
11006: ** At least one instance of the following structure is created for each
11007: ** trigger that may be fired while parsing an INSERT, UPDATE or DELETE
11008: ** statement. All such objects are stored in the linked list headed at
11009: ** Parse.pTriggerPrg and deleted once statement compilation has been
11010: ** completed.
11011: **
11012: ** A Vdbe sub-program that implements the body and WHEN clause of trigger
11013: ** TriggerPrg.pTrigger, assuming a default ON CONFLICT clause of
11014: ** TriggerPrg.orconf, is stored in the TriggerPrg.pProgram variable.
11015: ** The Parse.pTriggerPrg list never contains two entries with the same
11016: ** values for both pTrigger and orconf.
11017: **
11018: ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
11019: ** accessed (or set to 0 for triggers fired as a result of INSERT
11020: ** statements). Similarly, the TriggerPrg.aColmask[1] variable is set to
11021: ** a mask of new.* columns used by the program.
11022: */
11023: struct TriggerPrg {
11024: Trigger *pTrigger; /* Trigger this program was coded from */
11025: int orconf; /* Default ON CONFLICT policy */
11026: SubProgram *pProgram; /* Program implementing pTrigger/orconf */
11027: u32 aColmask[2]; /* Masks of old.*, new.* columns accessed */
11028: TriggerPrg *pNext; /* Next entry in Parse.pTriggerPrg list */
11029: };
11030:
11031: /*
11032: ** The yDbMask datatype for the bitmask of all attached databases.
11033: */
11034: #if SQLITE_MAX_ATTACHED>30
11035: typedef sqlite3_uint64 yDbMask;
11036: #else
11037: typedef unsigned int yDbMask;
11038: #endif
11039:
11040: /*
11041: ** An SQL parser context. A copy of this structure is passed through
11042: ** the parser and down into all the parser action routine in order to
11043: ** carry around information that is global to the entire parse.
11044: **
11045: ** The structure is divided into two parts. When the parser and code
11046: ** generate call themselves recursively, the first part of the structure
11047: ** is constant but the second part is reset at the beginning and end of
11048: ** each recursion.
11049: **
11050: ** The nTableLock and aTableLock variables are only used if the shared-cache
11051: ** feature is enabled (if sqlite3Tsd()->useSharedData is true). They are
11052: ** used to store the set of table-locks required by the statement being
11053: ** compiled. Function sqlite3TableLock() is used to add entries to the
11054: ** list.
11055: */
11056: struct Parse {
11057: sqlite3 *db; /* The main database structure */
11058: int rc; /* Return code from execution */
11059: char *zErrMsg; /* An error message */
11060: Vdbe *pVdbe; /* An engine for executing database bytecode */
11061: u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */
11062: u8 checkSchema; /* Causes schema cookie check after an error */
11063: u8 nested; /* Number of nested calls to the parser/code generator */
11064: u8 nTempReg; /* Number of temporary registers in aTempReg[] */
11065: u8 nTempInUse; /* Number of aTempReg[] currently checked out */
11066: int aTempReg[8]; /* Holding area for temporary registers */
11067: int nRangeReg; /* Size of the temporary register block */
11068: int iRangeReg; /* First register in temporary register block */
11069: int nErr; /* Number of errors seen */
11070: int nTab; /* Number of previously allocated VDBE cursors */
11071: int nMem; /* Number of memory cells used so far */
11072: int nSet; /* Number of sets used so far */
11073: int nOnce; /* Number of OP_Once instructions so far */
11074: int ckBase; /* Base register of data during check constraints */
11075: int iCacheLevel; /* ColCache valid when aColCache[].iLevel<=iCacheLevel */
11076: int iCacheCnt; /* Counter used to generate aColCache[].lru values */
11077: u8 nColCache; /* Number of entries in aColCache[] */
11078: u8 iColCache; /* Next entry in aColCache[] to replace */
11079: struct yColCache {
11080: int iTable; /* Table cursor number */
11081: int iColumn; /* Table column number */
11082: u8 tempReg; /* iReg is a temp register that needs to be freed */
11083: int iLevel; /* Nesting level */
11084: int iReg; /* Reg with value of this column. 0 means none. */
11085: int lru; /* Least recently used entry has the smallest value */
11086: } aColCache[SQLITE_N_COLCACHE]; /* One for each column cache entry */
11087: yDbMask writeMask; /* Start a write transaction on these databases */
11088: yDbMask cookieMask; /* Bitmask of schema verified databases */
11089: u8 isMultiWrite; /* True if statement may affect/insert multiple rows */
11090: u8 mayAbort; /* True if statement may throw an ABORT exception */
11091: int cookieGoto; /* Address of OP_Goto to cookie verifier subroutine */
11092: int cookieValue[SQLITE_MAX_ATTACHED+2]; /* Values of cookies to verify */
11093: #ifndef SQLITE_OMIT_SHARED_CACHE
11094: int nTableLock; /* Number of locks in aTableLock */
11095: TableLock *aTableLock; /* Required table locks for shared-cache mode */
11096: #endif
11097: int regRowid; /* Register holding rowid of CREATE TABLE entry */
11098: int regRoot; /* Register holding root page number for new objects */
11099: AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */
11100: int nMaxArg; /* Max args passed to user function by sub-program */
11101:
11102: /* Information used while coding trigger programs. */
11103: Parse *pToplevel; /* Parse structure for main program (or NULL) */
11104: Table *pTriggerTab; /* Table triggers are being coded for */
11105: u32 oldmask; /* Mask of old.* columns referenced */
11106: u32 newmask; /* Mask of new.* columns referenced */
11107: u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */
11108: u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */
11109: u8 disableTriggers; /* True to disable triggers */
11110: double nQueryLoop; /* Estimated number of iterations of a query */
11111:
11112: /* Above is constant between recursions. Below is reset before and after
11113: ** each recursion */
11114:
11115: int nVar; /* Number of '?' variables seen in the SQL so far */
11116: int nzVar; /* Number of available slots in azVar[] */
11117: char **azVar; /* Pointers to names of parameters */
11118: Vdbe *pReprepare; /* VM being reprepared (sqlite3Reprepare()) */
11119: int nAlias; /* Number of aliased result set columns */
11120: int *aAlias; /* Register used to hold aliased result */
11121: u8 explain; /* True if the EXPLAIN flag is found on the query */
11122: Token sNameToken; /* Token with unqualified schema object name */
11123: Token sLastToken; /* The last token parsed */
11124: const char *zTail; /* All SQL text past the last semicolon parsed */
11125: Table *pNewTable; /* A table being constructed by CREATE TABLE */
11126: Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */
11127: const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
11128: #ifndef SQLITE_OMIT_VIRTUALTABLE
11129: Token sArg; /* Complete text of a module argument */
11130: u8 declareVtab; /* True if inside sqlite3_declare_vtab() */
11131: int nVtabLock; /* Number of virtual tables to lock */
11132: Table **apVtabLock; /* Pointer to virtual tables needing locking */
11133: #endif
11134: int nHeight; /* Expression tree height of current sub-select */
11135: Table *pZombieTab; /* List of Table objects to delete after code gen */
11136: TriggerPrg *pTriggerPrg; /* Linked list of coded triggers */
11137:
11138: #ifndef SQLITE_OMIT_EXPLAIN
11139: int iSelectId;
11140: int iNextSelectId;
11141: #endif
11142: };
11143:
11144: #ifdef SQLITE_OMIT_VIRTUALTABLE
11145: #define IN_DECLARE_VTAB 0
11146: #else
11147: #define IN_DECLARE_VTAB (pParse->declareVtab)
11148: #endif
11149:
11150: /*
11151: ** An instance of the following structure can be declared on a stack and used
11152: ** to save the Parse.zAuthContext value so that it can be restored later.
11153: */
11154: struct AuthContext {
11155: const char *zAuthContext; /* Put saved Parse.zAuthContext here */
11156: Parse *pParse; /* The Parse structure */
11157: };
11158:
11159: /*
11160: ** Bitfield flags for P5 value in OP_Insert and OP_Delete
11161: */
11162: #define OPFLAG_NCHANGE 0x01 /* Set to update db->nChange */
11163: #define OPFLAG_LASTROWID 0x02 /* Set to update db->lastRowid */
11164: #define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */
11165: #define OPFLAG_APPEND 0x08 /* This is likely to be an append */
11166: #define OPFLAG_USESEEKRESULT 0x10 /* Try to avoid a seek in BtreeInsert() */
11167: #define OPFLAG_CLEARCACHE 0x20 /* Clear pseudo-table cache in OP_Column */
11168:
11169: /*
11170: * Each trigger present in the database schema is stored as an instance of
11171: * struct Trigger.
11172: *
11173: * Pointers to instances of struct Trigger are stored in two ways.
11174: * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
11175: * database). This allows Trigger structures to be retrieved by name.
11176: * 2. All triggers associated with a single table form a linked list, using the
11177: * pNext member of struct Trigger. A pointer to the first element of the
11178: * linked list is stored as the "pTrigger" member of the associated
11179: * struct Table.
11180: *
11181: * The "step_list" member points to the first element of a linked list
11182: * containing the SQL statements specified as the trigger program.
11183: */
11184: struct Trigger {
11185: char *zName; /* The name of the trigger */
11186: char *table; /* The table or view to which the trigger applies */
11187: u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */
11188: u8 tr_tm; /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
11189: Expr *pWhen; /* The WHEN clause of the expression (may be NULL) */
11190: IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger,
11191: the <column-list> is stored here */
11192: Schema *pSchema; /* Schema containing the trigger */
11193: Schema *pTabSchema; /* Schema containing the table */
11194: TriggerStep *step_list; /* Link list of trigger program steps */
11195: Trigger *pNext; /* Next trigger associated with the table */
11196: };
11197:
11198: /*
11199: ** A trigger is either a BEFORE or an AFTER trigger. The following constants
11200: ** determine which.
11201: **
11202: ** If there are multiple triggers, you might of some BEFORE and some AFTER.
11203: ** In that cases, the constants below can be ORed together.
11204: */
11205: #define TRIGGER_BEFORE 1
11206: #define TRIGGER_AFTER 2
11207:
11208: /*
11209: * An instance of struct TriggerStep is used to store a single SQL statement
11210: * that is a part of a trigger-program.
11211: *
11212: * Instances of struct TriggerStep are stored in a singly linked list (linked
11213: * using the "pNext" member) referenced by the "step_list" member of the
11214: * associated struct Trigger instance. The first element of the linked list is
11215: * the first step of the trigger-program.
11216: *
11217: * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or
11218: * "SELECT" statement. The meanings of the other members is determined by the
11219: * value of "op" as follows:
11220: *
11221: * (op == TK_INSERT)
11222: * orconf -> stores the ON CONFLICT algorithm
11223: * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then
11224: * this stores a pointer to the SELECT statement. Otherwise NULL.
11225: * target -> A token holding the quoted name of the table to insert into.
11226: * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then
11227: * this stores values to be inserted. Otherwise NULL.
11228: * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ...
11229: * statement, then this stores the column-names to be
11230: * inserted into.
11231: *
11232: * (op == TK_DELETE)
11233: * target -> A token holding the quoted name of the table to delete from.
11234: * pWhere -> The WHERE clause of the DELETE statement if one is specified.
11235: * Otherwise NULL.
11236: *
11237: * (op == TK_UPDATE)
11238: * target -> A token holding the quoted name of the table to update rows of.
11239: * pWhere -> The WHERE clause of the UPDATE statement if one is specified.
11240: * Otherwise NULL.
11241: * pExprList -> A list of the columns to update and the expressions to update
11242: * them to. See sqlite3Update() documentation of "pChanges"
11243: * argument.
11244: *
11245: */
11246: struct TriggerStep {
11247: u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
11248: u8 orconf; /* OE_Rollback etc. */
11249: Trigger *pTrig; /* The trigger that this step is a part of */
11250: Select *pSelect; /* SELECT statment or RHS of INSERT INTO .. SELECT ... */
11251: Token target; /* Target table for DELETE, UPDATE, INSERT */
11252: Expr *pWhere; /* The WHERE clause for DELETE or UPDATE steps */
11253: ExprList *pExprList; /* SET clause for UPDATE. VALUES clause for INSERT */
11254: IdList *pIdList; /* Column names for INSERT */
11255: TriggerStep *pNext; /* Next in the link-list */
11256: TriggerStep *pLast; /* Last element in link-list. Valid for 1st elem only */
11257: };
11258:
11259: /*
11260: ** The following structure contains information used by the sqliteFix...
11261: ** routines as they walk the parse tree to make database references
11262: ** explicit.
11263: */
11264: typedef struct DbFixer DbFixer;
11265: struct DbFixer {
11266: Parse *pParse; /* The parsing context. Error messages written here */
11267: const char *zDb; /* Make sure all objects are contained in this database */
11268: const char *zType; /* Type of the container - used for error messages */
11269: const Token *pName; /* Name of the container - used for error messages */
11270: };
11271:
11272: /*
11273: ** An objected used to accumulate the text of a string where we
11274: ** do not necessarily know how big the string will be in the end.
11275: */
11276: struct StrAccum {
11277: sqlite3 *db; /* Optional database for lookaside. Can be NULL */
11278: char *zBase; /* A base allocation. Not from malloc. */
11279: char *zText; /* The string collected so far */
11280: int nChar; /* Length of the string so far */
11281: int nAlloc; /* Amount of space allocated in zText */
11282: int mxAlloc; /* Maximum allowed string length */
11283: u8 mallocFailed; /* Becomes true if any memory allocation fails */
11284: u8 useMalloc; /* 0: none, 1: sqlite3DbMalloc, 2: sqlite3_malloc */
11285: u8 tooBig; /* Becomes true if string size exceeds limits */
11286: };
11287:
11288: /*
11289: ** A pointer to this structure is used to communicate information
11290: ** from sqlite3Init and OP_ParseSchema into the sqlite3InitCallback.
11291: */
11292: typedef struct {
11293: sqlite3 *db; /* The database being initialized */
11294: int iDb; /* 0 for main database. 1 for TEMP, 2.. for ATTACHed */
11295: char **pzErrMsg; /* Error message stored here */
11296: int rc; /* Result code stored here */
11297: } InitData;
11298:
11299: /*
11300: ** Structure containing global configuration data for the SQLite library.
11301: **
11302: ** This structure also contains some state information.
11303: */
11304: struct Sqlite3Config {
11305: int bMemstat; /* True to enable memory status */
11306: int bCoreMutex; /* True to enable core mutexing */
11307: int bFullMutex; /* True to enable full mutexing */
11308: int bOpenUri; /* True to interpret filenames as URIs */
11309: int mxStrlen; /* Maximum string length */
11310: int szLookaside; /* Default lookaside buffer size */
11311: int nLookaside; /* Default lookaside buffer count */
11312: sqlite3_mem_methods m; /* Low-level memory allocation interface */
11313: sqlite3_mutex_methods mutex; /* Low-level mutex interface */
11314: sqlite3_pcache_methods2 pcache2; /* Low-level page-cache interface */
11315: void *pHeap; /* Heap storage space */
11316: int nHeap; /* Size of pHeap[] */
11317: int mnReq, mxReq; /* Min and max heap requests sizes */
11318: void *pScratch; /* Scratch memory */
11319: int szScratch; /* Size of each scratch buffer */
11320: int nScratch; /* Number of scratch buffers */
11321: void *pPage; /* Page cache memory */
11322: int szPage; /* Size of each page in pPage[] */
11323: int nPage; /* Number of pages in pPage[] */
11324: int mxParserStack; /* maximum depth of the parser stack */
11325: int sharedCacheEnabled; /* true if shared-cache mode enabled */
11326: /* The above might be initialized to non-zero. The following need to always
11327: ** initially be zero, however. */
11328: int isInit; /* True after initialization has finished */
11329: int inProgress; /* True while initialization in progress */
11330: int isMutexInit; /* True after mutexes are initialized */
11331: int isMallocInit; /* True after malloc is initialized */
11332: int isPCacheInit; /* True after malloc is initialized */
11333: sqlite3_mutex *pInitMutex; /* Mutex used by sqlite3_initialize() */
11334: int nRefInitMutex; /* Number of users of pInitMutex */
11335: void (*xLog)(void*,int,const char*); /* Function for logging */
11336: void *pLogArg; /* First argument to xLog() */
11337: int bLocaltimeFault; /* True to fail localtime() calls */
11338: };
11339:
11340: /*
11341: ** Context pointer passed down through the tree-walk.
11342: */
11343: struct Walker {
11344: int (*xExprCallback)(Walker*, Expr*); /* Callback for expressions */
11345: int (*xSelectCallback)(Walker*,Select*); /* Callback for SELECTs */
11346: Parse *pParse; /* Parser context. */
11347: union { /* Extra data for callback */
11348: NameContext *pNC; /* Naming context */
11349: int i; /* Integer value */
11350: } u;
11351: };
11352:
11353: /* Forward declarations */
11354: SQLITE_PRIVATE int sqlite3WalkExpr(Walker*, Expr*);
11355: SQLITE_PRIVATE int sqlite3WalkExprList(Walker*, ExprList*);
11356: SQLITE_PRIVATE int sqlite3WalkSelect(Walker*, Select*);
11357: SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker*, Select*);
11358: SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker*, Select*);
11359:
11360: /*
11361: ** Return code from the parse-tree walking primitives and their
11362: ** callbacks.
11363: */
11364: #define WRC_Continue 0 /* Continue down into children */
11365: #define WRC_Prune 1 /* Omit children but continue walking siblings */
11366: #define WRC_Abort 2 /* Abandon the tree walk */
11367:
11368: /*
11369: ** Assuming zIn points to the first byte of a UTF-8 character,
11370: ** advance zIn to point to the first byte of the next UTF-8 character.
11371: */
11372: #define SQLITE_SKIP_UTF8(zIn) { \
11373: if( (*(zIn++))>=0xc0 ){ \
11374: while( (*zIn & 0xc0)==0x80 ){ zIn++; } \
11375: } \
11376: }
11377:
11378: /*
11379: ** The SQLITE_*_BKPT macros are substitutes for the error codes with
11380: ** the same name but without the _BKPT suffix. These macros invoke
11381: ** routines that report the line-number on which the error originated
11382: ** using sqlite3_log(). The routines also provide a convenient place
11383: ** to set a debugger breakpoint.
11384: */
11385: SQLITE_PRIVATE int sqlite3CorruptError(int);
11386: SQLITE_PRIVATE int sqlite3MisuseError(int);
11387: SQLITE_PRIVATE int sqlite3CantopenError(int);
11388: #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
11389: #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
11390: #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
11391:
11392:
11393: /*
11394: ** FTS4 is really an extension for FTS3. It is enabled using the
11395: ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also all
11396: ** the SQLITE_ENABLE_FTS4 macro to serve as an alisse for SQLITE_ENABLE_FTS3.
11397: */
11398: #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
11399: # define SQLITE_ENABLE_FTS3
11400: #endif
11401:
11402: /*
11403: ** The ctype.h header is needed for non-ASCII systems. It is also
11404: ** needed by FTS3 when FTS3 is included in the amalgamation.
11405: */
11406: #if !defined(SQLITE_ASCII) || \
11407: (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION))
11408: # include <ctype.h>
11409: #endif
11410:
11411: /*
11412: ** The following macros mimic the standard library functions toupper(),
11413: ** isspace(), isalnum(), isdigit() and isxdigit(), respectively. The
11414: ** sqlite versions only work for ASCII characters, regardless of locale.
11415: */
11416: #ifdef SQLITE_ASCII
11417: # define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20))
11418: # define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01)
11419: # define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06)
11420: # define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02)
11421: # define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04)
11422: # define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08)
11423: # define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)])
11424: #else
11425: # define sqlite3Toupper(x) toupper((unsigned char)(x))
11426: # define sqlite3Isspace(x) isspace((unsigned char)(x))
11427: # define sqlite3Isalnum(x) isalnum((unsigned char)(x))
11428: # define sqlite3Isalpha(x) isalpha((unsigned char)(x))
11429: # define sqlite3Isdigit(x) isdigit((unsigned char)(x))
11430: # define sqlite3Isxdigit(x) isxdigit((unsigned char)(x))
11431: # define sqlite3Tolower(x) tolower((unsigned char)(x))
11432: #endif
11433:
11434: /*
11435: ** Internal function prototypes
11436: */
11437: SQLITE_PRIVATE int sqlite3StrICmp(const char *, const char *);
11438: SQLITE_PRIVATE int sqlite3Strlen30(const char*);
11439: #define sqlite3StrNICmp sqlite3_strnicmp
11440:
11441: SQLITE_PRIVATE int sqlite3MallocInit(void);
11442: SQLITE_PRIVATE void sqlite3MallocEnd(void);
11443: SQLITE_PRIVATE void *sqlite3Malloc(int);
11444: SQLITE_PRIVATE void *sqlite3MallocZero(int);
11445: SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3*, int);
11446: SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3*, int);
11447: SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3*,const char*);
11448: SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3*,const char*, int);
11449: SQLITE_PRIVATE void *sqlite3Realloc(void*, int);
11450: SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *, void *, int);
11451: SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *, void *, int);
11452: SQLITE_PRIVATE void sqlite3DbFree(sqlite3*, void*);
11453: SQLITE_PRIVATE int sqlite3MallocSize(void*);
11454: SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3*, void*);
11455: SQLITE_PRIVATE void *sqlite3ScratchMalloc(int);
11456: SQLITE_PRIVATE void sqlite3ScratchFree(void*);
11457: SQLITE_PRIVATE void *sqlite3PageMalloc(int);
11458: SQLITE_PRIVATE void sqlite3PageFree(void*);
11459: SQLITE_PRIVATE void sqlite3MemSetDefault(void);
11460: SQLITE_PRIVATE void sqlite3BenignMallocHooks(void (*)(void), void (*)(void));
11461: SQLITE_PRIVATE int sqlite3HeapNearlyFull(void);
11462:
11463: /*
11464: ** On systems with ample stack space and that support alloca(), make
11465: ** use of alloca() to obtain space for large automatic objects. By default,
11466: ** obtain space from malloc().
11467: **
11468: ** The alloca() routine never returns NULL. This will cause code paths
11469: ** that deal with sqlite3StackAlloc() failures to be unreachable.
11470: */
11471: #ifdef SQLITE_USE_ALLOCA
11472: # define sqlite3StackAllocRaw(D,N) alloca(N)
11473: # define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N)
11474: # define sqlite3StackFree(D,P)
11475: #else
11476: # define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N)
11477: # define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N)
11478: # define sqlite3StackFree(D,P) sqlite3DbFree(D,P)
11479: #endif
11480:
11481: #ifdef SQLITE_ENABLE_MEMSYS3
11482: SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
11483: #endif
11484: #ifdef SQLITE_ENABLE_MEMSYS5
11485: SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
11486: #endif
11487:
11488:
11489: #ifndef SQLITE_MUTEX_OMIT
11490: SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void);
11491: SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void);
11492: SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int);
11493: SQLITE_PRIVATE int sqlite3MutexInit(void);
11494: SQLITE_PRIVATE int sqlite3MutexEnd(void);
11495: #endif
11496:
11497: SQLITE_PRIVATE int sqlite3StatusValue(int);
11498: SQLITE_PRIVATE void sqlite3StatusAdd(int, int);
11499: SQLITE_PRIVATE void sqlite3StatusSet(int, int);
11500:
11501: #ifndef SQLITE_OMIT_FLOATING_POINT
11502: SQLITE_PRIVATE int sqlite3IsNaN(double);
11503: #else
11504: # define sqlite3IsNaN(X) 0
11505: #endif
11506:
11507: SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, int, const char*, va_list);
11508: #ifndef SQLITE_OMIT_TRACE
11509: SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, const char*, ...);
11510: #endif
11511: SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3*,const char*, ...);
11512: SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
11513: SQLITE_PRIVATE char *sqlite3MAppendf(sqlite3*,char*,const char*,...);
11514: #if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
11515: SQLITE_PRIVATE void sqlite3DebugPrintf(const char*, ...);
11516: #endif
11517: #if defined(SQLITE_TEST)
11518: SQLITE_PRIVATE void *sqlite3TestTextToPtr(const char*);
11519: #endif
11520:
11521: /* Output formatting for SQLITE_TESTCTRL_EXPLAIN */
11522: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
11523: SQLITE_PRIVATE void sqlite3ExplainBegin(Vdbe*);
11524: SQLITE_PRIVATE void sqlite3ExplainPrintf(Vdbe*, const char*, ...);
11525: SQLITE_PRIVATE void sqlite3ExplainNL(Vdbe*);
11526: SQLITE_PRIVATE void sqlite3ExplainPush(Vdbe*);
11527: SQLITE_PRIVATE void sqlite3ExplainPop(Vdbe*);
11528: SQLITE_PRIVATE void sqlite3ExplainFinish(Vdbe*);
11529: SQLITE_PRIVATE void sqlite3ExplainSelect(Vdbe*, Select*);
11530: SQLITE_PRIVATE void sqlite3ExplainExpr(Vdbe*, Expr*);
11531: SQLITE_PRIVATE void sqlite3ExplainExprList(Vdbe*, ExprList*);
11532: SQLITE_PRIVATE const char *sqlite3VdbeExplanation(Vdbe*);
11533: #else
11534: # define sqlite3ExplainBegin(X)
11535: # define sqlite3ExplainSelect(A,B)
11536: # define sqlite3ExplainExpr(A,B)
11537: # define sqlite3ExplainExprList(A,B)
11538: # define sqlite3ExplainFinish(X)
11539: # define sqlite3VdbeExplanation(X) 0
11540: #endif
11541:
11542:
11543: SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*, ...);
11544: SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...);
11545: SQLITE_PRIVATE int sqlite3Dequote(char*);
11546: SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int);
11547: SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*, char **);
11548: SQLITE_PRIVATE void sqlite3FinishCoding(Parse*);
11549: SQLITE_PRIVATE int sqlite3GetTempReg(Parse*);
11550: SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse*,int);
11551: SQLITE_PRIVATE int sqlite3GetTempRange(Parse*,int);
11552: SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse*,int,int);
11553: SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse*);
11554: SQLITE_PRIVATE Expr *sqlite3ExprAlloc(sqlite3*,int,const Token*,int);
11555: SQLITE_PRIVATE Expr *sqlite3Expr(sqlite3*,int,const char*);
11556: SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*);
11557: SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*, const Token*);
11558: SQLITE_PRIVATE Expr *sqlite3ExprAnd(sqlite3*,Expr*, Expr*);
11559: SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*);
11560: SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*);
11561: SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*);
11562: SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);
11563: SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,Token*,int);
11564: SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*);
11565: SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*);
11566: SQLITE_PRIVATE int sqlite3Init(sqlite3*, char**);
11567: SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**);
11568: SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
11569: SQLITE_PRIVATE void sqlite3ResetInternalSchema(sqlite3*, int);
11570: SQLITE_PRIVATE void sqlite3BeginParse(Parse*,int);
11571: SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
11572: SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*);
11573: SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *, int);
11574: SQLITE_PRIVATE void sqlite3StartTable(Parse*,Token*,Token*,int,int,int,int);
11575: SQLITE_PRIVATE void sqlite3AddColumn(Parse*,Token*);
11576: SQLITE_PRIVATE void sqlite3AddNotNull(Parse*, int);
11577: SQLITE_PRIVATE void sqlite3AddPrimaryKey(Parse*, ExprList*, int, int, int);
11578: SQLITE_PRIVATE void sqlite3AddCheckConstraint(Parse*, Expr*);
11579: SQLITE_PRIVATE void sqlite3AddColumnType(Parse*,Token*);
11580: SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse*,ExprSpan*);
11581: SQLITE_PRIVATE void sqlite3AddCollateType(Parse*, Token*);
11582: SQLITE_PRIVATE void sqlite3EndTable(Parse*,Token*,Token*,Select*);
11583: SQLITE_PRIVATE int sqlite3ParseUri(const char*,const char*,unsigned int*,
11584: sqlite3_vfs**,char**,char **);
11585: SQLITE_PRIVATE int sqlite3CodeOnce(Parse *);
11586:
11587: SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32);
11588: SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec*, u32);
11589: SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec*, u32);
11590: SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec*, u32, void*);
11591: SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec*);
11592: SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*);
11593: SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int,int*);
11594:
11595: SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3*, void*, unsigned int);
11596: SQLITE_PRIVATE void sqlite3RowSetClear(RowSet*);
11597: SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet*, i64);
11598: SQLITE_PRIVATE int sqlite3RowSetTest(RowSet*, u8 iBatch, i64);
11599: SQLITE_PRIVATE int sqlite3RowSetNext(RowSet*, i64*);
11600:
11601: SQLITE_PRIVATE void sqlite3CreateView(Parse*,Token*,Token*,Token*,Select*,int,int);
11602:
11603: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
11604: SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse*,Table*);
11605: #else
11606: # define sqlite3ViewGetColumnNames(A,B) 0
11607: #endif
11608:
11609: SQLITE_PRIVATE void sqlite3DropTable(Parse*, SrcList*, int, int);
11610: SQLITE_PRIVATE void sqlite3CodeDropTable(Parse*, Table*, int, int);
11611: SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3*, Table*);
11612: #ifndef SQLITE_OMIT_AUTOINCREMENT
11613: SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse);
11614: SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse);
11615: #else
11616: # define sqlite3AutoincrementBegin(X)
11617: # define sqlite3AutoincrementEnd(X)
11618: #endif
11619: SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, ExprList*, Select*, IdList*, int);
11620: SQLITE_PRIVATE void *sqlite3ArrayAllocate(sqlite3*,void*,int,int,int*,int*,int*);
11621: SQLITE_PRIVATE IdList *sqlite3IdListAppend(sqlite3*, IdList*, Token*);
11622: SQLITE_PRIVATE int sqlite3IdListIndex(IdList*,const char*);
11623: SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(sqlite3*, SrcList*, int, int);
11624: SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(sqlite3*, SrcList*, Token*, Token*);
11625: SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*,
11626: Token*, Select*, Expr*, IdList*);
11627: SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
11628: SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *, struct SrcList_item *);
11629: SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList*);
11630: SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse*, SrcList*);
11631: SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3*, IdList*);
11632: SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3*, SrcList*);
11633: SQLITE_PRIVATE Index *sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,int,Token*,
11634: Token*, int, int);
11635: SQLITE_PRIVATE void sqlite3DropIndex(Parse*, SrcList*, int);
11636: SQLITE_PRIVATE int sqlite3Select(Parse*, Select*, SelectDest*);
11637: SQLITE_PRIVATE Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*,
11638: Expr*,ExprList*,int,Expr*,Expr*);
11639: SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3*, Select*);
11640: SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse*, SrcList*);
11641: SQLITE_PRIVATE int sqlite3IsReadOnly(Parse*, Table*, int);
11642: SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
11643: #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
11644: SQLITE_PRIVATE Expr *sqlite3LimitWhere(Parse *, SrcList *, Expr *, ExprList *, Expr *, Expr *, char *);
11645: #endif
11646: SQLITE_PRIVATE void sqlite3DeleteFrom(Parse*, SrcList*, Expr*);
11647: SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int);
11648: SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(Parse*, SrcList*, Expr*, ExprList**,ExprList*,u16);
11649: SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*);
11650: SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int);
11651: SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int);
11652: SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int);
11653: SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse*, int, int, int);
11654: SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse*, int, int, int);
11655: SQLITE_PRIVATE void sqlite3ExprCachePush(Parse*);
11656: SQLITE_PRIVATE void sqlite3ExprCachePop(Parse*, int);
11657: SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse*, int, int);
11658: SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse*);
11659: SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse*, int, int);
11660: SQLITE_PRIVATE int sqlite3ExprCode(Parse*, Expr*, int);
11661: SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse*, Expr*, int*);
11662: SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse*, Expr*, int);
11663: SQLITE_PRIVATE int sqlite3ExprCodeAndCache(Parse*, Expr*, int);
11664: SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse*, Expr*);
11665: SQLITE_PRIVATE int sqlite3ExprCodeExprList(Parse*, ExprList*, int, int);
11666: SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse*, Expr*, int, int);
11667: SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse*, Expr*, int, int);
11668: SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3*,const char*, const char*);
11669: SQLITE_PRIVATE Table *sqlite3LocateTable(Parse*,int isView,const char*, const char*);
11670: SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3*,const char*, const char*);
11671: SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
11672: SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
11673: SQLITE_PRIVATE void sqlite3Vacuum(Parse*);
11674: SQLITE_PRIVATE int sqlite3RunVacuum(char**, sqlite3*);
11675: SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, Token*);
11676: SQLITE_PRIVATE int sqlite3ExprCompare(Expr*, Expr*);
11677: SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList*, ExprList*);
11678: SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
11679: SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
11680: SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*);
11681: SQLITE_PRIVATE void sqlite3PrngSaveState(void);
11682: SQLITE_PRIVATE void sqlite3PrngRestoreState(void);
11683: SQLITE_PRIVATE void sqlite3PrngResetState(void);
11684: SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3*);
11685: SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse*, int);
11686: SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse*, const char *zDb);
11687: SQLITE_PRIVATE void sqlite3BeginTransaction(Parse*, int);
11688: SQLITE_PRIVATE void sqlite3CommitTransaction(Parse*);
11689: SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse*);
11690: SQLITE_PRIVATE void sqlite3Savepoint(Parse*, int, Token*);
11691: SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *);
11692: SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr*);
11693: SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*);
11694: SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*);
11695: SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr*, int*);
11696: SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr*);
11697: SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(Vdbe*, const Expr*, int, int);
11698: SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr*, char);
11699: SQLITE_PRIVATE int sqlite3IsRowid(const char*);
11700: SQLITE_PRIVATE void sqlite3GenerateRowDelete(Parse*, Table*, int, int, int, Trigger *, int);
11701: SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int*);
11702: SQLITE_PRIVATE int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int);
11703: SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int,int,
11704: int*,int,int,int,int,int*);
11705: SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*, Table*, int, int, int*, int, int, int);
11706: SQLITE_PRIVATE int sqlite3OpenTableAndIndices(Parse*, Table*, int, int);
11707: SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int);
11708: SQLITE_PRIVATE void sqlite3MultiWrite(Parse*);
11709: SQLITE_PRIVATE void sqlite3MayAbort(Parse*);
11710: SQLITE_PRIVATE void sqlite3HaltConstraint(Parse*, int, char*, int);
11711: SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3*,Expr*,int);
11712: SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,ExprList*,int);
11713: SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,SrcList*,int);
11714: SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,IdList*);
11715: SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,Select*,int);
11716: SQLITE_PRIVATE void sqlite3FuncDefInsert(FuncDefHash*, FuncDef*);
11717: SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,int,u8,int);
11718: SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3*);
11719: SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void);
11720: SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void);
11721: SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3*);
11722: SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3*);
11723: SQLITE_PRIVATE void sqlite3ChangeCookie(Parse*, int);
11724:
11725: #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
11726: SQLITE_PRIVATE void sqlite3MaterializeView(Parse*, Table*, Expr*, int);
11727: #endif
11728:
11729: #ifndef SQLITE_OMIT_TRIGGER
11730: SQLITE_PRIVATE void sqlite3BeginTrigger(Parse*, Token*,Token*,int,int,IdList*,SrcList*,
11731: Expr*,int, int);
11732: SQLITE_PRIVATE void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*);
11733: SQLITE_PRIVATE void sqlite3DropTrigger(Parse*, SrcList*, int);
11734: SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse*, Trigger*);
11735: SQLITE_PRIVATE Trigger *sqlite3TriggersExist(Parse *, Table*, int, ExprList*, int *pMask);
11736: SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *, Table *);
11737: SQLITE_PRIVATE void sqlite3CodeRowTrigger(Parse*, Trigger *, int, ExprList*, int, Table *,
11738: int, int, int);
11739: SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int);
11740: void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*);
11741: SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*);
11742: SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*);
11743: SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(sqlite3*,Token*, IdList*,
11744: ExprList*,Select*,u8);
11745: SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(sqlite3*,Token*,ExprList*, Expr*, u8);
11746: SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(sqlite3*,Token*, Expr*);
11747: SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3*, Trigger*);
11748: SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*);
11749: SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int);
11750: # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
11751: #else
11752: # define sqlite3TriggersExist(B,C,D,E,F) 0
11753: # define sqlite3DeleteTrigger(A,B)
11754: # define sqlite3DropTriggerPtr(A,B)
11755: # define sqlite3UnlinkAndDeleteTrigger(A,B,C)
11756: # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
11757: # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F)
11758: # define sqlite3TriggerList(X, Y) 0
11759: # define sqlite3ParseToplevel(p) p
11760: # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
11761: #endif
11762:
11763: SQLITE_PRIVATE int sqlite3JoinType(Parse*, Token*, Token*, Token*);
11764: SQLITE_PRIVATE void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*, int);
11765: SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse*, int);
11766: #ifndef SQLITE_OMIT_AUTHORIZATION
11767: SQLITE_PRIVATE void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*);
11768: SQLITE_PRIVATE int sqlite3AuthCheck(Parse*,int, const char*, const char*, const char*);
11769: SQLITE_PRIVATE void sqlite3AuthContextPush(Parse*, AuthContext*, const char*);
11770: SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext*);
11771: SQLITE_PRIVATE int sqlite3AuthReadCol(Parse*, const char *, const char *, int);
11772: #else
11773: # define sqlite3AuthRead(a,b,c,d)
11774: # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK
11775: # define sqlite3AuthContextPush(a,b,c)
11776: # define sqlite3AuthContextPop(a) ((void)(a))
11777: #endif
11778: SQLITE_PRIVATE void sqlite3Attach(Parse*, Expr*, Expr*, Expr*);
11779: SQLITE_PRIVATE void sqlite3Detach(Parse*, Expr*);
11780: SQLITE_PRIVATE int sqlite3FixInit(DbFixer*, Parse*, int, const char*, const Token*);
11781: SQLITE_PRIVATE int sqlite3FixSrcList(DbFixer*, SrcList*);
11782: SQLITE_PRIVATE int sqlite3FixSelect(DbFixer*, Select*);
11783: SQLITE_PRIVATE int sqlite3FixExpr(DbFixer*, Expr*);
11784: SQLITE_PRIVATE int sqlite3FixExprList(DbFixer*, ExprList*);
11785: SQLITE_PRIVATE int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);
11786: SQLITE_PRIVATE int sqlite3AtoF(const char *z, double*, int, u8);
11787: SQLITE_PRIVATE int sqlite3GetInt32(const char *, int*);
11788: SQLITE_PRIVATE int sqlite3Atoi(const char*);
11789: SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *pData, int nChar);
11790: SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *pData, int nByte);
11791: SQLITE_PRIVATE u32 sqlite3Utf8Read(const u8*, const u8**);
11792:
11793: /*
11794: ** Routines to read and write variable-length integers. These used to
11795: ** be defined locally, but now we use the varint routines in the util.c
11796: ** file. Code should use the MACRO forms below, as the Varint32 versions
11797: ** are coded to assume the single byte case is already handled (which
11798: ** the MACRO form does).
11799: */
11800: SQLITE_PRIVATE int sqlite3PutVarint(unsigned char*, u64);
11801: SQLITE_PRIVATE int sqlite3PutVarint32(unsigned char*, u32);
11802: SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *, u64 *);
11803: SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *, u32 *);
11804: SQLITE_PRIVATE int sqlite3VarintLen(u64 v);
11805:
11806: /*
11807: ** The header of a record consists of a sequence variable-length integers.
11808: ** These integers are almost always small and are encoded as a single byte.
11809: ** The following macros take advantage this fact to provide a fast encode
11810: ** and decode of the integers in a record header. It is faster for the common
11811: ** case where the integer is a single byte. It is a little slower when the
11812: ** integer is two or more bytes. But overall it is faster.
11813: **
11814: ** The following expressions are equivalent:
11815: **
11816: ** x = sqlite3GetVarint32( A, &B );
11817: ** x = sqlite3PutVarint32( A, B );
11818: **
11819: ** x = getVarint32( A, B );
11820: ** x = putVarint32( A, B );
11821: **
11822: */
11823: #define getVarint32(A,B) (u8)((*(A)<(u8)0x80) ? ((B) = (u32)*(A)),1 : sqlite3GetVarint32((A), (u32 *)&(B)))
11824: #define putVarint32(A,B) (u8)(((u32)(B)<(u32)0x80) ? (*(A) = (unsigned char)(B)),1 : sqlite3PutVarint32((A), (B)))
11825: #define getVarint sqlite3GetVarint
11826: #define putVarint sqlite3PutVarint
11827:
11828:
11829: SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *, Index *);
11830: SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *, Table *);
11831: SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2);
11832: SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
11833: SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr);
11834: SQLITE_PRIVATE int sqlite3Atoi64(const char*, i64*, int, u8);
11835: SQLITE_PRIVATE void sqlite3Error(sqlite3*, int, const char*,...);
11836: SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
11837: SQLITE_PRIVATE u8 sqlite3HexToInt(int h);
11838: SQLITE_PRIVATE int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
11839: SQLITE_PRIVATE const char *sqlite3ErrStr(int);
11840: SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse);
11841: SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);
11842: SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
11843: SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
11844: SQLITE_PRIVATE Expr *sqlite3ExprSetColl(Expr*, CollSeq*);
11845: SQLITE_PRIVATE Expr *sqlite3ExprSetCollByToken(Parse *pParse, Expr*, Token*);
11846: SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *, CollSeq *);
11847: SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *, const char *);
11848: SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, int);
11849: SQLITE_PRIVATE int sqlite3AddInt64(i64*,i64);
11850: SQLITE_PRIVATE int sqlite3SubInt64(i64*,i64);
11851: SQLITE_PRIVATE int sqlite3MulInt64(i64*,i64);
11852: SQLITE_PRIVATE int sqlite3AbsInt32(int);
11853: #ifdef SQLITE_ENABLE_8_3_NAMES
11854: SQLITE_PRIVATE void sqlite3FileSuffix3(const char*, char*);
11855: #else
11856: # define sqlite3FileSuffix3(X,Y)
11857: #endif
11858: SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z);
11859:
11860: SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value*, u8);
11861: SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value*, u8);
11862: SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
11863: void(*)(void*));
11864: SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*);
11865: SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *);
11866: SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8);
11867: #ifdef SQLITE_ENABLE_STAT3
11868: SQLITE_PRIVATE char *sqlite3Utf8to16(sqlite3 *, u8, char *, int, int *);
11869: #endif
11870: SQLITE_PRIVATE int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **);
11871: SQLITE_PRIVATE void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
11872: #ifndef SQLITE_AMALGAMATION
11873: SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[];
11874: SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[];
11875: SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[];
11876: SQLITE_PRIVATE const Token sqlite3IntTokens[];
11877: SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config;
11878: SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
11879: #ifndef SQLITE_OMIT_WSD
11880: SQLITE_PRIVATE int sqlite3PendingByte;
11881: #endif
11882: #endif
11883: SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3*, int, int, int);
11884: SQLITE_PRIVATE void sqlite3Reindex(Parse*, Token*, Token*);
11885: SQLITE_PRIVATE void sqlite3AlterFunctions(void);
11886: SQLITE_PRIVATE void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
11887: SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *, int *);
11888: SQLITE_PRIVATE void sqlite3NestedParse(Parse*, const char*, ...);
11889: SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*);
11890: SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *, Expr *, int, int);
11891: SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*);
11892: SQLITE_PRIVATE int sqlite3ResolveExprNames(NameContext*, Expr*);
11893: SQLITE_PRIVATE void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*);
11894: SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*);
11895: SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
11896: SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *);
11897: SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
11898: SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(sqlite3*, u8, CollSeq *, const char*);
11899: SQLITE_PRIVATE char sqlite3AffinityType(const char*);
11900: SQLITE_PRIVATE void sqlite3Analyze(Parse*, Token*, Token*);
11901: SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler*);
11902: SQLITE_PRIVATE int sqlite3FindDb(sqlite3*, Token*);
11903: SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *, const char *);
11904: SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3*,int iDB);
11905: SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3*,Index*);
11906: SQLITE_PRIVATE void sqlite3DefaultRowEst(Index*);
11907: SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3*, int);
11908: SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*);
11909: SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse*, int, int);
11910: SQLITE_PRIVATE void sqlite3SchemaClear(void *);
11911: SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
11912: SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
11913: SQLITE_PRIVATE KeyInfo *sqlite3IndexKeyinfo(Parse *, Index *);
11914: SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
11915: void (*)(sqlite3_context*,int,sqlite3_value **),
11916: void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*),
11917: FuncDestructor *pDestructor
11918: );
11919: SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int);
11920: SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *);
11921:
11922: SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum*, char*, int, int);
11923: SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum*,const char*,int);
11924: SQLITE_PRIVATE void sqlite3AppendSpace(StrAccum*,int);
11925: SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum*);
11926: SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum*);
11927: SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest*,int,int);
11928: SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *, SrcList *, int, int);
11929:
11930: SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *);
11931: SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *, Pgno, const u8 *);
11932:
11933: /*
11934: ** The interface to the LEMON-generated parser
11935: */
11936: SQLITE_PRIVATE void *sqlite3ParserAlloc(void*(*)(size_t));
11937: SQLITE_PRIVATE void sqlite3ParserFree(void*, void(*)(void*));
11938: SQLITE_PRIVATE void sqlite3Parser(void*, int, Token, Parse*);
11939: #ifdef YYTRACKMAXSTACKDEPTH
11940: SQLITE_PRIVATE int sqlite3ParserStackPeak(void*);
11941: #endif
11942:
11943: SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3*);
11944: #ifndef SQLITE_OMIT_LOAD_EXTENSION
11945: SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3*);
11946: #else
11947: # define sqlite3CloseExtensions(X)
11948: #endif
11949:
11950: #ifndef SQLITE_OMIT_SHARED_CACHE
11951: SQLITE_PRIVATE void sqlite3TableLock(Parse *, int, int, u8, const char *);
11952: #else
11953: #define sqlite3TableLock(v,w,x,y,z)
11954: #endif
11955:
11956: #ifdef SQLITE_TEST
11957: SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char*);
11958: #endif
11959:
11960: #ifdef SQLITE_OMIT_VIRTUALTABLE
11961: # define sqlite3VtabClear(Y)
11962: # define sqlite3VtabSync(X,Y) SQLITE_OK
11963: # define sqlite3VtabRollback(X)
11964: # define sqlite3VtabCommit(X)
11965: # define sqlite3VtabInSync(db) 0
11966: # define sqlite3VtabLock(X)
11967: # define sqlite3VtabUnlock(X)
11968: # define sqlite3VtabUnlockList(X)
11969: # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK
11970: # define sqlite3GetVTable(X,Y) ((VTable*)0)
11971: #else
11972: SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table*);
11973: SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, char **);
11974: SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db);
11975: SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db);
11976: SQLITE_PRIVATE void sqlite3VtabLock(VTable *);
11977: SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *);
11978: SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3*);
11979: SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *, int, int);
11980: SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3*, Table*);
11981: # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0)
11982: #endif
11983: SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse*,Table*);
11984: SQLITE_PRIVATE void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*);
11985: SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse*, Token*);
11986: SQLITE_PRIVATE void sqlite3VtabArgInit(Parse*);
11987: SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse*, Token*);
11988: SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **);
11989: SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse*, Table*);
11990: SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3*, int, const char *);
11991: SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *, VTable *);
11992: SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*);
11993: SQLITE_PRIVATE void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**);
11994: SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
11995: SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
11996: SQLITE_PRIVATE int sqlite3Reprepare(Vdbe*);
11997: SQLITE_PRIVATE void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*);
11998: SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq(Parse *, Expr *, Expr *);
11999: SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3*);
12000: SQLITE_PRIVATE const char *sqlite3JournalModename(int);
12001: SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3*, int, int, int*, int*);
12002: SQLITE_PRIVATE int sqlite3WalDefaultHook(void*,sqlite3*,const char*,int);
12003:
12004: /* Declarations for functions in fkey.c. All of these are replaced by
12005: ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
12006: ** key functionality is available. If OMIT_TRIGGER is defined but
12007: ** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In
12008: ** this case foreign keys are parsed, but no other functionality is
12009: ** provided (enforcement of FK constraints requires the triggers sub-system).
12010: */
12011: #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
12012: SQLITE_PRIVATE void sqlite3FkCheck(Parse*, Table*, int, int);
12013: SQLITE_PRIVATE void sqlite3FkDropTable(Parse*, SrcList *, Table*);
12014: SQLITE_PRIVATE void sqlite3FkActions(Parse*, Table*, ExprList*, int);
12015: SQLITE_PRIVATE int sqlite3FkRequired(Parse*, Table*, int*, int);
12016: SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*);
12017: SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *);
12018: #else
12019: #define sqlite3FkActions(a,b,c,d)
12020: #define sqlite3FkCheck(a,b,c,d)
12021: #define sqlite3FkDropTable(a,b,c)
12022: #define sqlite3FkOldmask(a,b) 0
12023: #define sqlite3FkRequired(a,b,c,d) 0
12024: #endif
12025: #ifndef SQLITE_OMIT_FOREIGN_KEY
12026: SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *, Table*);
12027: #else
12028: #define sqlite3FkDelete(a,b)
12029: #endif
12030:
12031:
12032: /*
12033: ** Available fault injectors. Should be numbered beginning with 0.
12034: */
12035: #define SQLITE_FAULTINJECTOR_MALLOC 0
12036: #define SQLITE_FAULTINJECTOR_COUNT 1
12037:
12038: /*
12039: ** The interface to the code in fault.c used for identifying "benign"
12040: ** malloc failures. This is only present if SQLITE_OMIT_BUILTIN_TEST
12041: ** is not defined.
12042: */
12043: #ifndef SQLITE_OMIT_BUILTIN_TEST
12044: SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void);
12045: SQLITE_PRIVATE void sqlite3EndBenignMalloc(void);
12046: #else
12047: #define sqlite3BeginBenignMalloc()
12048: #define sqlite3EndBenignMalloc()
12049: #endif
12050:
12051: #define IN_INDEX_ROWID 1
12052: #define IN_INDEX_EPH 2
12053: #define IN_INDEX_INDEX 3
12054: SQLITE_PRIVATE int sqlite3FindInIndex(Parse *, Expr *, int*);
12055:
12056: #ifdef SQLITE_ENABLE_ATOMIC_WRITE
12057: SQLITE_PRIVATE int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int);
12058: SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *);
12059: SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *);
12060: #else
12061: #define sqlite3JournalSize(pVfs) ((pVfs)->szOsFile)
12062: #endif
12063:
12064: SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *);
12065: SQLITE_PRIVATE int sqlite3MemJournalSize(void);
12066: SQLITE_PRIVATE int sqlite3IsMemJournal(sqlite3_file *);
12067:
12068: #if SQLITE_MAX_EXPR_DEPTH>0
12069: SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p);
12070: SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *);
12071: SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse*, int);
12072: #else
12073: #define sqlite3ExprSetHeight(x,y)
12074: #define sqlite3SelectExprHeight(x) 0
12075: #define sqlite3ExprCheckHeight(x,y)
12076: #endif
12077:
12078: SQLITE_PRIVATE u32 sqlite3Get4byte(const u8*);
12079: SQLITE_PRIVATE void sqlite3Put4byte(u8*, u32);
12080:
12081: #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
12082: SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *, sqlite3 *);
12083: SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db);
12084: SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db);
12085: #else
12086: #define sqlite3ConnectionBlocked(x,y)
12087: #define sqlite3ConnectionUnlocked(x)
12088: #define sqlite3ConnectionClosed(x)
12089: #endif
12090:
12091: #ifdef SQLITE_DEBUG
12092: SQLITE_PRIVATE void sqlite3ParserTrace(FILE*, char *);
12093: #endif
12094:
12095: /*
12096: ** If the SQLITE_ENABLE IOTRACE exists then the global variable
12097: ** sqlite3IoTrace is a pointer to a printf-like routine used to
12098: ** print I/O tracing messages.
12099: */
12100: #ifdef SQLITE_ENABLE_IOTRACE
12101: # define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; }
12102: SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe*);
12103: SQLITE_PRIVATE void (*sqlite3IoTrace)(const char*,...);
12104: #else
12105: # define IOTRACE(A)
12106: # define sqlite3VdbeIOTraceSql(X)
12107: #endif
12108:
12109: /*
12110: ** These routines are available for the mem2.c debugging memory allocator
12111: ** only. They are used to verify that different "types" of memory
12112: ** allocations are properly tracked by the system.
12113: **
12114: ** sqlite3MemdebugSetType() sets the "type" of an allocation to one of
12115: ** the MEMTYPE_* macros defined below. The type must be a bitmask with
12116: ** a single bit set.
12117: **
12118: ** sqlite3MemdebugHasType() returns true if any of the bits in its second
12119: ** argument match the type set by the previous sqlite3MemdebugSetType().
12120: ** sqlite3MemdebugHasType() is intended for use inside assert() statements.
12121: **
12122: ** sqlite3MemdebugNoType() returns true if none of the bits in its second
12123: ** argument match the type set by the previous sqlite3MemdebugSetType().
12124: **
12125: ** Perhaps the most important point is the difference between MEMTYPE_HEAP
12126: ** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means
12127: ** it might have been allocated by lookaside, except the allocation was
12128: ** too large or lookaside was already full. It is important to verify
12129: ** that allocations that might have been satisfied by lookaside are not
12130: ** passed back to non-lookaside free() routines. Asserts such as the
12131: ** example above are placed on the non-lookaside free() routines to verify
12132: ** this constraint.
12133: **
12134: ** All of this is no-op for a production build. It only comes into
12135: ** play when the SQLITE_MEMDEBUG compile-time option is used.
12136: */
12137: #ifdef SQLITE_MEMDEBUG
12138: SQLITE_PRIVATE void sqlite3MemdebugSetType(void*,u8);
12139: SQLITE_PRIVATE int sqlite3MemdebugHasType(void*,u8);
12140: SQLITE_PRIVATE int sqlite3MemdebugNoType(void*,u8);
12141: #else
12142: # define sqlite3MemdebugSetType(X,Y) /* no-op */
12143: # define sqlite3MemdebugHasType(X,Y) 1
12144: # define sqlite3MemdebugNoType(X,Y) 1
12145: #endif
12146: #define MEMTYPE_HEAP 0x01 /* General heap allocations */
12147: #define MEMTYPE_LOOKASIDE 0x02 /* Might have been lookaside memory */
12148: #define MEMTYPE_SCRATCH 0x04 /* Scratch allocations */
12149: #define MEMTYPE_PCACHE 0x08 /* Page cache allocations */
12150: #define MEMTYPE_DB 0x10 /* Uses sqlite3DbMalloc, not sqlite_malloc */
12151:
12152: #endif /* _SQLITEINT_H_ */
12153:
12154: /************** End of sqliteInt.h *******************************************/
12155: /************** Begin file global.c ******************************************/
12156: /*
12157: ** 2008 June 13
12158: **
12159: ** The author disclaims copyright to this source code. In place of
12160: ** a legal notice, here is a blessing:
12161: **
12162: ** May you do good and not evil.
12163: ** May you find forgiveness for yourself and forgive others.
12164: ** May you share freely, never taking more than you give.
12165: **
12166: *************************************************************************
12167: **
12168: ** This file contains definitions of global variables and contants.
12169: */
12170:
12171: /* An array to map all upper-case characters into their corresponding
12172: ** lower-case character.
12173: **
12174: ** SQLite only considers US-ASCII (or EBCDIC) characters. We do not
12175: ** handle case conversions for the UTF character set since the tables
12176: ** involved are nearly as big or bigger than SQLite itself.
12177: */
12178: SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[] = {
12179: #ifdef SQLITE_ASCII
12180: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
12181: 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
12182: 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
12183: 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
12184: 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,
12185: 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
12186: 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
12187: 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
12188: 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
12189: 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
12190: 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
12191: 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
12192: 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
12193: 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
12194: 252,253,254,255
12195: #endif
12196: #ifdef SQLITE_EBCDIC
12197: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, /* 0x */
12198: 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* 1x */
12199: 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, /* 2x */
12200: 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, /* 3x */
12201: 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, /* 4x */
12202: 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, /* 5x */
12203: 96, 97, 66, 67, 68, 69, 70, 71, 72, 73,106,107,108,109,110,111, /* 6x */
12204: 112, 81, 82, 83, 84, 85, 86, 87, 88, 89,122,123,124,125,126,127, /* 7x */
12205: 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, /* 8x */
12206: 144,145,146,147,148,149,150,151,152,153,154,155,156,157,156,159, /* 9x */
12207: 160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175, /* Ax */
12208: 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191, /* Bx */
12209: 192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207, /* Cx */
12210: 208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223, /* Dx */
12211: 224,225,162,163,164,165,166,167,168,169,232,203,204,205,206,207, /* Ex */
12212: 239,240,241,242,243,244,245,246,247,248,249,219,220,221,222,255, /* Fx */
12213: #endif
12214: };
12215:
12216: /*
12217: ** The following 256 byte lookup table is used to support SQLites built-in
12218: ** equivalents to the following standard library functions:
12219: **
12220: ** isspace() 0x01
12221: ** isalpha() 0x02
12222: ** isdigit() 0x04
12223: ** isalnum() 0x06
12224: ** isxdigit() 0x08
12225: ** toupper() 0x20
12226: ** SQLite identifier character 0x40
12227: **
12228: ** Bit 0x20 is set if the mapped character requires translation to upper
12229: ** case. i.e. if the character is a lower-case ASCII character.
12230: ** If x is a lower-case ASCII character, then its upper-case equivalent
12231: ** is (x - 0x20). Therefore toupper() can be implemented as:
12232: **
12233: ** (x & ~(map[x]&0x20))
12234: **
12235: ** Standard function tolower() is implemented using the sqlite3UpperToLower[]
12236: ** array. tolower() is used more often than toupper() by SQLite.
12237: **
12238: ** Bit 0x40 is set if the character non-alphanumeric and can be used in an
12239: ** SQLite identifier. Identifiers are alphanumerics, "_", "$", and any
12240: ** non-ASCII UTF character. Hence the test for whether or not a character is
12241: ** part of an identifier is 0x46.
12242: **
12243: ** SQLite's versions are identical to the standard versions assuming a
12244: ** locale of "C". They are implemented as macros in sqliteInt.h.
12245: */
12246: #ifdef SQLITE_ASCII
12247: SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[256] = {
12248: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 00..07 ........ */
12249: 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, /* 08..0f ........ */
12250: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 10..17 ........ */
12251: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 18..1f ........ */
12252: 0x01, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, /* 20..27 !"#$%&' */
12253: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 28..2f ()*+,-./ */
12254: 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, /* 30..37 01234567 */
12255: 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 38..3f 89:;<=>? */
12256:
12257: 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02, /* 40..47 @ABCDEFG */
12258: 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 48..4f HIJKLMNO */
12259: 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, /* 50..57 PQRSTUVW */
12260: 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x40, /* 58..5f XYZ[\]^_ */
12261: 0x00, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22, /* 60..67 `abcdefg */
12262: 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 68..6f hijklmno */
12263: 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, /* 70..77 pqrstuvw */
12264: 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, /* 78..7f xyz{|}~. */
12265:
12266: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 80..87 ........ */
12267: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 88..8f ........ */
12268: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 90..97 ........ */
12269: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* 98..9f ........ */
12270: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a0..a7 ........ */
12271: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* a8..af ........ */
12272: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b0..b7 ........ */
12273: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* b8..bf ........ */
12274:
12275: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c0..c7 ........ */
12276: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* c8..cf ........ */
12277: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d0..d7 ........ */
12278: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* d8..df ........ */
12279: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e0..e7 ........ */
12280: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* e8..ef ........ */
12281: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, /* f0..f7 ........ */
12282: 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40 /* f8..ff ........ */
12283: };
12284: #endif
12285:
12286: #ifndef SQLITE_USE_URI
12287: # define SQLITE_USE_URI 0
12288: #endif
12289:
12290: /*
12291: ** The following singleton contains the global configuration for
12292: ** the SQLite library.
12293: */
12294: SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = {
12295: SQLITE_DEFAULT_MEMSTATUS, /* bMemstat */
12296: 1, /* bCoreMutex */
12297: SQLITE_THREADSAFE==1, /* bFullMutex */
12298: SQLITE_USE_URI, /* bOpenUri */
12299: 0x7ffffffe, /* mxStrlen */
12300: 128, /* szLookaside */
12301: 500, /* nLookaside */
12302: {0,0,0,0,0,0,0,0}, /* m */
12303: {0,0,0,0,0,0,0,0,0}, /* mutex */
12304: {0,0,0,0,0,0,0,0,0,0,0,0,0},/* pcache2 */
12305: (void*)0, /* pHeap */
12306: 0, /* nHeap */
12307: 0, 0, /* mnHeap, mxHeap */
12308: (void*)0, /* pScratch */
12309: 0, /* szScratch */
12310: 0, /* nScratch */
12311: (void*)0, /* pPage */
12312: 0, /* szPage */
12313: 0, /* nPage */
12314: 0, /* mxParserStack */
12315: 0, /* sharedCacheEnabled */
12316: /* All the rest should always be initialized to zero */
12317: 0, /* isInit */
12318: 0, /* inProgress */
12319: 0, /* isMutexInit */
12320: 0, /* isMallocInit */
12321: 0, /* isPCacheInit */
12322: 0, /* pInitMutex */
12323: 0, /* nRefInitMutex */
12324: 0, /* xLog */
12325: 0, /* pLogArg */
12326: 0, /* bLocaltimeFault */
12327: };
12328:
12329:
12330: /*
12331: ** Hash table for global functions - functions common to all
12332: ** database connections. After initialization, this table is
12333: ** read-only.
12334: */
12335: SQLITE_PRIVATE SQLITE_WSD FuncDefHash sqlite3GlobalFunctions;
12336:
12337: /*
12338: ** Constant tokens for values 0 and 1.
12339: */
12340: SQLITE_PRIVATE const Token sqlite3IntTokens[] = {
12341: { "0", 1 },
12342: { "1", 1 }
12343: };
12344:
12345:
12346: /*
12347: ** The value of the "pending" byte must be 0x40000000 (1 byte past the
12348: ** 1-gibabyte boundary) in a compatible database. SQLite never uses
12349: ** the database page that contains the pending byte. It never attempts
12350: ** to read or write that page. The pending byte page is set assign
12351: ** for use by the VFS layers as space for managing file locks.
12352: **
12353: ** During testing, it is often desirable to move the pending byte to
12354: ** a different position in the file. This allows code that has to
12355: ** deal with the pending byte to run on files that are much smaller
12356: ** than 1 GiB. The sqlite3_test_control() interface can be used to
12357: ** move the pending byte.
12358: **
12359: ** IMPORTANT: Changing the pending byte to any value other than
12360: ** 0x40000000 results in an incompatible database file format!
12361: ** Changing the pending byte during operating results in undefined
12362: ** and dileterious behavior.
12363: */
12364: #ifndef SQLITE_OMIT_WSD
12365: SQLITE_PRIVATE int sqlite3PendingByte = 0x40000000;
12366: #endif
12367:
12368: /*
12369: ** Properties of opcodes. The OPFLG_INITIALIZER macro is
12370: ** created by mkopcodeh.awk during compilation. Data is obtained
12371: ** from the comments following the "case OP_xxxx:" statements in
12372: ** the vdbe.c file.
12373: */
12374: SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER;
12375:
12376: /************** End of global.c **********************************************/
12377: /************** Begin file ctime.c *******************************************/
12378: /*
12379: ** 2010 February 23
12380: **
12381: ** The author disclaims copyright to this source code. In place of
12382: ** a legal notice, here is a blessing:
12383: **
12384: ** May you do good and not evil.
12385: ** May you find forgiveness for yourself and forgive others.
12386: ** May you share freely, never taking more than you give.
12387: **
12388: *************************************************************************
12389: **
12390: ** This file implements routines used to report what compile-time options
12391: ** SQLite was built with.
12392: */
12393:
12394: #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
12395:
12396:
12397: /*
12398: ** An array of names of all compile-time options. This array should
12399: ** be sorted A-Z.
12400: **
12401: ** This array looks large, but in a typical installation actually uses
12402: ** only a handful of compile-time options, so most times this array is usually
12403: ** rather short and uses little memory space.
12404: */
12405: static const char * const azCompileOpt[] = {
12406:
12407: /* These macros are provided to "stringify" the value of the define
12408: ** for those options in which the value is meaningful. */
12409: #define CTIMEOPT_VAL_(opt) #opt
12410: #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt)
12411:
12412: #ifdef SQLITE_32BIT_ROWID
12413: "32BIT_ROWID",
12414: #endif
12415: #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC
12416: "4_BYTE_ALIGNED_MALLOC",
12417: #endif
12418: #ifdef SQLITE_CASE_SENSITIVE_LIKE
12419: "CASE_SENSITIVE_LIKE",
12420: #endif
12421: #ifdef SQLITE_CHECK_PAGES
12422: "CHECK_PAGES",
12423: #endif
12424: #ifdef SQLITE_COVERAGE_TEST
12425: "COVERAGE_TEST",
12426: #endif
12427: #ifdef SQLITE_DEBUG
12428: "DEBUG",
12429: #endif
12430: #ifdef SQLITE_DEFAULT_LOCKING_MODE
12431: "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
12432: #endif
12433: #ifdef SQLITE_DISABLE_DIRSYNC
12434: "DISABLE_DIRSYNC",
12435: #endif
12436: #ifdef SQLITE_DISABLE_LFS
12437: "DISABLE_LFS",
12438: #endif
12439: #ifdef SQLITE_ENABLE_ATOMIC_WRITE
12440: "ENABLE_ATOMIC_WRITE",
12441: #endif
12442: #ifdef SQLITE_ENABLE_CEROD
12443: "ENABLE_CEROD",
12444: #endif
12445: #ifdef SQLITE_ENABLE_COLUMN_METADATA
12446: "ENABLE_COLUMN_METADATA",
12447: #endif
12448: #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
12449: "ENABLE_EXPENSIVE_ASSERT",
12450: #endif
12451: #ifdef SQLITE_ENABLE_FTS1
12452: "ENABLE_FTS1",
12453: #endif
12454: #ifdef SQLITE_ENABLE_FTS2
12455: "ENABLE_FTS2",
12456: #endif
12457: #ifdef SQLITE_ENABLE_FTS3
12458: "ENABLE_FTS3",
12459: #endif
12460: #ifdef SQLITE_ENABLE_FTS3_PARENTHESIS
12461: "ENABLE_FTS3_PARENTHESIS",
12462: #endif
12463: #ifdef SQLITE_ENABLE_FTS4
12464: "ENABLE_FTS4",
12465: #endif
12466: #ifdef SQLITE_ENABLE_ICU
12467: "ENABLE_ICU",
12468: #endif
12469: #ifdef SQLITE_ENABLE_IOTRACE
12470: "ENABLE_IOTRACE",
12471: #endif
12472: #ifdef SQLITE_ENABLE_LOAD_EXTENSION
12473: "ENABLE_LOAD_EXTENSION",
12474: #endif
12475: #ifdef SQLITE_ENABLE_LOCKING_STYLE
12476: "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE),
12477: #endif
12478: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
12479: "ENABLE_MEMORY_MANAGEMENT",
12480: #endif
12481: #ifdef SQLITE_ENABLE_MEMSYS3
12482: "ENABLE_MEMSYS3",
12483: #endif
12484: #ifdef SQLITE_ENABLE_MEMSYS5
12485: "ENABLE_MEMSYS5",
12486: #endif
12487: #ifdef SQLITE_ENABLE_OVERSIZE_CELL_CHECK
12488: "ENABLE_OVERSIZE_CELL_CHECK",
12489: #endif
12490: #ifdef SQLITE_ENABLE_RTREE
12491: "ENABLE_RTREE",
12492: #endif
12493: #ifdef SQLITE_ENABLE_STAT3
12494: "ENABLE_STAT3",
12495: #endif
12496: #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
12497: "ENABLE_UNLOCK_NOTIFY",
12498: #endif
12499: #ifdef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
12500: "ENABLE_UPDATE_DELETE_LIMIT",
12501: #endif
12502: #ifdef SQLITE_HAS_CODEC
12503: "HAS_CODEC",
12504: #endif
12505: #ifdef SQLITE_HAVE_ISNAN
12506: "HAVE_ISNAN",
12507: #endif
12508: #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
12509: "HOMEGROWN_RECURSIVE_MUTEX",
12510: #endif
12511: #ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS
12512: "IGNORE_AFP_LOCK_ERRORS",
12513: #endif
12514: #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
12515: "IGNORE_FLOCK_LOCK_ERRORS",
12516: #endif
12517: #ifdef SQLITE_INT64_TYPE
12518: "INT64_TYPE",
12519: #endif
12520: #ifdef SQLITE_LOCK_TRACE
12521: "LOCK_TRACE",
12522: #endif
12523: #ifdef SQLITE_MAX_SCHEMA_RETRY
12524: "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY),
12525: #endif
12526: #ifdef SQLITE_MEMDEBUG
12527: "MEMDEBUG",
12528: #endif
12529: #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
12530: "MIXED_ENDIAN_64BIT_FLOAT",
12531: #endif
12532: #ifdef SQLITE_NO_SYNC
12533: "NO_SYNC",
12534: #endif
12535: #ifdef SQLITE_OMIT_ALTERTABLE
12536: "OMIT_ALTERTABLE",
12537: #endif
12538: #ifdef SQLITE_OMIT_ANALYZE
12539: "OMIT_ANALYZE",
12540: #endif
12541: #ifdef SQLITE_OMIT_ATTACH
12542: "OMIT_ATTACH",
12543: #endif
12544: #ifdef SQLITE_OMIT_AUTHORIZATION
12545: "OMIT_AUTHORIZATION",
12546: #endif
12547: #ifdef SQLITE_OMIT_AUTOINCREMENT
12548: "OMIT_AUTOINCREMENT",
12549: #endif
12550: #ifdef SQLITE_OMIT_AUTOINIT
12551: "OMIT_AUTOINIT",
12552: #endif
12553: #ifdef SQLITE_OMIT_AUTOMATIC_INDEX
12554: "OMIT_AUTOMATIC_INDEX",
12555: #endif
12556: #ifdef SQLITE_OMIT_AUTORESET
12557: "OMIT_AUTORESET",
12558: #endif
12559: #ifdef SQLITE_OMIT_AUTOVACUUM
12560: "OMIT_AUTOVACUUM",
12561: #endif
12562: #ifdef SQLITE_OMIT_BETWEEN_OPTIMIZATION
12563: "OMIT_BETWEEN_OPTIMIZATION",
12564: #endif
12565: #ifdef SQLITE_OMIT_BLOB_LITERAL
12566: "OMIT_BLOB_LITERAL",
12567: #endif
12568: #ifdef SQLITE_OMIT_BTREECOUNT
12569: "OMIT_BTREECOUNT",
12570: #endif
12571: #ifdef SQLITE_OMIT_BUILTIN_TEST
12572: "OMIT_BUILTIN_TEST",
12573: #endif
12574: #ifdef SQLITE_OMIT_CAST
12575: "OMIT_CAST",
12576: #endif
12577: #ifdef SQLITE_OMIT_CHECK
12578: "OMIT_CHECK",
12579: #endif
12580: /* // redundant
12581: ** #ifdef SQLITE_OMIT_COMPILEOPTION_DIAGS
12582: ** "OMIT_COMPILEOPTION_DIAGS",
12583: ** #endif
12584: */
12585: #ifdef SQLITE_OMIT_COMPLETE
12586: "OMIT_COMPLETE",
12587: #endif
12588: #ifdef SQLITE_OMIT_COMPOUND_SELECT
12589: "OMIT_COMPOUND_SELECT",
12590: #endif
12591: #ifdef SQLITE_OMIT_DATETIME_FUNCS
12592: "OMIT_DATETIME_FUNCS",
12593: #endif
12594: #ifdef SQLITE_OMIT_DECLTYPE
12595: "OMIT_DECLTYPE",
12596: #endif
12597: #ifdef SQLITE_OMIT_DEPRECATED
12598: "OMIT_DEPRECATED",
12599: #endif
12600: #ifdef SQLITE_OMIT_DISKIO
12601: "OMIT_DISKIO",
12602: #endif
12603: #ifdef SQLITE_OMIT_EXPLAIN
12604: "OMIT_EXPLAIN",
12605: #endif
12606: #ifdef SQLITE_OMIT_FLAG_PRAGMAS
12607: "OMIT_FLAG_PRAGMAS",
12608: #endif
12609: #ifdef SQLITE_OMIT_FLOATING_POINT
12610: "OMIT_FLOATING_POINT",
12611: #endif
12612: #ifdef SQLITE_OMIT_FOREIGN_KEY
12613: "OMIT_FOREIGN_KEY",
12614: #endif
12615: #ifdef SQLITE_OMIT_GET_TABLE
12616: "OMIT_GET_TABLE",
12617: #endif
12618: #ifdef SQLITE_OMIT_INCRBLOB
12619: "OMIT_INCRBLOB",
12620: #endif
12621: #ifdef SQLITE_OMIT_INTEGRITY_CHECK
12622: "OMIT_INTEGRITY_CHECK",
12623: #endif
12624: #ifdef SQLITE_OMIT_LIKE_OPTIMIZATION
12625: "OMIT_LIKE_OPTIMIZATION",
12626: #endif
12627: #ifdef SQLITE_OMIT_LOAD_EXTENSION
12628: "OMIT_LOAD_EXTENSION",
12629: #endif
12630: #ifdef SQLITE_OMIT_LOCALTIME
12631: "OMIT_LOCALTIME",
12632: #endif
12633: #ifdef SQLITE_OMIT_LOOKASIDE
12634: "OMIT_LOOKASIDE",
12635: #endif
12636: #ifdef SQLITE_OMIT_MEMORYDB
12637: "OMIT_MEMORYDB",
12638: #endif
12639: #ifdef SQLITE_OMIT_MERGE_SORT
12640: "OMIT_MERGE_SORT",
12641: #endif
12642: #ifdef SQLITE_OMIT_OR_OPTIMIZATION
12643: "OMIT_OR_OPTIMIZATION",
12644: #endif
12645: #ifdef SQLITE_OMIT_PAGER_PRAGMAS
12646: "OMIT_PAGER_PRAGMAS",
12647: #endif
12648: #ifdef SQLITE_OMIT_PRAGMA
12649: "OMIT_PRAGMA",
12650: #endif
12651: #ifdef SQLITE_OMIT_PROGRESS_CALLBACK
12652: "OMIT_PROGRESS_CALLBACK",
12653: #endif
12654: #ifdef SQLITE_OMIT_QUICKBALANCE
12655: "OMIT_QUICKBALANCE",
12656: #endif
12657: #ifdef SQLITE_OMIT_REINDEX
12658: "OMIT_REINDEX",
12659: #endif
12660: #ifdef SQLITE_OMIT_SCHEMA_PRAGMAS
12661: "OMIT_SCHEMA_PRAGMAS",
12662: #endif
12663: #ifdef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
12664: "OMIT_SCHEMA_VERSION_PRAGMAS",
12665: #endif
12666: #ifdef SQLITE_OMIT_SHARED_CACHE
12667: "OMIT_SHARED_CACHE",
12668: #endif
12669: #ifdef SQLITE_OMIT_SUBQUERY
12670: "OMIT_SUBQUERY",
12671: #endif
12672: #ifdef SQLITE_OMIT_TCL_VARIABLE
12673: "OMIT_TCL_VARIABLE",
12674: #endif
12675: #ifdef SQLITE_OMIT_TEMPDB
12676: "OMIT_TEMPDB",
12677: #endif
12678: #ifdef SQLITE_OMIT_TRACE
12679: "OMIT_TRACE",
12680: #endif
12681: #ifdef SQLITE_OMIT_TRIGGER
12682: "OMIT_TRIGGER",
12683: #endif
12684: #ifdef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
12685: "OMIT_TRUNCATE_OPTIMIZATION",
12686: #endif
12687: #ifdef SQLITE_OMIT_UTF16
12688: "OMIT_UTF16",
12689: #endif
12690: #ifdef SQLITE_OMIT_VACUUM
12691: "OMIT_VACUUM",
12692: #endif
12693: #ifdef SQLITE_OMIT_VIEW
12694: "OMIT_VIEW",
12695: #endif
12696: #ifdef SQLITE_OMIT_VIRTUALTABLE
12697: "OMIT_VIRTUALTABLE",
12698: #endif
12699: #ifdef SQLITE_OMIT_WAL
12700: "OMIT_WAL",
12701: #endif
12702: #ifdef SQLITE_OMIT_WSD
12703: "OMIT_WSD",
12704: #endif
12705: #ifdef SQLITE_OMIT_XFER_OPT
12706: "OMIT_XFER_OPT",
12707: #endif
12708: #ifdef SQLITE_PERFORMANCE_TRACE
12709: "PERFORMANCE_TRACE",
12710: #endif
12711: #ifdef SQLITE_PROXY_DEBUG
12712: "PROXY_DEBUG",
12713: #endif
12714: #ifdef SQLITE_SECURE_DELETE
12715: "SECURE_DELETE",
12716: #endif
12717: #ifdef SQLITE_SMALL_STACK
12718: "SMALL_STACK",
12719: #endif
12720: #ifdef SQLITE_SOUNDEX
12721: "SOUNDEX",
12722: #endif
12723: #ifdef SQLITE_TCL
12724: "TCL",
12725: #endif
12726: #ifdef SQLITE_TEMP_STORE
12727: "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE),
12728: #endif
12729: #ifdef SQLITE_TEST
12730: "TEST",
12731: #endif
12732: #ifdef SQLITE_THREADSAFE
12733: "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE),
12734: #endif
12735: #ifdef SQLITE_USE_ALLOCA
12736: "USE_ALLOCA",
12737: #endif
12738: #ifdef SQLITE_ZERO_MALLOC
12739: "ZERO_MALLOC"
12740: #endif
12741: };
12742:
12743: /*
12744: ** Given the name of a compile-time option, return true if that option
12745: ** was used and false if not.
12746: **
12747: ** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix
12748: ** is not required for a match.
12749: */
12750: SQLITE_API int sqlite3_compileoption_used(const char *zOptName){
12751: int i, n;
12752: if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
12753: n = sqlite3Strlen30(zOptName);
12754:
12755: /* Since ArraySize(azCompileOpt) is normally in single digits, a
12756: ** linear search is adequate. No need for a binary search. */
12757: for(i=0; i<ArraySize(azCompileOpt); i++){
12758: if( (sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0)
12759: && ( (azCompileOpt[i][n]==0) || (azCompileOpt[i][n]=='=') ) ) return 1;
12760: }
12761: return 0;
12762: }
12763:
12764: /*
12765: ** Return the N-th compile-time option string. If N is out of range,
12766: ** return a NULL pointer.
12767: */
12768: SQLITE_API const char *sqlite3_compileoption_get(int N){
12769: if( N>=0 && N<ArraySize(azCompileOpt) ){
12770: return azCompileOpt[N];
12771: }
12772: return 0;
12773: }
12774:
12775: #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
12776:
12777: /************** End of ctime.c ***********************************************/
12778: /************** Begin file status.c ******************************************/
12779: /*
12780: ** 2008 June 18
12781: **
12782: ** The author disclaims copyright to this source code. In place of
12783: ** a legal notice, here is a blessing:
12784: **
12785: ** May you do good and not evil.
12786: ** May you find forgiveness for yourself and forgive others.
12787: ** May you share freely, never taking more than you give.
12788: **
12789: *************************************************************************
12790: **
12791: ** This module implements the sqlite3_status() interface and related
12792: ** functionality.
12793: */
12794: /************** Include vdbeInt.h in the middle of status.c ******************/
12795: /************** Begin file vdbeInt.h *****************************************/
12796: /*
12797: ** 2003 September 6
12798: **
12799: ** The author disclaims copyright to this source code. In place of
12800: ** a legal notice, here is a blessing:
12801: **
12802: ** May you do good and not evil.
12803: ** May you find forgiveness for yourself and forgive others.
12804: ** May you share freely, never taking more than you give.
12805: **
12806: *************************************************************************
12807: ** This is the header file for information that is private to the
12808: ** VDBE. This information used to all be at the top of the single
12809: ** source code file "vdbe.c". When that file became too big (over
12810: ** 6000 lines long) it was split up into several smaller files and
12811: ** this header information was factored out.
12812: */
12813: #ifndef _VDBEINT_H_
12814: #define _VDBEINT_H_
12815:
12816: /*
12817: ** SQL is translated into a sequence of instructions to be
12818: ** executed by a virtual machine. Each instruction is an instance
12819: ** of the following structure.
12820: */
12821: typedef struct VdbeOp Op;
12822:
12823: /*
12824: ** Boolean values
12825: */
12826: typedef unsigned char Bool;
12827:
12828: /* Opaque type used by code in vdbesort.c */
12829: typedef struct VdbeSorter VdbeSorter;
12830:
12831: /* Opaque type used by the explainer */
12832: typedef struct Explain Explain;
12833:
12834: /*
12835: ** A cursor is a pointer into a single BTree within a database file.
12836: ** The cursor can seek to a BTree entry with a particular key, or
12837: ** loop over all entries of the Btree. You can also insert new BTree
12838: ** entries or retrieve the key or data from the entry that the cursor
12839: ** is currently pointing to.
12840: **
12841: ** Every cursor that the virtual machine has open is represented by an
12842: ** instance of the following structure.
12843: */
12844: struct VdbeCursor {
12845: BtCursor *pCursor; /* The cursor structure of the backend */
12846: Btree *pBt; /* Separate file holding temporary table */
12847: KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */
12848: int iDb; /* Index of cursor database in db->aDb[] (or -1) */
12849: int pseudoTableReg; /* Register holding pseudotable content. */
12850: int nField; /* Number of fields in the header */
12851: Bool zeroed; /* True if zeroed out and ready for reuse */
12852: Bool rowidIsValid; /* True if lastRowid is valid */
12853: Bool atFirst; /* True if pointing to first entry */
12854: Bool useRandomRowid; /* Generate new record numbers semi-randomly */
12855: Bool nullRow; /* True if pointing to a row with no data */
12856: Bool deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */
12857: Bool isTable; /* True if a table requiring integer keys */
12858: Bool isIndex; /* True if an index containing keys only - no data */
12859: Bool isOrdered; /* True if the underlying table is BTREE_UNORDERED */
12860: Bool isSorter; /* True if a new-style sorter */
12861: sqlite3_vtab_cursor *pVtabCursor; /* The cursor for a virtual table */
12862: const sqlite3_module *pModule; /* Module for cursor pVtabCursor */
12863: i64 seqCount; /* Sequence counter */
12864: i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */
12865: i64 lastRowid; /* Last rowid from a Next or NextIdx operation */
12866: VdbeSorter *pSorter; /* Sorter object for OP_SorterOpen cursors */
12867:
12868: /* Result of last sqlite3BtreeMoveto() done by an OP_NotExists or
12869: ** OP_IsUnique opcode on this cursor. */
12870: int seekResult;
12871:
12872: /* Cached information about the header for the data record that the
12873: ** cursor is currently pointing to. Only valid if cacheStatus matches
12874: ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of
12875: ** CACHE_STALE and so setting cacheStatus=CACHE_STALE guarantees that
12876: ** the cache is out of date.
12877: **
12878: ** aRow might point to (ephemeral) data for the current row, or it might
12879: ** be NULL.
12880: */
12881: u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */
12882: int payloadSize; /* Total number of bytes in the record */
12883: u32 *aType; /* Type values for all entries in the record */
12884: u32 *aOffset; /* Cached offsets to the start of each columns data */
12885: u8 *aRow; /* Data for the current row, if all on one page */
12886: };
12887: typedef struct VdbeCursor VdbeCursor;
12888:
12889: /*
12890: ** When a sub-program is executed (OP_Program), a structure of this type
12891: ** is allocated to store the current value of the program counter, as
12892: ** well as the current memory cell array and various other frame specific
12893: ** values stored in the Vdbe struct. When the sub-program is finished,
12894: ** these values are copied back to the Vdbe from the VdbeFrame structure,
12895: ** restoring the state of the VM to as it was before the sub-program
12896: ** began executing.
12897: **
12898: ** The memory for a VdbeFrame object is allocated and managed by a memory
12899: ** cell in the parent (calling) frame. When the memory cell is deleted or
12900: ** overwritten, the VdbeFrame object is not freed immediately. Instead, it
12901: ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
12902: ** list is deleted when the VM is reset in VdbeHalt(). The reason for doing
12903: ** this instead of deleting the VdbeFrame immediately is to avoid recursive
12904: ** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the
12905: ** child frame are released.
12906: **
12907: ** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is
12908: ** set to NULL if the currently executing frame is the main program.
12909: */
12910: typedef struct VdbeFrame VdbeFrame;
12911: struct VdbeFrame {
12912: Vdbe *v; /* VM this frame belongs to */
12913: int pc; /* Program Counter in parent (calling) frame */
12914: Op *aOp; /* Program instructions for parent frame */
12915: int nOp; /* Size of aOp array */
12916: Mem *aMem; /* Array of memory cells for parent frame */
12917: int nMem; /* Number of entries in aMem */
12918: u8 *aOnceFlag; /* Array of OP_Once flags for parent frame */
12919: int nOnceFlag; /* Number of entries in aOnceFlag */
12920: VdbeCursor **apCsr; /* Array of Vdbe cursors for parent frame */
12921: u16 nCursor; /* Number of entries in apCsr */
12922: void *token; /* Copy of SubProgram.token */
12923: int nChildMem; /* Number of memory cells for child frame */
12924: int nChildCsr; /* Number of cursors for child frame */
12925: i64 lastRowid; /* Last insert rowid (sqlite3.lastRowid) */
12926: int nChange; /* Statement changes (Vdbe.nChanges) */
12927: VdbeFrame *pParent; /* Parent of this frame, or NULL if parent is main */
12928: };
12929:
12930: #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
12931:
12932: /*
12933: ** A value for VdbeCursor.cacheValid that means the cache is always invalid.
12934: */
12935: #define CACHE_STALE 0
12936:
12937: /*
12938: ** Internally, the vdbe manipulates nearly all SQL values as Mem
12939: ** structures. Each Mem struct may cache multiple representations (string,
12940: ** integer etc.) of the same value.
12941: */
12942: struct Mem {
12943: sqlite3 *db; /* The associated database connection */
12944: char *z; /* String or BLOB value */
12945: double r; /* Real value */
12946: union {
12947: i64 i; /* Integer value used when MEM_Int is set in flags */
12948: int nZero; /* Used when bit MEM_Zero is set in flags */
12949: FuncDef *pDef; /* Used only when flags==MEM_Agg */
12950: RowSet *pRowSet; /* Used only when flags==MEM_RowSet */
12951: VdbeFrame *pFrame; /* Used when flags==MEM_Frame */
12952: } u;
12953: int n; /* Number of characters in string value, excluding '\0' */
12954: u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
12955: u8 type; /* One of SQLITE_NULL, SQLITE_TEXT, SQLITE_INTEGER, etc */
12956: u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
12957: #ifdef SQLITE_DEBUG
12958: Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */
12959: void *pFiller; /* So that sizeof(Mem) is a multiple of 8 */
12960: #endif
12961: void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
12962: char *zMalloc; /* Dynamic buffer allocated by sqlite3_malloc() */
12963: };
12964:
12965: /* One or more of the following flags are set to indicate the validOK
12966: ** representations of the value stored in the Mem struct.
12967: **
12968: ** If the MEM_Null flag is set, then the value is an SQL NULL value.
12969: ** No other flags may be set in this case.
12970: **
12971: ** If the MEM_Str flag is set then Mem.z points at a string representation.
12972: ** Usually this is encoded in the same unicode encoding as the main
12973: ** database (see below for exceptions). If the MEM_Term flag is also
12974: ** set, then the string is nul terminated. The MEM_Int and MEM_Real
12975: ** flags may coexist with the MEM_Str flag.
12976: */
12977: #define MEM_Null 0x0001 /* Value is NULL */
12978: #define MEM_Str 0x0002 /* Value is a string */
12979: #define MEM_Int 0x0004 /* Value is an integer */
12980: #define MEM_Real 0x0008 /* Value is a real number */
12981: #define MEM_Blob 0x0010 /* Value is a BLOB */
12982: #define MEM_RowSet 0x0020 /* Value is a RowSet object */
12983: #define MEM_Frame 0x0040 /* Value is a VdbeFrame object */
12984: #define MEM_Invalid 0x0080 /* Value is undefined */
12985: #define MEM_TypeMask 0x00ff /* Mask of type bits */
12986:
12987: /* Whenever Mem contains a valid string or blob representation, one of
12988: ** the following flags must be set to determine the memory management
12989: ** policy for Mem.z. The MEM_Term flag tells us whether or not the
12990: ** string is \000 or \u0000 terminated
12991: */
12992: #define MEM_Term 0x0200 /* String rep is nul terminated */
12993: #define MEM_Dyn 0x0400 /* Need to call sqliteFree() on Mem.z */
12994: #define MEM_Static 0x0800 /* Mem.z points to a static string */
12995: #define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */
12996: #define MEM_Agg 0x2000 /* Mem.z points to an agg function context */
12997: #define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */
12998: #ifdef SQLITE_OMIT_INCRBLOB
12999: #undef MEM_Zero
13000: #define MEM_Zero 0x0000
13001: #endif
13002:
13003: /*
13004: ** Clear any existing type flags from a Mem and replace them with f
13005: */
13006: #define MemSetTypeFlag(p, f) \
13007: ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
13008:
13009: /*
13010: ** Return true if a memory cell is not marked as invalid. This macro
13011: ** is for use inside assert() statements only.
13012: */
13013: #ifdef SQLITE_DEBUG
13014: #define memIsValid(M) ((M)->flags & MEM_Invalid)==0
13015: #endif
13016:
13017:
13018: /* A VdbeFunc is just a FuncDef (defined in sqliteInt.h) that contains
13019: ** additional information about auxiliary information bound to arguments
13020: ** of the function. This is used to implement the sqlite3_get_auxdata()
13021: ** and sqlite3_set_auxdata() APIs. The "auxdata" is some auxiliary data
13022: ** that can be associated with a constant argument to a function. This
13023: ** allows functions such as "regexp" to compile their constant regular
13024: ** expression argument once and reused the compiled code for multiple
13025: ** invocations.
13026: */
13027: struct VdbeFunc {
13028: FuncDef *pFunc; /* The definition of the function */
13029: int nAux; /* Number of entries allocated for apAux[] */
13030: struct AuxData {
13031: void *pAux; /* Aux data for the i-th argument */
13032: void (*xDelete)(void *); /* Destructor for the aux data */
13033: } apAux[1]; /* One slot for each function argument */
13034: };
13035:
13036: /*
13037: ** The "context" argument for a installable function. A pointer to an
13038: ** instance of this structure is the first argument to the routines used
13039: ** implement the SQL functions.
13040: **
13041: ** There is a typedef for this structure in sqlite.h. So all routines,
13042: ** even the public interface to SQLite, can use a pointer to this structure.
13043: ** But this file is the only place where the internal details of this
13044: ** structure are known.
13045: **
13046: ** This structure is defined inside of vdbeInt.h because it uses substructures
13047: ** (Mem) which are only defined there.
13048: */
13049: struct sqlite3_context {
13050: FuncDef *pFunc; /* Pointer to function information. MUST BE FIRST */
13051: VdbeFunc *pVdbeFunc; /* Auxilary data, if created. */
13052: Mem s; /* The return value is stored here */
13053: Mem *pMem; /* Memory cell used to store aggregate context */
13054: int isError; /* Error code returned by the function. */
13055: CollSeq *pColl; /* Collating sequence */
13056: };
13057:
13058: /*
13059: ** An Explain object accumulates indented output which is helpful
13060: ** in describing recursive data structures.
13061: */
13062: struct Explain {
13063: Vdbe *pVdbe; /* Attach the explanation to this Vdbe */
13064: StrAccum str; /* The string being accumulated */
13065: int nIndent; /* Number of elements in aIndent */
13066: u16 aIndent[100]; /* Levels of indentation */
13067: char zBase[100]; /* Initial space */
13068: };
13069:
13070: /*
13071: ** An instance of the virtual machine. This structure contains the complete
13072: ** state of the virtual machine.
13073: **
13074: ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare()
13075: ** is really a pointer to an instance of this structure.
13076: **
13077: ** The Vdbe.inVtabMethod variable is set to non-zero for the duration of
13078: ** any virtual table method invocations made by the vdbe program. It is
13079: ** set to 2 for xDestroy method calls and 1 for all other methods. This
13080: ** variable is used for two purposes: to allow xDestroy methods to execute
13081: ** "DROP TABLE" statements and to prevent some nasty side effects of
13082: ** malloc failure when SQLite is invoked recursively by a virtual table
13083: ** method function.
13084: */
13085: struct Vdbe {
13086: sqlite3 *db; /* The database connection that owns this statement */
13087: Op *aOp; /* Space to hold the virtual machine's program */
13088: Mem *aMem; /* The memory locations */
13089: Mem **apArg; /* Arguments to currently executing user function */
13090: Mem *aColName; /* Column names to return */
13091: Mem *pResultSet; /* Pointer to an array of results */
13092: int nMem; /* Number of memory locations currently allocated */
13093: int nOp; /* Number of instructions in the program */
13094: int nOpAlloc; /* Number of slots allocated for aOp[] */
13095: int nLabel; /* Number of labels used */
13096: int nLabelAlloc; /* Number of slots allocated in aLabel[] */
13097: int *aLabel; /* Space to hold the labels */
13098: u16 nResColumn; /* Number of columns in one row of the result set */
13099: u16 nCursor; /* Number of slots in apCsr[] */
13100: u32 magic; /* Magic number for sanity checking */
13101: char *zErrMsg; /* Error message written here */
13102: Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
13103: VdbeCursor **apCsr; /* One element of this array for each open cursor */
13104: Mem *aVar; /* Values for the OP_Variable opcode. */
13105: char **azVar; /* Name of variables */
13106: ynVar nVar; /* Number of entries in aVar[] */
13107: ynVar nzVar; /* Number of entries in azVar[] */
13108: u32 cacheCtr; /* VdbeCursor row cache generation counter */
13109: int pc; /* The program counter */
13110: int rc; /* Value to return */
13111: u8 errorAction; /* Recovery action to do in case of an error */
13112: u8 explain; /* True if EXPLAIN present on SQL command */
13113: u8 changeCntOn; /* True to update the change-counter */
13114: u8 expired; /* True if the VM needs to be recompiled */
13115: u8 runOnlyOnce; /* Automatically expire on reset */
13116: u8 minWriteFileFormat; /* Minimum file format for writable database files */
13117: u8 inVtabMethod; /* See comments above */
13118: u8 usesStmtJournal; /* True if uses a statement journal */
13119: u8 readOnly; /* True for read-only statements */
13120: u8 isPrepareV2; /* True if prepared with prepare_v2() */
13121: int nChange; /* Number of db changes made since last reset */
13122: yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
13123: yDbMask lockMask; /* Subset of btreeMask that requires a lock */
13124: int iStatement; /* Statement number (or 0 if has not opened stmt) */
13125: int aCounter[3]; /* Counters used by sqlite3_stmt_status() */
13126: #ifndef SQLITE_OMIT_TRACE
13127: i64 startTime; /* Time when query started - used for profiling */
13128: #endif
13129: i64 nFkConstraint; /* Number of imm. FK constraints this VM */
13130: i64 nStmtDefCons; /* Number of def. constraints when stmt started */
13131: char *zSql; /* Text of the SQL statement that generated this */
13132: void *pFree; /* Free this when deleting the vdbe */
13133: #ifdef SQLITE_DEBUG
13134: FILE *trace; /* Write an execution trace here, if not NULL */
13135: #endif
13136: #ifdef SQLITE_ENABLE_TREE_EXPLAIN
13137: Explain *pExplain; /* The explainer */
13138: char *zExplain; /* Explanation of data structures */
13139: #endif
13140: VdbeFrame *pFrame; /* Parent frame */
13141: VdbeFrame *pDelFrame; /* List of frame objects to free on VM reset */
13142: int nFrame; /* Number of frames in pFrame list */
13143: u32 expmask; /* Binding to these vars invalidates VM */
13144: SubProgram *pProgram; /* Linked list of all sub-programs used by VM */
13145: int nOnceFlag; /* Size of array aOnceFlag[] */
13146: u8 *aOnceFlag; /* Flags for OP_Once */
13147: };
13148:
13149: /*
13150: ** The following are allowed values for Vdbe.magic
13151: */
13152: #define VDBE_MAGIC_INIT 0x26bceaa5 /* Building a VDBE program */
13153: #define VDBE_MAGIC_RUN 0xbdf20da3 /* VDBE is ready to execute */
13154: #define VDBE_MAGIC_HALT 0x519c2973 /* VDBE has completed execution */
13155: #define VDBE_MAGIC_DEAD 0xb606c3c8 /* The VDBE has been deallocated */
13156:
13157: /*
13158: ** Function prototypes
13159: */
13160: SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
13161: void sqliteVdbePopStack(Vdbe*,int);
13162: SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor*);
13163: #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
13164: SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, Op*);
13165: #endif
13166: SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32);
13167: SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int);
13168: SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, int, Mem*, int);
13169: SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
13170: SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(VdbeFunc*, int);
13171:
13172: int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
13173: SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(VdbeCursor*,UnpackedRecord*,int*);
13174: SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3*, BtCursor *, i64 *);
13175: SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
13176: SQLITE_PRIVATE int sqlite3VdbeExec(Vdbe*);
13177: SQLITE_PRIVATE int sqlite3VdbeList(Vdbe*);
13178: SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe*);
13179: SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int);
13180: SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*);
13181: SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*);
13182: SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
13183: SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
13184: SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*);
13185: SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
13186: SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64);
13187: #ifdef SQLITE_OMIT_FLOATING_POINT
13188: # define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64
13189: #else
13190: SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double);
13191: #endif
13192: SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*);
13193: SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int);
13194: SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem*);
13195: SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*);
13196: SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, int);
13197: SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*);
13198: SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*);
13199: SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*);
13200: SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*);
13201: SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*);
13202: SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*);
13203: SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
13204: SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
13205: SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p);
13206: #define VdbeMemRelease(X) \
13207: if((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame)) \
13208: sqlite3VdbeMemReleaseExternal(X);
13209: SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
13210: SQLITE_PRIVATE const char *sqlite3OpcodeName(int);
13211: SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
13212: SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int);
13213: SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*);
13214: SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *);
13215: SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem);
13216: SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p);
13217:
13218: #ifdef SQLITE_OMIT_MERGE_SORT
13219: # define sqlite3VdbeSorterInit(Y,Z) SQLITE_OK
13220: # define sqlite3VdbeSorterWrite(X,Y,Z) SQLITE_OK
13221: # define sqlite3VdbeSorterClose(Y,Z)
13222: # define sqlite3VdbeSorterRowkey(Y,Z) SQLITE_OK
13223: # define sqlite3VdbeSorterRewind(X,Y,Z) SQLITE_OK
13224: # define sqlite3VdbeSorterNext(X,Y,Z) SQLITE_OK
13225: # define sqlite3VdbeSorterCompare(X,Y,Z) SQLITE_OK
13226: #else
13227: SQLITE_PRIVATE int sqlite3VdbeSorterInit(sqlite3 *, VdbeCursor *);
13228: SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *, VdbeCursor *);
13229: SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(VdbeCursor *, Mem *);
13230: SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *, VdbeCursor *, int *);
13231: SQLITE_PRIVATE int sqlite3VdbeSorterRewind(sqlite3 *, VdbeCursor *, int *);
13232: SQLITE_PRIVATE int sqlite3VdbeSorterWrite(sqlite3 *, VdbeCursor *, Mem *);
13233: SQLITE_PRIVATE int sqlite3VdbeSorterCompare(VdbeCursor *, Mem *, int *);
13234: #endif
13235:
13236: #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
13237: SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe*);
13238: SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe*);
13239: #else
13240: # define sqlite3VdbeEnter(X)
13241: # define sqlite3VdbeLeave(X)
13242: #endif
13243:
13244: #ifdef SQLITE_DEBUG
13245: SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
13246: #endif
13247:
13248: #ifndef SQLITE_OMIT_FOREIGN_KEY
13249: SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *, int);
13250: #else
13251: # define sqlite3VdbeCheckFk(p,i) 0
13252: #endif
13253:
13254: SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8);
13255: #ifdef SQLITE_DEBUG
13256: SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe*);
13257: SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
13258: #endif
13259: SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem);
13260:
13261: #ifndef SQLITE_OMIT_INCRBLOB
13262: SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *);
13263: #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
13264: #else
13265: #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
13266: #define ExpandBlob(P) SQLITE_OK
13267: #endif
13268:
13269: #endif /* !defined(_VDBEINT_H_) */
13270:
13271: /************** End of vdbeInt.h *********************************************/
13272: /************** Continuing where we left off in status.c *********************/
13273:
13274: /*
13275: ** Variables in which to record status information.
13276: */
13277: typedef struct sqlite3StatType sqlite3StatType;
13278: static SQLITE_WSD struct sqlite3StatType {
13279: int nowValue[10]; /* Current value */
13280: int mxValue[10]; /* Maximum value */
13281: } sqlite3Stat = { {0,}, {0,} };
13282:
13283:
13284: /* The "wsdStat" macro will resolve to the status information
13285: ** state vector. If writable static data is unsupported on the target,
13286: ** we have to locate the state vector at run-time. In the more common
13287: ** case where writable static data is supported, wsdStat can refer directly
13288: ** to the "sqlite3Stat" state vector declared above.
13289: */
13290: #ifdef SQLITE_OMIT_WSD
13291: # define wsdStatInit sqlite3StatType *x = &GLOBAL(sqlite3StatType,sqlite3Stat)
13292: # define wsdStat x[0]
13293: #else
13294: # define wsdStatInit
13295: # define wsdStat sqlite3Stat
13296: #endif
13297:
13298: /*
13299: ** Return the current value of a status parameter.
13300: */
13301: SQLITE_PRIVATE int sqlite3StatusValue(int op){
13302: wsdStatInit;
13303: assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
13304: return wsdStat.nowValue[op];
13305: }
13306:
13307: /*
13308: ** Add N to the value of a status record. It is assumed that the
13309: ** caller holds appropriate locks.
13310: */
13311: SQLITE_PRIVATE void sqlite3StatusAdd(int op, int N){
13312: wsdStatInit;
13313: assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
13314: wsdStat.nowValue[op] += N;
13315: if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
13316: wsdStat.mxValue[op] = wsdStat.nowValue[op];
13317: }
13318: }
13319:
13320: /*
13321: ** Set the value of a status to X.
13322: */
13323: SQLITE_PRIVATE void sqlite3StatusSet(int op, int X){
13324: wsdStatInit;
13325: assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
13326: wsdStat.nowValue[op] = X;
13327: if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
13328: wsdStat.mxValue[op] = wsdStat.nowValue[op];
13329: }
13330: }
13331:
13332: /*
13333: ** Query status information.
13334: **
13335: ** This implementation assumes that reading or writing an aligned
13336: ** 32-bit integer is an atomic operation. If that assumption is not true,
13337: ** then this routine is not threadsafe.
13338: */
13339: SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
13340: wsdStatInit;
13341: if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
13342: return SQLITE_MISUSE_BKPT;
13343: }
13344: *pCurrent = wsdStat.nowValue[op];
13345: *pHighwater = wsdStat.mxValue[op];
13346: if( resetFlag ){
13347: wsdStat.mxValue[op] = wsdStat.nowValue[op];
13348: }
13349: return SQLITE_OK;
13350: }
13351:
13352: /*
13353: ** Query status information for a single database connection
13354: */
13355: SQLITE_API int sqlite3_db_status(
13356: sqlite3 *db, /* The database connection whose status is desired */
13357: int op, /* Status verb */
13358: int *pCurrent, /* Write current value here */
13359: int *pHighwater, /* Write high-water mark here */
13360: int resetFlag /* Reset high-water mark if true */
13361: ){
13362: int rc = SQLITE_OK; /* Return code */
13363: sqlite3_mutex_enter(db->mutex);
13364: switch( op ){
13365: case SQLITE_DBSTATUS_LOOKASIDE_USED: {
13366: *pCurrent = db->lookaside.nOut;
13367: *pHighwater = db->lookaside.mxOut;
13368: if( resetFlag ){
13369: db->lookaside.mxOut = db->lookaside.nOut;
13370: }
13371: break;
13372: }
13373:
13374: case SQLITE_DBSTATUS_LOOKASIDE_HIT:
13375: case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE:
13376: case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: {
13377: testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT );
13378: testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE );
13379: testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL );
13380: assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 );
13381: assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 );
13382: *pCurrent = 0;
13383: *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT];
13384: if( resetFlag ){
13385: db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0;
13386: }
13387: break;
13388: }
13389:
13390: /*
13391: ** Return an approximation for the amount of memory currently used
13392: ** by all pagers associated with the given database connection. The
13393: ** highwater mark is meaningless and is returned as zero.
13394: */
13395: case SQLITE_DBSTATUS_CACHE_USED: {
13396: int totalUsed = 0;
13397: int i;
13398: sqlite3BtreeEnterAll(db);
13399: for(i=0; i<db->nDb; i++){
13400: Btree *pBt = db->aDb[i].pBt;
13401: if( pBt ){
13402: Pager *pPager = sqlite3BtreePager(pBt);
13403: totalUsed += sqlite3PagerMemUsed(pPager);
13404: }
13405: }
13406: sqlite3BtreeLeaveAll(db);
13407: *pCurrent = totalUsed;
13408: *pHighwater = 0;
13409: break;
13410: }
13411:
13412: /*
13413: ** *pCurrent gets an accurate estimate of the amount of memory used
13414: ** to store the schema for all databases (main, temp, and any ATTACHed
13415: ** databases. *pHighwater is set to zero.
13416: */
13417: case SQLITE_DBSTATUS_SCHEMA_USED: {
13418: int i; /* Used to iterate through schemas */
13419: int nByte = 0; /* Used to accumulate return value */
13420:
13421: sqlite3BtreeEnterAll(db);
13422: db->pnBytesFreed = &nByte;
13423: for(i=0; i<db->nDb; i++){
13424: Schema *pSchema = db->aDb[i].pSchema;
13425: if( ALWAYS(pSchema!=0) ){
13426: HashElem *p;
13427:
13428: nByte += sqlite3GlobalConfig.m.xRoundup(sizeof(HashElem)) * (
13429: pSchema->tblHash.count
13430: + pSchema->trigHash.count
13431: + pSchema->idxHash.count
13432: + pSchema->fkeyHash.count
13433: );
13434: nByte += sqlite3MallocSize(pSchema->tblHash.ht);
13435: nByte += sqlite3MallocSize(pSchema->trigHash.ht);
13436: nByte += sqlite3MallocSize(pSchema->idxHash.ht);
13437: nByte += sqlite3MallocSize(pSchema->fkeyHash.ht);
13438:
13439: for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){
13440: sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p));
13441: }
13442: for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
13443: sqlite3DeleteTable(db, (Table *)sqliteHashData(p));
13444: }
13445: }
13446: }
13447: db->pnBytesFreed = 0;
13448: sqlite3BtreeLeaveAll(db);
13449:
13450: *pHighwater = 0;
13451: *pCurrent = nByte;
13452: break;
13453: }
13454:
13455: /*
13456: ** *pCurrent gets an accurate estimate of the amount of memory used
13457: ** to store all prepared statements.
13458: ** *pHighwater is set to zero.
13459: */
13460: case SQLITE_DBSTATUS_STMT_USED: {
13461: struct Vdbe *pVdbe; /* Used to iterate through VMs */
13462: int nByte = 0; /* Used to accumulate return value */
13463:
13464: db->pnBytesFreed = &nByte;
13465: for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
13466: sqlite3VdbeDeleteObject(db, pVdbe);
13467: }
13468: db->pnBytesFreed = 0;
13469:
13470: *pHighwater = 0;
13471: *pCurrent = nByte;
13472:
13473: break;
13474: }
13475:
13476: /*
13477: ** Set *pCurrent to the total cache hits or misses encountered by all
13478: ** pagers the database handle is connected to. *pHighwater is always set
13479: ** to zero.
13480: */
13481: case SQLITE_DBSTATUS_CACHE_HIT:
13482: case SQLITE_DBSTATUS_CACHE_MISS: {
13483: int i;
13484: int nRet = 0;
13485: assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 );
13486:
13487: for(i=0; i<db->nDb; i++){
13488: if( db->aDb[i].pBt ){
13489: Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
13490: sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet);
13491: }
13492: }
13493: *pHighwater = 0;
13494: *pCurrent = nRet;
13495: break;
13496: }
13497:
13498: default: {
13499: rc = SQLITE_ERROR;
13500: }
13501: }
13502: sqlite3_mutex_leave(db->mutex);
13503: return rc;
13504: }
13505:
13506: /************** End of status.c **********************************************/
13507: /************** Begin file date.c ********************************************/
13508: /*
13509: ** 2003 October 31
13510: **
13511: ** The author disclaims copyright to this source code. In place of
13512: ** a legal notice, here is a blessing:
13513: **
13514: ** May you do good and not evil.
13515: ** May you find forgiveness for yourself and forgive others.
13516: ** May you share freely, never taking more than you give.
13517: **
13518: *************************************************************************
13519: ** This file contains the C functions that implement date and time
13520: ** functions for SQLite.
13521: **
13522: ** There is only one exported symbol in this file - the function
13523: ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
13524: ** All other code has file scope.
13525: **
13526: ** SQLite processes all times and dates as Julian Day numbers. The
13527: ** dates and times are stored as the number of days since noon
13528: ** in Greenwich on November 24, 4714 B.C. according to the Gregorian
13529: ** calendar system.
13530: **
13531: ** 1970-01-01 00:00:00 is JD 2440587.5
13532: ** 2000-01-01 00:00:00 is JD 2451544.5
13533: **
13534: ** This implemention requires years to be expressed as a 4-digit number
13535: ** which means that only dates between 0000-01-01 and 9999-12-31 can
13536: ** be represented, even though julian day numbers allow a much wider
13537: ** range of dates.
13538: **
13539: ** The Gregorian calendar system is used for all dates and times,
13540: ** even those that predate the Gregorian calendar. Historians usually
13541: ** use the Julian calendar for dates prior to 1582-10-15 and for some
13542: ** dates afterwards, depending on locale. Beware of this difference.
13543: **
13544: ** The conversion algorithms are implemented based on descriptions
13545: ** in the following text:
13546: **
13547: ** Jean Meeus
13548: ** Astronomical Algorithms, 2nd Edition, 1998
13549: ** ISBM 0-943396-61-1
13550: ** Willmann-Bell, Inc
13551: ** Richmond, Virginia (USA)
13552: */
13553: /* #include <stdlib.h> */
13554: /* #include <assert.h> */
13555: #include <time.h>
13556:
13557: #ifndef SQLITE_OMIT_DATETIME_FUNCS
13558:
13559:
13560: /*
13561: ** A structure for holding a single date and time.
13562: */
13563: typedef struct DateTime DateTime;
13564: struct DateTime {
13565: sqlite3_int64 iJD; /* The julian day number times 86400000 */
13566: int Y, M, D; /* Year, month, and day */
13567: int h, m; /* Hour and minutes */
13568: int tz; /* Timezone offset in minutes */
13569: double s; /* Seconds */
13570: char validYMD; /* True (1) if Y,M,D are valid */
13571: char validHMS; /* True (1) if h,m,s are valid */
13572: char validJD; /* True (1) if iJD is valid */
13573: char validTZ; /* True (1) if tz is valid */
13574: };
13575:
13576:
13577: /*
13578: ** Convert zDate into one or more integers. Additional arguments
13579: ** come in groups of 5 as follows:
13580: **
13581: ** N number of digits in the integer
13582: ** min minimum allowed value of the integer
13583: ** max maximum allowed value of the integer
13584: ** nextC first character after the integer
13585: ** pVal where to write the integers value.
13586: **
13587: ** Conversions continue until one with nextC==0 is encountered.
13588: ** The function returns the number of successful conversions.
13589: */
13590: static int getDigits(const char *zDate, ...){
13591: va_list ap;
13592: int val;
13593: int N;
13594: int min;
13595: int max;
13596: int nextC;
13597: int *pVal;
13598: int cnt = 0;
13599: va_start(ap, zDate);
13600: do{
13601: N = va_arg(ap, int);
13602: min = va_arg(ap, int);
13603: max = va_arg(ap, int);
13604: nextC = va_arg(ap, int);
13605: pVal = va_arg(ap, int*);
13606: val = 0;
13607: while( N-- ){
13608: if( !sqlite3Isdigit(*zDate) ){
13609: goto end_getDigits;
13610: }
13611: val = val*10 + *zDate - '0';
13612: zDate++;
13613: }
13614: if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){
13615: goto end_getDigits;
13616: }
13617: *pVal = val;
13618: zDate++;
13619: cnt++;
13620: }while( nextC );
13621: end_getDigits:
13622: va_end(ap);
13623: return cnt;
13624: }
13625:
13626: /*
13627: ** Parse a timezone extension on the end of a date-time.
13628: ** The extension is of the form:
13629: **
13630: ** (+/-)HH:MM
13631: **
13632: ** Or the "zulu" notation:
13633: **
13634: ** Z
13635: **
13636: ** If the parse is successful, write the number of minutes
13637: ** of change in p->tz and return 0. If a parser error occurs,
13638: ** return non-zero.
13639: **
13640: ** A missing specifier is not considered an error.
13641: */
13642: static int parseTimezone(const char *zDate, DateTime *p){
13643: int sgn = 0;
13644: int nHr, nMn;
13645: int c;
13646: while( sqlite3Isspace(*zDate) ){ zDate++; }
13647: p->tz = 0;
13648: c = *zDate;
13649: if( c=='-' ){
13650: sgn = -1;
13651: }else if( c=='+' ){
13652: sgn = +1;
13653: }else if( c=='Z' || c=='z' ){
13654: zDate++;
13655: goto zulu_time;
13656: }else{
13657: return c!=0;
13658: }
13659: zDate++;
13660: if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){
13661: return 1;
13662: }
13663: zDate += 5;
13664: p->tz = sgn*(nMn + nHr*60);
13665: zulu_time:
13666: while( sqlite3Isspace(*zDate) ){ zDate++; }
13667: return *zDate!=0;
13668: }
13669:
13670: /*
13671: ** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF.
13672: ** The HH, MM, and SS must each be exactly 2 digits. The
13673: ** fractional seconds FFFF can be one or more digits.
13674: **
13675: ** Return 1 if there is a parsing error and 0 on success.
13676: */
13677: static int parseHhMmSs(const char *zDate, DateTime *p){
13678: int h, m, s;
13679: double ms = 0.0;
13680: if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){
13681: return 1;
13682: }
13683: zDate += 5;
13684: if( *zDate==':' ){
13685: zDate++;
13686: if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){
13687: return 1;
13688: }
13689: zDate += 2;
13690: if( *zDate=='.' && sqlite3Isdigit(zDate[1]) ){
13691: double rScale = 1.0;
13692: zDate++;
13693: while( sqlite3Isdigit(*zDate) ){
13694: ms = ms*10.0 + *zDate - '0';
13695: rScale *= 10.0;
13696: zDate++;
13697: }
13698: ms /= rScale;
13699: }
13700: }else{
13701: s = 0;
13702: }
13703: p->validJD = 0;
13704: p->validHMS = 1;
13705: p->h = h;
13706: p->m = m;
13707: p->s = s + ms;
13708: if( parseTimezone(zDate, p) ) return 1;
13709: p->validTZ = (p->tz!=0)?1:0;
13710: return 0;
13711: }
13712:
13713: /*
13714: ** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume
13715: ** that the YYYY-MM-DD is according to the Gregorian calendar.
13716: **
13717: ** Reference: Meeus page 61
13718: */
13719: static void computeJD(DateTime *p){
13720: int Y, M, D, A, B, X1, X2;
13721:
13722: if( p->validJD ) return;
13723: if( p->validYMD ){
13724: Y = p->Y;
13725: M = p->M;
13726: D = p->D;
13727: }else{
13728: Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */
13729: M = 1;
13730: D = 1;
13731: }
13732: if( M<=2 ){
13733: Y--;
13734: M += 12;
13735: }
13736: A = Y/100;
13737: B = 2 - A + (A/4);
13738: X1 = 36525*(Y+4716)/100;
13739: X2 = 306001*(M+1)/10000;
13740: p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000);
13741: p->validJD = 1;
13742: if( p->validHMS ){
13743: p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000);
13744: if( p->validTZ ){
13745: p->iJD -= p->tz*60000;
13746: p->validYMD = 0;
13747: p->validHMS = 0;
13748: p->validTZ = 0;
13749: }
13750: }
13751: }
13752:
13753: /*
13754: ** Parse dates of the form
13755: **
13756: ** YYYY-MM-DD HH:MM:SS.FFF
13757: ** YYYY-MM-DD HH:MM:SS
13758: ** YYYY-MM-DD HH:MM
13759: ** YYYY-MM-DD
13760: **
13761: ** Write the result into the DateTime structure and return 0
13762: ** on success and 1 if the input string is not a well-formed
13763: ** date.
13764: */
13765: static int parseYyyyMmDd(const char *zDate, DateTime *p){
13766: int Y, M, D, neg;
13767:
13768: if( zDate[0]=='-' ){
13769: zDate++;
13770: neg = 1;
13771: }else{
13772: neg = 0;
13773: }
13774: if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){
13775: return 1;
13776: }
13777: zDate += 10;
13778: while( sqlite3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; }
13779: if( parseHhMmSs(zDate, p)==0 ){
13780: /* We got the time */
13781: }else if( *zDate==0 ){
13782: p->validHMS = 0;
13783: }else{
13784: return 1;
13785: }
13786: p->validJD = 0;
13787: p->validYMD = 1;
13788: p->Y = neg ? -Y : Y;
13789: p->M = M;
13790: p->D = D;
13791: if( p->validTZ ){
13792: computeJD(p);
13793: }
13794: return 0;
13795: }
13796:
13797: /*
13798: ** Set the time to the current time reported by the VFS.
13799: **
13800: ** Return the number of errors.
13801: */
13802: static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
13803: sqlite3 *db = sqlite3_context_db_handle(context);
13804: if( sqlite3OsCurrentTimeInt64(db->pVfs, &p->iJD)==SQLITE_OK ){
13805: p->validJD = 1;
13806: return 0;
13807: }else{
13808: return 1;
13809: }
13810: }
13811:
13812: /*
13813: ** Attempt to parse the given string into a Julian Day Number. Return
13814: ** the number of errors.
13815: **
13816: ** The following are acceptable forms for the input string:
13817: **
13818: ** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM
13819: ** DDDD.DD
13820: ** now
13821: **
13822: ** In the first form, the +/-HH:MM is always optional. The fractional
13823: ** seconds extension (the ".FFF") is optional. The seconds portion
13824: ** (":SS.FFF") is option. The year and date can be omitted as long
13825: ** as there is a time string. The time string can be omitted as long
13826: ** as there is a year and date.
13827: */
13828: static int parseDateOrTime(
13829: sqlite3_context *context,
13830: const char *zDate,
13831: DateTime *p
13832: ){
13833: double r;
13834: if( parseYyyyMmDd(zDate,p)==0 ){
13835: return 0;
13836: }else if( parseHhMmSs(zDate, p)==0 ){
13837: return 0;
13838: }else if( sqlite3StrICmp(zDate,"now")==0){
13839: return setDateTimeToCurrent(context, p);
13840: }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8) ){
13841: p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5);
13842: p->validJD = 1;
13843: return 0;
13844: }
13845: return 1;
13846: }
13847:
13848: /*
13849: ** Compute the Year, Month, and Day from the julian day number.
13850: */
13851: static void computeYMD(DateTime *p){
13852: int Z, A, B, C, D, E, X1;
13853: if( p->validYMD ) return;
13854: if( !p->validJD ){
13855: p->Y = 2000;
13856: p->M = 1;
13857: p->D = 1;
13858: }else{
13859: Z = (int)((p->iJD + 43200000)/86400000);
13860: A = (int)((Z - 1867216.25)/36524.25);
13861: A = Z + 1 + A - (A/4);
13862: B = A + 1524;
13863: C = (int)((B - 122.1)/365.25);
13864: D = (36525*C)/100;
13865: E = (int)((B-D)/30.6001);
13866: X1 = (int)(30.6001*E);
13867: p->D = B - D - X1;
13868: p->M = E<14 ? E-1 : E-13;
13869: p->Y = p->M>2 ? C - 4716 : C - 4715;
13870: }
13871: p->validYMD = 1;
13872: }
13873:
13874: /*
13875: ** Compute the Hour, Minute, and Seconds from the julian day number.
13876: */
13877: static void computeHMS(DateTime *p){
13878: int s;
13879: if( p->validHMS ) return;
13880: computeJD(p);
13881: s = (int)((p->iJD + 43200000) % 86400000);
13882: p->s = s/1000.0;
13883: s = (int)p->s;
13884: p->s -= s;
13885: p->h = s/3600;
13886: s -= p->h*3600;
13887: p->m = s/60;
13888: p->s += s - p->m*60;
13889: p->validHMS = 1;
13890: }
13891:
13892: /*
13893: ** Compute both YMD and HMS
13894: */
13895: static void computeYMD_HMS(DateTime *p){
13896: computeYMD(p);
13897: computeHMS(p);
13898: }
13899:
13900: /*
13901: ** Clear the YMD and HMS and the TZ
13902: */
13903: static void clearYMD_HMS_TZ(DateTime *p){
13904: p->validYMD = 0;
13905: p->validHMS = 0;
13906: p->validTZ = 0;
13907: }
13908:
13909: /*
13910: ** On recent Windows platforms, the localtime_s() function is available
13911: ** as part of the "Secure CRT". It is essentially equivalent to
13912: ** localtime_r() available under most POSIX platforms, except that the
13913: ** order of the parameters is reversed.
13914: **
13915: ** See http://msdn.microsoft.com/en-us/library/a442x3ye(VS.80).aspx.
13916: **
13917: ** If the user has not indicated to use localtime_r() or localtime_s()
13918: ** already, check for an MSVC build environment that provides
13919: ** localtime_s().
13920: */
13921: #if !defined(HAVE_LOCALTIME_R) && !defined(HAVE_LOCALTIME_S) && \
13922: defined(_MSC_VER) && defined(_CRT_INSECURE_DEPRECATE)
13923: #define HAVE_LOCALTIME_S 1
13924: #endif
13925:
13926: #ifndef SQLITE_OMIT_LOCALTIME
13927: /*
13928: ** The following routine implements the rough equivalent of localtime_r()
13929: ** using whatever operating-system specific localtime facility that
13930: ** is available. This routine returns 0 on success and
13931: ** non-zero on any kind of error.
13932: **
13933: ** If the sqlite3GlobalConfig.bLocaltimeFault variable is true then this
13934: ** routine will always fail.
13935: */
13936: static int osLocaltime(time_t *t, struct tm *pTm){
13937: int rc;
13938: #if (!defined(HAVE_LOCALTIME_R) || !HAVE_LOCALTIME_R) \
13939: && (!defined(HAVE_LOCALTIME_S) || !HAVE_LOCALTIME_S)
13940: struct tm *pX;
13941: #if SQLITE_THREADSAFE>0
13942: sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
13943: #endif
13944: sqlite3_mutex_enter(mutex);
13945: pX = localtime(t);
13946: #ifndef SQLITE_OMIT_BUILTIN_TEST
13947: if( sqlite3GlobalConfig.bLocaltimeFault ) pX = 0;
13948: #endif
13949: if( pX ) *pTm = *pX;
13950: sqlite3_mutex_leave(mutex);
13951: rc = pX==0;
13952: #else
13953: #ifndef SQLITE_OMIT_BUILTIN_TEST
13954: if( sqlite3GlobalConfig.bLocaltimeFault ) return 1;
13955: #endif
13956: #if defined(HAVE_LOCALTIME_R) && HAVE_LOCALTIME_R
13957: rc = localtime_r(t, pTm)==0;
13958: #else
13959: rc = localtime_s(pTm, t);
13960: #endif /* HAVE_LOCALTIME_R */
13961: #endif /* HAVE_LOCALTIME_R || HAVE_LOCALTIME_S */
13962: return rc;
13963: }
13964: #endif /* SQLITE_OMIT_LOCALTIME */
13965:
13966:
13967: #ifndef SQLITE_OMIT_LOCALTIME
13968: /*
13969: ** Compute the difference (in milliseconds) between localtime and UTC
13970: ** (a.k.a. GMT) for the time value p where p is in UTC. If no error occurs,
13971: ** return this value and set *pRc to SQLITE_OK.
13972: **
13973: ** Or, if an error does occur, set *pRc to SQLITE_ERROR. The returned value
13974: ** is undefined in this case.
13975: */
13976: static sqlite3_int64 localtimeOffset(
13977: DateTime *p, /* Date at which to calculate offset */
13978: sqlite3_context *pCtx, /* Write error here if one occurs */
13979: int *pRc /* OUT: Error code. SQLITE_OK or ERROR */
13980: ){
13981: DateTime x, y;
13982: time_t t;
13983: struct tm sLocal;
13984:
13985: /* Initialize the contents of sLocal to avoid a compiler warning. */
13986: memset(&sLocal, 0, sizeof(sLocal));
13987:
13988: x = *p;
13989: computeYMD_HMS(&x);
13990: if( x.Y<1971 || x.Y>=2038 ){
13991: x.Y = 2000;
13992: x.M = 1;
13993: x.D = 1;
13994: x.h = 0;
13995: x.m = 0;
13996: x.s = 0.0;
13997: } else {
13998: int s = (int)(x.s + 0.5);
13999: x.s = s;
14000: }
14001: x.tz = 0;
14002: x.validJD = 0;
14003: computeJD(&x);
14004: t = (time_t)(x.iJD/1000 - 21086676*(i64)10000);
14005: if( osLocaltime(&t, &sLocal) ){
14006: sqlite3_result_error(pCtx, "local time unavailable", -1);
14007: *pRc = SQLITE_ERROR;
14008: return 0;
14009: }
14010: y.Y = sLocal.tm_year + 1900;
14011: y.M = sLocal.tm_mon + 1;
14012: y.D = sLocal.tm_mday;
14013: y.h = sLocal.tm_hour;
14014: y.m = sLocal.tm_min;
14015: y.s = sLocal.tm_sec;
14016: y.validYMD = 1;
14017: y.validHMS = 1;
14018: y.validJD = 0;
14019: y.validTZ = 0;
14020: computeJD(&y);
14021: *pRc = SQLITE_OK;
14022: return y.iJD - x.iJD;
14023: }
14024: #endif /* SQLITE_OMIT_LOCALTIME */
14025:
14026: /*
14027: ** Process a modifier to a date-time stamp. The modifiers are
14028: ** as follows:
14029: **
14030: ** NNN days
14031: ** NNN hours
14032: ** NNN minutes
14033: ** NNN.NNNN seconds
14034: ** NNN months
14035: ** NNN years
14036: ** start of month
14037: ** start of year
14038: ** start of week
14039: ** start of day
14040: ** weekday N
14041: ** unixepoch
14042: ** localtime
14043: ** utc
14044: **
14045: ** Return 0 on success and 1 if there is any kind of error. If the error
14046: ** is in a system call (i.e. localtime()), then an error message is written
14047: ** to context pCtx. If the error is an unrecognized modifier, no error is
14048: ** written to pCtx.
14049: */
14050: static int parseModifier(sqlite3_context *pCtx, const char *zMod, DateTime *p){
14051: int rc = 1;
14052: int n;
14053: double r;
14054: char *z, zBuf[30];
14055: z = zBuf;
14056: for(n=0; n<ArraySize(zBuf)-1 && zMod[n]; n++){
14057: z[n] = (char)sqlite3UpperToLower[(u8)zMod[n]];
14058: }
14059: z[n] = 0;
14060: switch( z[0] ){
14061: #ifndef SQLITE_OMIT_LOCALTIME
14062: case 'l': {
14063: /* localtime
14064: **
14065: ** Assuming the current time value is UTC (a.k.a. GMT), shift it to
14066: ** show local time.
14067: */
14068: if( strcmp(z, "localtime")==0 ){
14069: computeJD(p);
14070: p->iJD += localtimeOffset(p, pCtx, &rc);
14071: clearYMD_HMS_TZ(p);
14072: }
14073: break;
14074: }
14075: #endif
14076: case 'u': {
14077: /*
14078: ** unixepoch
14079: **
14080: ** Treat the current value of p->iJD as the number of
14081: ** seconds since 1970. Convert to a real julian day number.
14082: */
14083: if( strcmp(z, "unixepoch")==0 && p->validJD ){
14084: p->iJD = (p->iJD + 43200)/86400 + 21086676*(i64)10000000;
14085: clearYMD_HMS_TZ(p);
14086: rc = 0;
14087: }
14088: #ifndef SQLITE_OMIT_LOCALTIME
14089: else if( strcmp(z, "utc")==0 ){
14090: sqlite3_int64 c1;
14091: computeJD(p);
14092: c1 = localtimeOffset(p, pCtx, &rc);
14093: if( rc==SQLITE_OK ){
14094: p->iJD -= c1;
14095: clearYMD_HMS_TZ(p);
14096: p->iJD += c1 - localtimeOffset(p, pCtx, &rc);
14097: }
14098: }
14099: #endif
14100: break;
14101: }
14102: case 'w': {
14103: /*
14104: ** weekday N
14105: **
14106: ** Move the date to the same time on the next occurrence of
14107: ** weekday N where 0==Sunday, 1==Monday, and so forth. If the
14108: ** date is already on the appropriate weekday, this is a no-op.
14109: */
14110: if( strncmp(z, "weekday ", 8)==0
14111: && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8)
14112: && (n=(int)r)==r && n>=0 && r<7 ){
14113: sqlite3_int64 Z;
14114: computeYMD_HMS(p);
14115: p->validTZ = 0;
14116: p->validJD = 0;
14117: computeJD(p);
14118: Z = ((p->iJD + 129600000)/86400000) % 7;
14119: if( Z>n ) Z -= 7;
14120: p->iJD += (n - Z)*86400000;
14121: clearYMD_HMS_TZ(p);
14122: rc = 0;
14123: }
14124: break;
14125: }
14126: case 's': {
14127: /*
14128: ** start of TTTTT
14129: **
14130: ** Move the date backwards to the beginning of the current day,
14131: ** or month or year.
14132: */
14133: if( strncmp(z, "start of ", 9)!=0 ) break;
14134: z += 9;
14135: computeYMD(p);
14136: p->validHMS = 1;
14137: p->h = p->m = 0;
14138: p->s = 0.0;
14139: p->validTZ = 0;
14140: p->validJD = 0;
14141: if( strcmp(z,"month")==0 ){
14142: p->D = 1;
14143: rc = 0;
14144: }else if( strcmp(z,"year")==0 ){
14145: computeYMD(p);
14146: p->M = 1;
14147: p->D = 1;
14148: rc = 0;
14149: }else if( strcmp(z,"day")==0 ){
14150: rc = 0;
14151: }
14152: break;
14153: }
14154: case '+':
14155: case '-':
14156: case '0':
14157: case '1':
14158: case '2':
14159: case '3':
14160: case '4':
14161: case '5':
14162: case '6':
14163: case '7':
14164: case '8':
14165: case '9': {
14166: double rRounder;
14167: for(n=1; z[n] && z[n]!=':' && !sqlite3Isspace(z[n]); n++){}
14168: if( !sqlite3AtoF(z, &r, n, SQLITE_UTF8) ){
14169: rc = 1;
14170: break;
14171: }
14172: if( z[n]==':' ){
14173: /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the
14174: ** specified number of hours, minutes, seconds, and fractional seconds
14175: ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be
14176: ** omitted.
14177: */
14178: const char *z2 = z;
14179: DateTime tx;
14180: sqlite3_int64 day;
14181: if( !sqlite3Isdigit(*z2) ) z2++;
14182: memset(&tx, 0, sizeof(tx));
14183: if( parseHhMmSs(z2, &tx) ) break;
14184: computeJD(&tx);
14185: tx.iJD -= 43200000;
14186: day = tx.iJD/86400000;
14187: tx.iJD -= day*86400000;
14188: if( z[0]=='-' ) tx.iJD = -tx.iJD;
14189: computeJD(p);
14190: clearYMD_HMS_TZ(p);
14191: p->iJD += tx.iJD;
14192: rc = 0;
14193: break;
14194: }
14195: z += n;
14196: while( sqlite3Isspace(*z) ) z++;
14197: n = sqlite3Strlen30(z);
14198: if( n>10 || n<3 ) break;
14199: if( z[n-1]=='s' ){ z[n-1] = 0; n--; }
14200: computeJD(p);
14201: rc = 0;
14202: rRounder = r<0 ? -0.5 : +0.5;
14203: if( n==3 && strcmp(z,"day")==0 ){
14204: p->iJD += (sqlite3_int64)(r*86400000.0 + rRounder);
14205: }else if( n==4 && strcmp(z,"hour")==0 ){
14206: p->iJD += (sqlite3_int64)(r*(86400000.0/24.0) + rRounder);
14207: }else if( n==6 && strcmp(z,"minute")==0 ){
14208: p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0)) + rRounder);
14209: }else if( n==6 && strcmp(z,"second")==0 ){
14210: p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0*60.0)) + rRounder);
14211: }else if( n==5 && strcmp(z,"month")==0 ){
14212: int x, y;
14213: computeYMD_HMS(p);
14214: p->M += (int)r;
14215: x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
14216: p->Y += x;
14217: p->M -= x*12;
14218: p->validJD = 0;
14219: computeJD(p);
14220: y = (int)r;
14221: if( y!=r ){
14222: p->iJD += (sqlite3_int64)((r - y)*30.0*86400000.0 + rRounder);
14223: }
14224: }else if( n==4 && strcmp(z,"year")==0 ){
14225: int y = (int)r;
14226: computeYMD_HMS(p);
14227: p->Y += y;
14228: p->validJD = 0;
14229: computeJD(p);
14230: if( y!=r ){
14231: p->iJD += (sqlite3_int64)((r - y)*365.0*86400000.0 + rRounder);
14232: }
14233: }else{
14234: rc = 1;
14235: }
14236: clearYMD_HMS_TZ(p);
14237: break;
14238: }
14239: default: {
14240: break;
14241: }
14242: }
14243: return rc;
14244: }
14245:
14246: /*
14247: ** Process time function arguments. argv[0] is a date-time stamp.
14248: ** argv[1] and following are modifiers. Parse them all and write
14249: ** the resulting time into the DateTime structure p. Return 0
14250: ** on success and 1 if there are any errors.
14251: **
14252: ** If there are zero parameters (if even argv[0] is undefined)
14253: ** then assume a default value of "now" for argv[0].
14254: */
14255: static int isDate(
14256: sqlite3_context *context,
14257: int argc,
14258: sqlite3_value **argv,
14259: DateTime *p
14260: ){
14261: int i;
14262: const unsigned char *z;
14263: int eType;
14264: memset(p, 0, sizeof(*p));
14265: if( argc==0 ){
14266: return setDateTimeToCurrent(context, p);
14267: }
14268: if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT
14269: || eType==SQLITE_INTEGER ){
14270: p->iJD = (sqlite3_int64)(sqlite3_value_double(argv[0])*86400000.0 + 0.5);
14271: p->validJD = 1;
14272: }else{
14273: z = sqlite3_value_text(argv[0]);
14274: if( !z || parseDateOrTime(context, (char*)z, p) ){
14275: return 1;
14276: }
14277: }
14278: for(i=1; i<argc; i++){
14279: z = sqlite3_value_text(argv[i]);
14280: if( z==0 || parseModifier(context, (char*)z, p) ) return 1;
14281: }
14282: return 0;
14283: }
14284:
14285:
14286: /*
14287: ** The following routines implement the various date and time functions
14288: ** of SQLite.
14289: */
14290:
14291: /*
14292: ** julianday( TIMESTRING, MOD, MOD, ...)
14293: **
14294: ** Return the julian day number of the date specified in the arguments
14295: */
14296: static void juliandayFunc(
14297: sqlite3_context *context,
14298: int argc,
14299: sqlite3_value **argv
14300: ){
14301: DateTime x;
14302: if( isDate(context, argc, argv, &x)==0 ){
14303: computeJD(&x);
14304: sqlite3_result_double(context, x.iJD/86400000.0);
14305: }
14306: }
14307:
14308: /*
14309: ** datetime( TIMESTRING, MOD, MOD, ...)
14310: **
14311: ** Return YYYY-MM-DD HH:MM:SS
14312: */
14313: static void datetimeFunc(
14314: sqlite3_context *context,
14315: int argc,
14316: sqlite3_value **argv
14317: ){
14318: DateTime x;
14319: if( isDate(context, argc, argv, &x)==0 ){
14320: char zBuf[100];
14321: computeYMD_HMS(&x);
14322: sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
14323: x.Y, x.M, x.D, x.h, x.m, (int)(x.s));
14324: sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
14325: }
14326: }
14327:
14328: /*
14329: ** time( TIMESTRING, MOD, MOD, ...)
14330: **
14331: ** Return HH:MM:SS
14332: */
14333: static void timeFunc(
14334: sqlite3_context *context,
14335: int argc,
14336: sqlite3_value **argv
14337: ){
14338: DateTime x;
14339: if( isDate(context, argc, argv, &x)==0 ){
14340: char zBuf[100];
14341: computeHMS(&x);
14342: sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
14343: sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
14344: }
14345: }
14346:
14347: /*
14348: ** date( TIMESTRING, MOD, MOD, ...)
14349: **
14350: ** Return YYYY-MM-DD
14351: */
14352: static void dateFunc(
14353: sqlite3_context *context,
14354: int argc,
14355: sqlite3_value **argv
14356: ){
14357: DateTime x;
14358: if( isDate(context, argc, argv, &x)==0 ){
14359: char zBuf[100];
14360: computeYMD(&x);
14361: sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
14362: sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
14363: }
14364: }
14365:
14366: /*
14367: ** strftime( FORMAT, TIMESTRING, MOD, MOD, ...)
14368: **
14369: ** Return a string described by FORMAT. Conversions as follows:
14370: **
14371: ** %d day of month
14372: ** %f ** fractional seconds SS.SSS
14373: ** %H hour 00-24
14374: ** %j day of year 000-366
14375: ** %J ** Julian day number
14376: ** %m month 01-12
14377: ** %M minute 00-59
14378: ** %s seconds since 1970-01-01
14379: ** %S seconds 00-59
14380: ** %w day of week 0-6 sunday==0
14381: ** %W week of year 00-53
14382: ** %Y year 0000-9999
14383: ** %% %
14384: */
14385: static void strftimeFunc(
14386: sqlite3_context *context,
14387: int argc,
14388: sqlite3_value **argv
14389: ){
14390: DateTime x;
14391: u64 n;
14392: size_t i,j;
14393: char *z;
14394: sqlite3 *db;
14395: const char *zFmt = (const char*)sqlite3_value_text(argv[0]);
14396: char zBuf[100];
14397: if( zFmt==0 || isDate(context, argc-1, argv+1, &x) ) return;
14398: db = sqlite3_context_db_handle(context);
14399: for(i=0, n=1; zFmt[i]; i++, n++){
14400: if( zFmt[i]=='%' ){
14401: switch( zFmt[i+1] ){
14402: case 'd':
14403: case 'H':
14404: case 'm':
14405: case 'M':
14406: case 'S':
14407: case 'W':
14408: n++;
14409: /* fall thru */
14410: case 'w':
14411: case '%':
14412: break;
14413: case 'f':
14414: n += 8;
14415: break;
14416: case 'j':
14417: n += 3;
14418: break;
14419: case 'Y':
14420: n += 8;
14421: break;
14422: case 's':
14423: case 'J':
14424: n += 50;
14425: break;
14426: default:
14427: return; /* ERROR. return a NULL */
14428: }
14429: i++;
14430: }
14431: }
14432: testcase( n==sizeof(zBuf)-1 );
14433: testcase( n==sizeof(zBuf) );
14434: testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
14435: testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] );
14436: if( n<sizeof(zBuf) ){
14437: z = zBuf;
14438: }else if( n>(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ){
14439: sqlite3_result_error_toobig(context);
14440: return;
14441: }else{
14442: z = sqlite3DbMallocRaw(db, (int)n);
14443: if( z==0 ){
14444: sqlite3_result_error_nomem(context);
14445: return;
14446: }
14447: }
14448: computeJD(&x);
14449: computeYMD_HMS(&x);
14450: for(i=j=0; zFmt[i]; i++){
14451: if( zFmt[i]!='%' ){
14452: z[j++] = zFmt[i];
14453: }else{
14454: i++;
14455: switch( zFmt[i] ){
14456: case 'd': sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break;
14457: case 'f': {
14458: double s = x.s;
14459: if( s>59.999 ) s = 59.999;
14460: sqlite3_snprintf(7, &z[j],"%06.3f", s);
14461: j += sqlite3Strlen30(&z[j]);
14462: break;
14463: }
14464: case 'H': sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break;
14465: case 'W': /* Fall thru */
14466: case 'j': {
14467: int nDay; /* Number of days since 1st day of year */
14468: DateTime y = x;
14469: y.validJD = 0;
14470: y.M = 1;
14471: y.D = 1;
14472: computeJD(&y);
14473: nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
14474: if( zFmt[i]=='W' ){
14475: int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */
14476: wd = (int)(((x.iJD+43200000)/86400000)%7);
14477: sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7);
14478: j += 2;
14479: }else{
14480: sqlite3_snprintf(4, &z[j],"%03d",nDay+1);
14481: j += 3;
14482: }
14483: break;
14484: }
14485: case 'J': {
14486: sqlite3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0);
14487: j+=sqlite3Strlen30(&z[j]);
14488: break;
14489: }
14490: case 'm': sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break;
14491: case 'M': sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break;
14492: case 's': {
14493: sqlite3_snprintf(30,&z[j],"%lld",
14494: (i64)(x.iJD/1000 - 21086676*(i64)10000));
14495: j += sqlite3Strlen30(&z[j]);
14496: break;
14497: }
14498: case 'S': sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break;
14499: case 'w': {
14500: z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) + '0';
14501: break;
14502: }
14503: case 'Y': {
14504: sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]);
14505: break;
14506: }
14507: default: z[j++] = '%'; break;
14508: }
14509: }
14510: }
14511: z[j] = 0;
14512: sqlite3_result_text(context, z, -1,
14513: z==zBuf ? SQLITE_TRANSIENT : SQLITE_DYNAMIC);
14514: }
14515:
14516: /*
14517: ** current_time()
14518: **
14519: ** This function returns the same value as time('now').
14520: */
14521: static void ctimeFunc(
14522: sqlite3_context *context,
14523: int NotUsed,
14524: sqlite3_value **NotUsed2
14525: ){
14526: UNUSED_PARAMETER2(NotUsed, NotUsed2);
14527: timeFunc(context, 0, 0);
14528: }
14529:
14530: /*
14531: ** current_date()
14532: **
14533: ** This function returns the same value as date('now').
14534: */
14535: static void cdateFunc(
14536: sqlite3_context *context,
14537: int NotUsed,
14538: sqlite3_value **NotUsed2
14539: ){
14540: UNUSED_PARAMETER2(NotUsed, NotUsed2);
14541: dateFunc(context, 0, 0);
14542: }
14543:
14544: /*
14545: ** current_timestamp()
14546: **
14547: ** This function returns the same value as datetime('now').
14548: */
14549: static void ctimestampFunc(
14550: sqlite3_context *context,
14551: int NotUsed,
14552: sqlite3_value **NotUsed2
14553: ){
14554: UNUSED_PARAMETER2(NotUsed, NotUsed2);
14555: datetimeFunc(context, 0, 0);
14556: }
14557: #endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */
14558:
14559: #ifdef SQLITE_OMIT_DATETIME_FUNCS
14560: /*
14561: ** If the library is compiled to omit the full-scale date and time
14562: ** handling (to get a smaller binary), the following minimal version
14563: ** of the functions current_time(), current_date() and current_timestamp()
14564: ** are included instead. This is to support column declarations that
14565: ** include "DEFAULT CURRENT_TIME" etc.
14566: **
14567: ** This function uses the C-library functions time(), gmtime()
14568: ** and strftime(). The format string to pass to strftime() is supplied
14569: ** as the user-data for the function.
14570: */
14571: static void currentTimeFunc(
14572: sqlite3_context *context,
14573: int argc,
14574: sqlite3_value **argv
14575: ){
14576: time_t t;
14577: char *zFormat = (char *)sqlite3_user_data(context);
14578: sqlite3 *db;
14579: sqlite3_int64 iT;
14580: struct tm *pTm;
14581: struct tm sNow;
14582: char zBuf[20];
14583:
14584: UNUSED_PARAMETER(argc);
14585: UNUSED_PARAMETER(argv);
14586:
14587: db = sqlite3_context_db_handle(context);
14588: if( sqlite3OsCurrentTimeInt64(db->pVfs, &iT) ) return;
14589: t = iT/1000 - 10000*(sqlite3_int64)21086676;
14590: #ifdef HAVE_GMTIME_R
14591: pTm = gmtime_r(&t, &sNow);
14592: #else
14593: sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
14594: pTm = gmtime(&t);
14595: if( pTm ) memcpy(&sNow, pTm, sizeof(sNow));
14596: sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
14597: #endif
14598: if( pTm ){
14599: strftime(zBuf, 20, zFormat, &sNow);
14600: sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
14601: }
14602: }
14603: #endif
14604:
14605: /*
14606: ** This function registered all of the above C functions as SQL
14607: ** functions. This should be the only routine in this file with
14608: ** external linkage.
14609: */
14610: SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){
14611: static SQLITE_WSD FuncDef aDateTimeFuncs[] = {
14612: #ifndef SQLITE_OMIT_DATETIME_FUNCS
14613: FUNCTION(julianday, -1, 0, 0, juliandayFunc ),
14614: FUNCTION(date, -1, 0, 0, dateFunc ),
14615: FUNCTION(time, -1, 0, 0, timeFunc ),
14616: FUNCTION(datetime, -1, 0, 0, datetimeFunc ),
14617: FUNCTION(strftime, -1, 0, 0, strftimeFunc ),
14618: FUNCTION(current_time, 0, 0, 0, ctimeFunc ),
14619: FUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc),
14620: FUNCTION(current_date, 0, 0, 0, cdateFunc ),
14621: #else
14622: STR_FUNCTION(current_time, 0, "%H:%M:%S", 0, currentTimeFunc),
14623: STR_FUNCTION(current_date, 0, "%Y-%m-%d", 0, currentTimeFunc),
14624: STR_FUNCTION(current_timestamp, 0, "%Y-%m-%d %H:%M:%S", 0, currentTimeFunc),
14625: #endif
14626: };
14627: int i;
14628: FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
14629: FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aDateTimeFuncs);
14630:
14631: for(i=0; i<ArraySize(aDateTimeFuncs); i++){
14632: sqlite3FuncDefInsert(pHash, &aFunc[i]);
14633: }
14634: }
14635:
14636: /************** End of date.c ************************************************/
14637: /************** Begin file os.c **********************************************/
14638: /*
14639: ** 2005 November 29
14640: **
14641: ** The author disclaims copyright to this source code. In place of
14642: ** a legal notice, here is a blessing:
14643: **
14644: ** May you do good and not evil.
14645: ** May you find forgiveness for yourself and forgive others.
14646: ** May you share freely, never taking more than you give.
14647: **
14648: ******************************************************************************
14649: **
14650: ** This file contains OS interface code that is common to all
14651: ** architectures.
14652: */
14653: #define _SQLITE_OS_C_ 1
14654: #undef _SQLITE_OS_C_
14655:
14656: /*
14657: ** The default SQLite sqlite3_vfs implementations do not allocate
14658: ** memory (actually, os_unix.c allocates a small amount of memory
14659: ** from within OsOpen()), but some third-party implementations may.
14660: ** So we test the effects of a malloc() failing and the sqlite3OsXXX()
14661: ** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
14662: **
14663: ** The following functions are instrumented for malloc() failure
14664: ** testing:
14665: **
14666: ** sqlite3OsRead()
14667: ** sqlite3OsWrite()
14668: ** sqlite3OsSync()
14669: ** sqlite3OsFileSize()
14670: ** sqlite3OsLock()
14671: ** sqlite3OsCheckReservedLock()
14672: ** sqlite3OsFileControl()
14673: ** sqlite3OsShmMap()
14674: ** sqlite3OsOpen()
14675: ** sqlite3OsDelete()
14676: ** sqlite3OsAccess()
14677: ** sqlite3OsFullPathname()
14678: **
14679: */
14680: #if defined(SQLITE_TEST)
14681: SQLITE_API int sqlite3_memdebug_vfs_oom_test = 1;
14682: #define DO_OS_MALLOC_TEST(x) \
14683: if (sqlite3_memdebug_vfs_oom_test && (!x || !sqlite3IsMemJournal(x))) { \
14684: void *pTstAlloc = sqlite3Malloc(10); \
14685: if (!pTstAlloc) return SQLITE_IOERR_NOMEM; \
14686: sqlite3_free(pTstAlloc); \
14687: }
14688: #else
14689: #define DO_OS_MALLOC_TEST(x)
14690: #endif
14691:
14692: /*
14693: ** The following routines are convenience wrappers around methods
14694: ** of the sqlite3_file object. This is mostly just syntactic sugar. All
14695: ** of this would be completely automatic if SQLite were coded using
14696: ** C++ instead of plain old C.
14697: */
14698: SQLITE_PRIVATE int sqlite3OsClose(sqlite3_file *pId){
14699: int rc = SQLITE_OK;
14700: if( pId->pMethods ){
14701: rc = pId->pMethods->xClose(pId);
14702: pId->pMethods = 0;
14703: }
14704: return rc;
14705: }
14706: SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
14707: DO_OS_MALLOC_TEST(id);
14708: return id->pMethods->xRead(id, pBuf, amt, offset);
14709: }
14710: SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
14711: DO_OS_MALLOC_TEST(id);
14712: return id->pMethods->xWrite(id, pBuf, amt, offset);
14713: }
14714: SQLITE_PRIVATE int sqlite3OsTruncate(sqlite3_file *id, i64 size){
14715: return id->pMethods->xTruncate(id, size);
14716: }
14717: SQLITE_PRIVATE int sqlite3OsSync(sqlite3_file *id, int flags){
14718: DO_OS_MALLOC_TEST(id);
14719: return id->pMethods->xSync(id, flags);
14720: }
14721: SQLITE_PRIVATE int sqlite3OsFileSize(sqlite3_file *id, i64 *pSize){
14722: DO_OS_MALLOC_TEST(id);
14723: return id->pMethods->xFileSize(id, pSize);
14724: }
14725: SQLITE_PRIVATE int sqlite3OsLock(sqlite3_file *id, int lockType){
14726: DO_OS_MALLOC_TEST(id);
14727: return id->pMethods->xLock(id, lockType);
14728: }
14729: SQLITE_PRIVATE int sqlite3OsUnlock(sqlite3_file *id, int lockType){
14730: return id->pMethods->xUnlock(id, lockType);
14731: }
14732: SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){
14733: DO_OS_MALLOC_TEST(id);
14734: return id->pMethods->xCheckReservedLock(id, pResOut);
14735: }
14736:
14737: /*
14738: ** Use sqlite3OsFileControl() when we are doing something that might fail
14739: ** and we need to know about the failures. Use sqlite3OsFileControlHint()
14740: ** when simply tossing information over the wall to the VFS and we do not
14741: ** really care if the VFS receives and understands the information since it
14742: ** is only a hint and can be safely ignored. The sqlite3OsFileControlHint()
14743: ** routine has no return value since the return value would be meaningless.
14744: */
14745: SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
14746: DO_OS_MALLOC_TEST(id);
14747: return id->pMethods->xFileControl(id, op, pArg);
14748: }
14749: SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){
14750: (void)id->pMethods->xFileControl(id, op, pArg);
14751: }
14752:
14753: SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id){
14754: int (*xSectorSize)(sqlite3_file*) = id->pMethods->xSectorSize;
14755: return (xSectorSize ? xSectorSize(id) : SQLITE_DEFAULT_SECTOR_SIZE);
14756: }
14757: SQLITE_PRIVATE int sqlite3OsDeviceCharacteristics(sqlite3_file *id){
14758: return id->pMethods->xDeviceCharacteristics(id);
14759: }
14760: SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){
14761: return id->pMethods->xShmLock(id, offset, n, flags);
14762: }
14763: SQLITE_PRIVATE void sqlite3OsShmBarrier(sqlite3_file *id){
14764: id->pMethods->xShmBarrier(id);
14765: }
14766: SQLITE_PRIVATE int sqlite3OsShmUnmap(sqlite3_file *id, int deleteFlag){
14767: return id->pMethods->xShmUnmap(id, deleteFlag);
14768: }
14769: SQLITE_PRIVATE int sqlite3OsShmMap(
14770: sqlite3_file *id, /* Database file handle */
14771: int iPage,
14772: int pgsz,
14773: int bExtend, /* True to extend file if necessary */
14774: void volatile **pp /* OUT: Pointer to mapping */
14775: ){
14776: DO_OS_MALLOC_TEST(id);
14777: return id->pMethods->xShmMap(id, iPage, pgsz, bExtend, pp);
14778: }
14779:
14780: /*
14781: ** The next group of routines are convenience wrappers around the
14782: ** VFS methods.
14783: */
14784: SQLITE_PRIVATE int sqlite3OsOpen(
14785: sqlite3_vfs *pVfs,
14786: const char *zPath,
14787: sqlite3_file *pFile,
14788: int flags,
14789: int *pFlagsOut
14790: ){
14791: int rc;
14792: DO_OS_MALLOC_TEST(0);
14793: /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
14794: ** down into the VFS layer. Some SQLITE_OPEN_ flags (for example,
14795: ** SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
14796: ** reaching the VFS. */
14797: rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut);
14798: assert( rc==SQLITE_OK || pFile->pMethods==0 );
14799: return rc;
14800: }
14801: SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
14802: DO_OS_MALLOC_TEST(0);
14803: assert( dirSync==0 || dirSync==1 );
14804: return pVfs->xDelete(pVfs, zPath, dirSync);
14805: }
14806: SQLITE_PRIVATE int sqlite3OsAccess(
14807: sqlite3_vfs *pVfs,
14808: const char *zPath,
14809: int flags,
14810: int *pResOut
14811: ){
14812: DO_OS_MALLOC_TEST(0);
14813: return pVfs->xAccess(pVfs, zPath, flags, pResOut);
14814: }
14815: SQLITE_PRIVATE int sqlite3OsFullPathname(
14816: sqlite3_vfs *pVfs,
14817: const char *zPath,
14818: int nPathOut,
14819: char *zPathOut
14820: ){
14821: DO_OS_MALLOC_TEST(0);
14822: zPathOut[0] = 0;
14823: return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
14824: }
14825: #ifndef SQLITE_OMIT_LOAD_EXTENSION
14826: SQLITE_PRIVATE void *sqlite3OsDlOpen(sqlite3_vfs *pVfs, const char *zPath){
14827: return pVfs->xDlOpen(pVfs, zPath);
14828: }
14829: SQLITE_PRIVATE void sqlite3OsDlError(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
14830: pVfs->xDlError(pVfs, nByte, zBufOut);
14831: }
14832: SQLITE_PRIVATE void (*sqlite3OsDlSym(sqlite3_vfs *pVfs, void *pHdle, const char *zSym))(void){
14833: return pVfs->xDlSym(pVfs, pHdle, zSym);
14834: }
14835: SQLITE_PRIVATE void sqlite3OsDlClose(sqlite3_vfs *pVfs, void *pHandle){
14836: pVfs->xDlClose(pVfs, pHandle);
14837: }
14838: #endif /* SQLITE_OMIT_LOAD_EXTENSION */
14839: SQLITE_PRIVATE int sqlite3OsRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
14840: return pVfs->xRandomness(pVfs, nByte, zBufOut);
14841: }
14842: SQLITE_PRIVATE int sqlite3OsSleep(sqlite3_vfs *pVfs, int nMicro){
14843: return pVfs->xSleep(pVfs, nMicro);
14844: }
14845: SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
14846: int rc;
14847: /* IMPLEMENTATION-OF: R-49045-42493 SQLite will use the xCurrentTimeInt64()
14848: ** method to get the current date and time if that method is available
14849: ** (if iVersion is 2 or greater and the function pointer is not NULL) and
14850: ** will fall back to xCurrentTime() if xCurrentTimeInt64() is
14851: ** unavailable.
14852: */
14853: if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
14854: rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut);
14855: }else{
14856: double r;
14857: rc = pVfs->xCurrentTime(pVfs, &r);
14858: *pTimeOut = (sqlite3_int64)(r*86400000.0);
14859: }
14860: return rc;
14861: }
14862:
14863: SQLITE_PRIVATE int sqlite3OsOpenMalloc(
14864: sqlite3_vfs *pVfs,
14865: const char *zFile,
14866: sqlite3_file **ppFile,
14867: int flags,
14868: int *pOutFlags
14869: ){
14870: int rc = SQLITE_NOMEM;
14871: sqlite3_file *pFile;
14872: pFile = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
14873: if( pFile ){
14874: rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
14875: if( rc!=SQLITE_OK ){
14876: sqlite3_free(pFile);
14877: }else{
14878: *ppFile = pFile;
14879: }
14880: }
14881: return rc;
14882: }
14883: SQLITE_PRIVATE int sqlite3OsCloseFree(sqlite3_file *pFile){
14884: int rc = SQLITE_OK;
14885: assert( pFile );
14886: rc = sqlite3OsClose(pFile);
14887: sqlite3_free(pFile);
14888: return rc;
14889: }
14890:
14891: /*
14892: ** This function is a wrapper around the OS specific implementation of
14893: ** sqlite3_os_init(). The purpose of the wrapper is to provide the
14894: ** ability to simulate a malloc failure, so that the handling of an
14895: ** error in sqlite3_os_init() by the upper layers can be tested.
14896: */
14897: SQLITE_PRIVATE int sqlite3OsInit(void){
14898: void *p = sqlite3_malloc(10);
14899: if( p==0 ) return SQLITE_NOMEM;
14900: sqlite3_free(p);
14901: return sqlite3_os_init();
14902: }
14903:
14904: /*
14905: ** The list of all registered VFS implementations.
14906: */
14907: static sqlite3_vfs * SQLITE_WSD vfsList = 0;
14908: #define vfsList GLOBAL(sqlite3_vfs *, vfsList)
14909:
14910: /*
14911: ** Locate a VFS by name. If no name is given, simply return the
14912: ** first VFS on the list.
14913: */
14914: SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
14915: sqlite3_vfs *pVfs = 0;
14916: #if SQLITE_THREADSAFE
14917: sqlite3_mutex *mutex;
14918: #endif
14919: #ifndef SQLITE_OMIT_AUTOINIT
14920: int rc = sqlite3_initialize();
14921: if( rc ) return 0;
14922: #endif
14923: #if SQLITE_THREADSAFE
14924: mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
14925: #endif
14926: sqlite3_mutex_enter(mutex);
14927: for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
14928: if( zVfs==0 ) break;
14929: if( strcmp(zVfs, pVfs->zName)==0 ) break;
14930: }
14931: sqlite3_mutex_leave(mutex);
14932: return pVfs;
14933: }
14934:
14935: /*
14936: ** Unlink a VFS from the linked list
14937: */
14938: static void vfsUnlink(sqlite3_vfs *pVfs){
14939: assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) );
14940: if( pVfs==0 ){
14941: /* No-op */
14942: }else if( vfsList==pVfs ){
14943: vfsList = pVfs->pNext;
14944: }else if( vfsList ){
14945: sqlite3_vfs *p = vfsList;
14946: while( p->pNext && p->pNext!=pVfs ){
14947: p = p->pNext;
14948: }
14949: if( p->pNext==pVfs ){
14950: p->pNext = pVfs->pNext;
14951: }
14952: }
14953: }
14954:
14955: /*
14956: ** Register a VFS with the system. It is harmless to register the same
14957: ** VFS multiple times. The new VFS becomes the default if makeDflt is
14958: ** true.
14959: */
14960: SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
14961: MUTEX_LOGIC(sqlite3_mutex *mutex;)
14962: #ifndef SQLITE_OMIT_AUTOINIT
14963: int rc = sqlite3_initialize();
14964: if( rc ) return rc;
14965: #endif
14966: MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
14967: sqlite3_mutex_enter(mutex);
14968: vfsUnlink(pVfs);
14969: if( makeDflt || vfsList==0 ){
14970: pVfs->pNext = vfsList;
14971: vfsList = pVfs;
14972: }else{
14973: pVfs->pNext = vfsList->pNext;
14974: vfsList->pNext = pVfs;
14975: }
14976: assert(vfsList);
14977: sqlite3_mutex_leave(mutex);
14978: return SQLITE_OK;
14979: }
14980:
14981: /*
14982: ** Unregister a VFS so that it is no longer accessible.
14983: */
14984: SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
14985: #if SQLITE_THREADSAFE
14986: sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
14987: #endif
14988: sqlite3_mutex_enter(mutex);
14989: vfsUnlink(pVfs);
14990: sqlite3_mutex_leave(mutex);
14991: return SQLITE_OK;
14992: }
14993:
14994: /************** End of os.c **************************************************/
14995: /************** Begin file fault.c *******************************************/
14996: /*
14997: ** 2008 Jan 22
14998: **
14999: ** The author disclaims copyright to this source code. In place of
15000: ** a legal notice, here is a blessing:
15001: **
15002: ** May you do good and not evil.
15003: ** May you find forgiveness for yourself and forgive others.
15004: ** May you share freely, never taking more than you give.
15005: **
15006: *************************************************************************
15007: **
15008: ** This file contains code to support the concept of "benign"
15009: ** malloc failures (when the xMalloc() or xRealloc() method of the
15010: ** sqlite3_mem_methods structure fails to allocate a block of memory
15011: ** and returns 0).
15012: **
15013: ** Most malloc failures are non-benign. After they occur, SQLite
15014: ** abandons the current operation and returns an error code (usually
15015: ** SQLITE_NOMEM) to the user. However, sometimes a fault is not necessarily
15016: ** fatal. For example, if a malloc fails while resizing a hash table, this
15017: ** is completely recoverable simply by not carrying out the resize. The
15018: ** hash table will continue to function normally. So a malloc failure
15019: ** during a hash table resize is a benign fault.
15020: */
15021:
15022:
15023: #ifndef SQLITE_OMIT_BUILTIN_TEST
15024:
15025: /*
15026: ** Global variables.
15027: */
15028: typedef struct BenignMallocHooks BenignMallocHooks;
15029: static SQLITE_WSD struct BenignMallocHooks {
15030: void (*xBenignBegin)(void);
15031: void (*xBenignEnd)(void);
15032: } sqlite3Hooks = { 0, 0 };
15033:
15034: /* The "wsdHooks" macro will resolve to the appropriate BenignMallocHooks
15035: ** structure. If writable static data is unsupported on the target,
15036: ** we have to locate the state vector at run-time. In the more common
15037: ** case where writable static data is supported, wsdHooks can refer directly
15038: ** to the "sqlite3Hooks" state vector declared above.
15039: */
15040: #ifdef SQLITE_OMIT_WSD
15041: # define wsdHooksInit \
15042: BenignMallocHooks *x = &GLOBAL(BenignMallocHooks,sqlite3Hooks)
15043: # define wsdHooks x[0]
15044: #else
15045: # define wsdHooksInit
15046: # define wsdHooks sqlite3Hooks
15047: #endif
15048:
15049:
15050: /*
15051: ** Register hooks to call when sqlite3BeginBenignMalloc() and
15052: ** sqlite3EndBenignMalloc() are called, respectively.
15053: */
15054: SQLITE_PRIVATE void sqlite3BenignMallocHooks(
15055: void (*xBenignBegin)(void),
15056: void (*xBenignEnd)(void)
15057: ){
15058: wsdHooksInit;
15059: wsdHooks.xBenignBegin = xBenignBegin;
15060: wsdHooks.xBenignEnd = xBenignEnd;
15061: }
15062:
15063: /*
15064: ** This (sqlite3EndBenignMalloc()) is called by SQLite code to indicate that
15065: ** subsequent malloc failures are benign. A call to sqlite3EndBenignMalloc()
15066: ** indicates that subsequent malloc failures are non-benign.
15067: */
15068: SQLITE_PRIVATE void sqlite3BeginBenignMalloc(void){
15069: wsdHooksInit;
15070: if( wsdHooks.xBenignBegin ){
15071: wsdHooks.xBenignBegin();
15072: }
15073: }
15074: SQLITE_PRIVATE void sqlite3EndBenignMalloc(void){
15075: wsdHooksInit;
15076: if( wsdHooks.xBenignEnd ){
15077: wsdHooks.xBenignEnd();
15078: }
15079: }
15080:
15081: #endif /* #ifndef SQLITE_OMIT_BUILTIN_TEST */
15082:
15083: /************** End of fault.c ***********************************************/
15084: /************** Begin file mem0.c ********************************************/
15085: /*
15086: ** 2008 October 28
15087: **
15088: ** The author disclaims copyright to this source code. In place of
15089: ** a legal notice, here is a blessing:
15090: **
15091: ** May you do good and not evil.
15092: ** May you find forgiveness for yourself and forgive others.
15093: ** May you share freely, never taking more than you give.
15094: **
15095: *************************************************************************
15096: **
15097: ** This file contains a no-op memory allocation drivers for use when
15098: ** SQLITE_ZERO_MALLOC is defined. The allocation drivers implemented
15099: ** here always fail. SQLite will not operate with these drivers. These
15100: ** are merely placeholders. Real drivers must be substituted using
15101: ** sqlite3_config() before SQLite will operate.
15102: */
15103:
15104: /*
15105: ** This version of the memory allocator is the default. It is
15106: ** used when no other memory allocator is specified using compile-time
15107: ** macros.
15108: */
15109: #ifdef SQLITE_ZERO_MALLOC
15110:
15111: /*
15112: ** No-op versions of all memory allocation routines
15113: */
15114: static void *sqlite3MemMalloc(int nByte){ return 0; }
15115: static void sqlite3MemFree(void *pPrior){ return; }
15116: static void *sqlite3MemRealloc(void *pPrior, int nByte){ return 0; }
15117: static int sqlite3MemSize(void *pPrior){ return 0; }
15118: static int sqlite3MemRoundup(int n){ return n; }
15119: static int sqlite3MemInit(void *NotUsed){ return SQLITE_OK; }
15120: static void sqlite3MemShutdown(void *NotUsed){ return; }
15121:
15122: /*
15123: ** This routine is the only routine in this file with external linkage.
15124: **
15125: ** Populate the low-level memory allocation function pointers in
15126: ** sqlite3GlobalConfig.m with pointers to the routines in this file.
15127: */
15128: SQLITE_PRIVATE void sqlite3MemSetDefault(void){
15129: static const sqlite3_mem_methods defaultMethods = {
15130: sqlite3MemMalloc,
15131: sqlite3MemFree,
15132: sqlite3MemRealloc,
15133: sqlite3MemSize,
15134: sqlite3MemRoundup,
15135: sqlite3MemInit,
15136: sqlite3MemShutdown,
15137: 0
15138: };
15139: sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
15140: }
15141:
15142: #endif /* SQLITE_ZERO_MALLOC */
15143:
15144: /************** End of mem0.c ************************************************/
15145: /************** Begin file mem1.c ********************************************/
15146: /*
15147: ** 2007 August 14
15148: **
15149: ** The author disclaims copyright to this source code. In place of
15150: ** a legal notice, here is a blessing:
15151: **
15152: ** May you do good and not evil.
15153: ** May you find forgiveness for yourself and forgive others.
15154: ** May you share freely, never taking more than you give.
15155: **
15156: *************************************************************************
15157: **
15158: ** This file contains low-level memory allocation drivers for when
15159: ** SQLite will use the standard C-library malloc/realloc/free interface
15160: ** to obtain the memory it needs.
15161: **
15162: ** This file contains implementations of the low-level memory allocation
15163: ** routines specified in the sqlite3_mem_methods object.
15164: */
15165:
15166: /*
15167: ** This version of the memory allocator is the default. It is
15168: ** used when no other memory allocator is specified using compile-time
15169: ** macros.
15170: */
15171: #ifdef SQLITE_SYSTEM_MALLOC
15172:
15173: /*
15174: ** Windows systems have malloc_usable_size() but it is called _msize()
15175: */
15176: #if !defined(HAVE_MALLOC_USABLE_SIZE) && SQLITE_OS_WIN
15177: # define HAVE_MALLOC_USABLE_SIZE 1
15178: # define malloc_usable_size _msize
15179: #endif
15180:
15181: #if defined(__APPLE__)
15182:
15183: /*
15184: ** Use the zone allocator available on apple products
15185: */
15186: #include <sys/sysctl.h>
15187: #include <malloc/malloc.h>
15188: #include <libkern/OSAtomic.h>
15189: static malloc_zone_t* _sqliteZone_;
15190: #define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x))
15191: #define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x));
15192: #define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y))
15193: #define SQLITE_MALLOCSIZE(x) \
15194: (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x))
15195:
15196: #else /* if not __APPLE__ */
15197:
15198: /*
15199: ** Use standard C library malloc and free on non-Apple systems.
15200: */
15201: #define SQLITE_MALLOC(x) malloc(x)
15202: #define SQLITE_FREE(x) free(x)
15203: #define SQLITE_REALLOC(x,y) realloc((x),(y))
15204:
15205: #ifdef HAVE_MALLOC_USABLE_SIZE
15206: #include <malloc.h>
15207: #define SQLITE_MALLOCSIZE(x) malloc_usable_size(x)
15208: #else
15209: #undef SQLITE_MALLOCSIZE
15210: #endif
15211:
15212: #endif /* __APPLE__ or not __APPLE__ */
15213:
15214: /*
15215: ** Like malloc(), but remember the size of the allocation
15216: ** so that we can find it later using sqlite3MemSize().
15217: **
15218: ** For this low-level routine, we are guaranteed that nByte>0 because
15219: ** cases of nByte<=0 will be intercepted and dealt with by higher level
15220: ** routines.
15221: */
15222: static void *sqlite3MemMalloc(int nByte){
15223: #ifdef SQLITE_MALLOCSIZE
15224: void *p = SQLITE_MALLOC( nByte );
15225: if( p==0 ){
15226: testcase( sqlite3GlobalConfig.xLog!=0 );
15227: sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
15228: }
15229: return p;
15230: #else
15231: sqlite3_int64 *p;
15232: assert( nByte>0 );
15233: nByte = ROUND8(nByte);
15234: p = SQLITE_MALLOC( nByte+8 );
15235: if( p ){
15236: p[0] = nByte;
15237: p++;
15238: }else{
15239: testcase( sqlite3GlobalConfig.xLog!=0 );
15240: sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
15241: }
15242: return (void *)p;
15243: #endif
15244: }
15245:
15246: /*
15247: ** Like free() but works for allocations obtained from sqlite3MemMalloc()
15248: ** or sqlite3MemRealloc().
15249: **
15250: ** For this low-level routine, we already know that pPrior!=0 since
15251: ** cases where pPrior==0 will have been intecepted and dealt with
15252: ** by higher-level routines.
15253: */
15254: static void sqlite3MemFree(void *pPrior){
15255: #ifdef SQLITE_MALLOCSIZE
15256: SQLITE_FREE(pPrior);
15257: #else
15258: sqlite3_int64 *p = (sqlite3_int64*)pPrior;
15259: assert( pPrior!=0 );
15260: p--;
15261: SQLITE_FREE(p);
15262: #endif
15263: }
15264:
15265: /*
15266: ** Report the allocated size of a prior return from xMalloc()
15267: ** or xRealloc().
15268: */
15269: static int sqlite3MemSize(void *pPrior){
15270: #ifdef SQLITE_MALLOCSIZE
15271: return pPrior ? (int)SQLITE_MALLOCSIZE(pPrior) : 0;
15272: #else
15273: sqlite3_int64 *p;
15274: if( pPrior==0 ) return 0;
15275: p = (sqlite3_int64*)pPrior;
15276: p--;
15277: return (int)p[0];
15278: #endif
15279: }
15280:
15281: /*
15282: ** Like realloc(). Resize an allocation previously obtained from
15283: ** sqlite3MemMalloc().
15284: **
15285: ** For this low-level interface, we know that pPrior!=0. Cases where
15286: ** pPrior==0 while have been intercepted by higher-level routine and
15287: ** redirected to xMalloc. Similarly, we know that nByte>0 becauses
15288: ** cases where nByte<=0 will have been intercepted by higher-level
15289: ** routines and redirected to xFree.
15290: */
15291: static void *sqlite3MemRealloc(void *pPrior, int nByte){
15292: #ifdef SQLITE_MALLOCSIZE
15293: void *p = SQLITE_REALLOC(pPrior, nByte);
15294: if( p==0 ){
15295: testcase( sqlite3GlobalConfig.xLog!=0 );
15296: sqlite3_log(SQLITE_NOMEM,
15297: "failed memory resize %u to %u bytes",
15298: SQLITE_MALLOCSIZE(pPrior), nByte);
15299: }
15300: return p;
15301: #else
15302: sqlite3_int64 *p = (sqlite3_int64*)pPrior;
15303: assert( pPrior!=0 && nByte>0 );
15304: assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
15305: p--;
15306: p = SQLITE_REALLOC(p, nByte+8 );
15307: if( p ){
15308: p[0] = nByte;
15309: p++;
15310: }else{
15311: testcase( sqlite3GlobalConfig.xLog!=0 );
15312: sqlite3_log(SQLITE_NOMEM,
15313: "failed memory resize %u to %u bytes",
15314: sqlite3MemSize(pPrior), nByte);
15315: }
15316: return (void*)p;
15317: #endif
15318: }
15319:
15320: /*
15321: ** Round up a request size to the next valid allocation size.
15322: */
15323: static int sqlite3MemRoundup(int n){
15324: return ROUND8(n);
15325: }
15326:
15327: /*
15328: ** Initialize this module.
15329: */
15330: static int sqlite3MemInit(void *NotUsed){
15331: #if defined(__APPLE__)
15332: int cpuCount;
15333: size_t len;
15334: if( _sqliteZone_ ){
15335: return SQLITE_OK;
15336: }
15337: len = sizeof(cpuCount);
15338: /* One usually wants to use hw.acctivecpu for MT decisions, but not here */
15339: sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
15340: if( cpuCount>1 ){
15341: /* defer MT decisions to system malloc */
15342: _sqliteZone_ = malloc_default_zone();
15343: }else{
15344: /* only 1 core, use our own zone to contention over global locks,
15345: ** e.g. we have our own dedicated locks */
15346: bool success;
15347: malloc_zone_t* newzone = malloc_create_zone(4096, 0);
15348: malloc_set_zone_name(newzone, "Sqlite_Heap");
15349: do{
15350: success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone,
15351: (void * volatile *)&_sqliteZone_);
15352: }while(!_sqliteZone_);
15353: if( !success ){
15354: /* somebody registered a zone first */
15355: malloc_destroy_zone(newzone);
15356: }
15357: }
15358: #endif
15359: UNUSED_PARAMETER(NotUsed);
15360: return SQLITE_OK;
15361: }
15362:
15363: /*
15364: ** Deinitialize this module.
15365: */
15366: static void sqlite3MemShutdown(void *NotUsed){
15367: UNUSED_PARAMETER(NotUsed);
15368: return;
15369: }
15370:
15371: /*
15372: ** This routine is the only routine in this file with external linkage.
15373: **
15374: ** Populate the low-level memory allocation function pointers in
15375: ** sqlite3GlobalConfig.m with pointers to the routines in this file.
15376: */
15377: SQLITE_PRIVATE void sqlite3MemSetDefault(void){
15378: static const sqlite3_mem_methods defaultMethods = {
15379: sqlite3MemMalloc,
15380: sqlite3MemFree,
15381: sqlite3MemRealloc,
15382: sqlite3MemSize,
15383: sqlite3MemRoundup,
15384: sqlite3MemInit,
15385: sqlite3MemShutdown,
15386: 0
15387: };
15388: sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
15389: }
15390:
15391: #endif /* SQLITE_SYSTEM_MALLOC */
15392:
15393: /************** End of mem1.c ************************************************/
15394: /************** Begin file mem2.c ********************************************/
15395: /*
15396: ** 2007 August 15
15397: **
15398: ** The author disclaims copyright to this source code. In place of
15399: ** a legal notice, here is a blessing:
15400: **
15401: ** May you do good and not evil.
15402: ** May you find forgiveness for yourself and forgive others.
15403: ** May you share freely, never taking more than you give.
15404: **
15405: *************************************************************************
15406: **
15407: ** This file contains low-level memory allocation drivers for when
15408: ** SQLite will use the standard C-library malloc/realloc/free interface
15409: ** to obtain the memory it needs while adding lots of additional debugging
15410: ** information to each allocation in order to help detect and fix memory
15411: ** leaks and memory usage errors.
15412: **
15413: ** This file contains implementations of the low-level memory allocation
15414: ** routines specified in the sqlite3_mem_methods object.
15415: */
15416:
15417: /*
15418: ** This version of the memory allocator is used only if the
15419: ** SQLITE_MEMDEBUG macro is defined
15420: */
15421: #ifdef SQLITE_MEMDEBUG
15422:
15423: /*
15424: ** The backtrace functionality is only available with GLIBC
15425: */
15426: #ifdef __GLIBC__
15427: extern int backtrace(void**,int);
15428: extern void backtrace_symbols_fd(void*const*,int,int);
15429: #else
15430: # define backtrace(A,B) 1
15431: # define backtrace_symbols_fd(A,B,C)
15432: #endif
15433: /* #include <stdio.h> */
15434:
15435: /*
15436: ** Each memory allocation looks like this:
15437: **
15438: ** ------------------------------------------------------------------------
15439: ** | Title | backtrace pointers | MemBlockHdr | allocation | EndGuard |
15440: ** ------------------------------------------------------------------------
15441: **
15442: ** The application code sees only a pointer to the allocation. We have
15443: ** to back up from the allocation pointer to find the MemBlockHdr. The
15444: ** MemBlockHdr tells us the size of the allocation and the number of
15445: ** backtrace pointers. There is also a guard word at the end of the
15446: ** MemBlockHdr.
15447: */
15448: struct MemBlockHdr {
15449: i64 iSize; /* Size of this allocation */
15450: struct MemBlockHdr *pNext, *pPrev; /* Linked list of all unfreed memory */
15451: char nBacktrace; /* Number of backtraces on this alloc */
15452: char nBacktraceSlots; /* Available backtrace slots */
15453: u8 nTitle; /* Bytes of title; includes '\0' */
15454: u8 eType; /* Allocation type code */
15455: int iForeGuard; /* Guard word for sanity */
15456: };
15457:
15458: /*
15459: ** Guard words
15460: */
15461: #define FOREGUARD 0x80F5E153
15462: #define REARGUARD 0xE4676B53
15463:
15464: /*
15465: ** Number of malloc size increments to track.
15466: */
15467: #define NCSIZE 1000
15468:
15469: /*
15470: ** All of the static variables used by this module are collected
15471: ** into a single structure named "mem". This is to keep the
15472: ** static variables organized and to reduce namespace pollution
15473: ** when this module is combined with other in the amalgamation.
15474: */
15475: static struct {
15476:
15477: /*
15478: ** Mutex to control access to the memory allocation subsystem.
15479: */
15480: sqlite3_mutex *mutex;
15481:
15482: /*
15483: ** Head and tail of a linked list of all outstanding allocations
15484: */
15485: struct MemBlockHdr *pFirst;
15486: struct MemBlockHdr *pLast;
15487:
15488: /*
15489: ** The number of levels of backtrace to save in new allocations.
15490: */
15491: int nBacktrace;
15492: void (*xBacktrace)(int, int, void **);
15493:
15494: /*
15495: ** Title text to insert in front of each block
15496: */
15497: int nTitle; /* Bytes of zTitle to save. Includes '\0' and padding */
15498: char zTitle[100]; /* The title text */
15499:
15500: /*
15501: ** sqlite3MallocDisallow() increments the following counter.
15502: ** sqlite3MallocAllow() decrements it.
15503: */
15504: int disallow; /* Do not allow memory allocation */
15505:
15506: /*
15507: ** Gather statistics on the sizes of memory allocations.
15508: ** nAlloc[i] is the number of allocation attempts of i*8
15509: ** bytes. i==NCSIZE is the number of allocation attempts for
15510: ** sizes more than NCSIZE*8 bytes.
15511: */
15512: int nAlloc[NCSIZE]; /* Total number of allocations */
15513: int nCurrent[NCSIZE]; /* Current number of allocations */
15514: int mxCurrent[NCSIZE]; /* Highwater mark for nCurrent */
15515:
15516: } mem;
15517:
15518:
15519: /*
15520: ** Adjust memory usage statistics
15521: */
15522: static void adjustStats(int iSize, int increment){
15523: int i = ROUND8(iSize)/8;
15524: if( i>NCSIZE-1 ){
15525: i = NCSIZE - 1;
15526: }
15527: if( increment>0 ){
15528: mem.nAlloc[i]++;
15529: mem.nCurrent[i]++;
15530: if( mem.nCurrent[i]>mem.mxCurrent[i] ){
15531: mem.mxCurrent[i] = mem.nCurrent[i];
15532: }
15533: }else{
15534: mem.nCurrent[i]--;
15535: assert( mem.nCurrent[i]>=0 );
15536: }
15537: }
15538:
15539: /*
15540: ** Given an allocation, find the MemBlockHdr for that allocation.
15541: **
15542: ** This routine checks the guards at either end of the allocation and
15543: ** if they are incorrect it asserts.
15544: */
15545: static struct MemBlockHdr *sqlite3MemsysGetHeader(void *pAllocation){
15546: struct MemBlockHdr *p;
15547: int *pInt;
15548: u8 *pU8;
15549: int nReserve;
15550:
15551: p = (struct MemBlockHdr*)pAllocation;
15552: p--;
15553: assert( p->iForeGuard==(int)FOREGUARD );
15554: nReserve = ROUND8(p->iSize);
15555: pInt = (int*)pAllocation;
15556: pU8 = (u8*)pAllocation;
15557: assert( pInt[nReserve/sizeof(int)]==(int)REARGUARD );
15558: /* This checks any of the "extra" bytes allocated due
15559: ** to rounding up to an 8 byte boundary to ensure
15560: ** they haven't been overwritten.
15561: */
15562: while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 );
15563: return p;
15564: }
15565:
15566: /*
15567: ** Return the number of bytes currently allocated at address p.
15568: */
15569: static int sqlite3MemSize(void *p){
15570: struct MemBlockHdr *pHdr;
15571: if( !p ){
15572: return 0;
15573: }
15574: pHdr = sqlite3MemsysGetHeader(p);
15575: return pHdr->iSize;
15576: }
15577:
15578: /*
15579: ** Initialize the memory allocation subsystem.
15580: */
15581: static int sqlite3MemInit(void *NotUsed){
15582: UNUSED_PARAMETER(NotUsed);
15583: assert( (sizeof(struct MemBlockHdr)&7) == 0 );
15584: if( !sqlite3GlobalConfig.bMemstat ){
15585: /* If memory status is enabled, then the malloc.c wrapper will already
15586: ** hold the STATIC_MEM mutex when the routines here are invoked. */
15587: mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
15588: }
15589: return SQLITE_OK;
15590: }
15591:
15592: /*
15593: ** Deinitialize the memory allocation subsystem.
15594: */
15595: static void sqlite3MemShutdown(void *NotUsed){
15596: UNUSED_PARAMETER(NotUsed);
15597: mem.mutex = 0;
15598: }
15599:
15600: /*
15601: ** Round up a request size to the next valid allocation size.
15602: */
15603: static int sqlite3MemRoundup(int n){
15604: return ROUND8(n);
15605: }
15606:
15607: /*
15608: ** Fill a buffer with pseudo-random bytes. This is used to preset
15609: ** the content of a new memory allocation to unpredictable values and
15610: ** to clear the content of a freed allocation to unpredictable values.
15611: */
15612: static void randomFill(char *pBuf, int nByte){
15613: unsigned int x, y, r;
15614: x = SQLITE_PTR_TO_INT(pBuf);
15615: y = nByte | 1;
15616: while( nByte >= 4 ){
15617: x = (x>>1) ^ (-(x&1) & 0xd0000001);
15618: y = y*1103515245 + 12345;
15619: r = x ^ y;
15620: *(int*)pBuf = r;
15621: pBuf += 4;
15622: nByte -= 4;
15623: }
15624: while( nByte-- > 0 ){
15625: x = (x>>1) ^ (-(x&1) & 0xd0000001);
15626: y = y*1103515245 + 12345;
15627: r = x ^ y;
15628: *(pBuf++) = r & 0xff;
15629: }
15630: }
15631:
15632: /*
15633: ** Allocate nByte bytes of memory.
15634: */
15635: static void *sqlite3MemMalloc(int nByte){
15636: struct MemBlockHdr *pHdr;
15637: void **pBt;
15638: char *z;
15639: int *pInt;
15640: void *p = 0;
15641: int totalSize;
15642: int nReserve;
15643: sqlite3_mutex_enter(mem.mutex);
15644: assert( mem.disallow==0 );
15645: nReserve = ROUND8(nByte);
15646: totalSize = nReserve + sizeof(*pHdr) + sizeof(int) +
15647: mem.nBacktrace*sizeof(void*) + mem.nTitle;
15648: p = malloc(totalSize);
15649: if( p ){
15650: z = p;
15651: pBt = (void**)&z[mem.nTitle];
15652: pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
15653: pHdr->pNext = 0;
15654: pHdr->pPrev = mem.pLast;
15655: if( mem.pLast ){
15656: mem.pLast->pNext = pHdr;
15657: }else{
15658: mem.pFirst = pHdr;
15659: }
15660: mem.pLast = pHdr;
15661: pHdr->iForeGuard = FOREGUARD;
15662: pHdr->eType = MEMTYPE_HEAP;
15663: pHdr->nBacktraceSlots = mem.nBacktrace;
15664: pHdr->nTitle = mem.nTitle;
15665: if( mem.nBacktrace ){
15666: void *aAddr[40];
15667: pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1;
15668: memcpy(pBt, &aAddr[1], pHdr->nBacktrace*sizeof(void*));
15669: assert(pBt[0]);
15670: if( mem.xBacktrace ){
15671: mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]);
15672: }
15673: }else{
15674: pHdr->nBacktrace = 0;
15675: }
15676: if( mem.nTitle ){
15677: memcpy(z, mem.zTitle, mem.nTitle);
15678: }
15679: pHdr->iSize = nByte;
15680: adjustStats(nByte, +1);
15681: pInt = (int*)&pHdr[1];
15682: pInt[nReserve/sizeof(int)] = REARGUARD;
15683: randomFill((char*)pInt, nByte);
15684: memset(((char*)pInt)+nByte, 0x65, nReserve-nByte);
15685: p = (void*)pInt;
15686: }
15687: sqlite3_mutex_leave(mem.mutex);
15688: return p;
15689: }
15690:
15691: /*
15692: ** Free memory.
15693: */
15694: static void sqlite3MemFree(void *pPrior){
15695: struct MemBlockHdr *pHdr;
15696: void **pBt;
15697: char *z;
15698: assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0
15699: || mem.mutex!=0 );
15700: pHdr = sqlite3MemsysGetHeader(pPrior);
15701: pBt = (void**)pHdr;
15702: pBt -= pHdr->nBacktraceSlots;
15703: sqlite3_mutex_enter(mem.mutex);
15704: if( pHdr->pPrev ){
15705: assert( pHdr->pPrev->pNext==pHdr );
15706: pHdr->pPrev->pNext = pHdr->pNext;
15707: }else{
15708: assert( mem.pFirst==pHdr );
15709: mem.pFirst = pHdr->pNext;
15710: }
15711: if( pHdr->pNext ){
15712: assert( pHdr->pNext->pPrev==pHdr );
15713: pHdr->pNext->pPrev = pHdr->pPrev;
15714: }else{
15715: assert( mem.pLast==pHdr );
15716: mem.pLast = pHdr->pPrev;
15717: }
15718: z = (char*)pBt;
15719: z -= pHdr->nTitle;
15720: adjustStats(pHdr->iSize, -1);
15721: randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) +
15722: pHdr->iSize + sizeof(int) + pHdr->nTitle);
15723: free(z);
15724: sqlite3_mutex_leave(mem.mutex);
15725: }
15726:
15727: /*
15728: ** Change the size of an existing memory allocation.
15729: **
15730: ** For this debugging implementation, we *always* make a copy of the
15731: ** allocation into a new place in memory. In this way, if the
15732: ** higher level code is using pointer to the old allocation, it is
15733: ** much more likely to break and we are much more liking to find
15734: ** the error.
15735: */
15736: static void *sqlite3MemRealloc(void *pPrior, int nByte){
15737: struct MemBlockHdr *pOldHdr;
15738: void *pNew;
15739: assert( mem.disallow==0 );
15740: assert( (nByte & 7)==0 ); /* EV: R-46199-30249 */
15741: pOldHdr = sqlite3MemsysGetHeader(pPrior);
15742: pNew = sqlite3MemMalloc(nByte);
15743: if( pNew ){
15744: memcpy(pNew, pPrior, nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize);
15745: if( nByte>pOldHdr->iSize ){
15746: randomFill(&((char*)pNew)[pOldHdr->iSize], nByte - pOldHdr->iSize);
15747: }
15748: sqlite3MemFree(pPrior);
15749: }
15750: return pNew;
15751: }
15752:
15753: /*
15754: ** Populate the low-level memory allocation function pointers in
15755: ** sqlite3GlobalConfig.m with pointers to the routines in this file.
15756: */
15757: SQLITE_PRIVATE void sqlite3MemSetDefault(void){
15758: static const sqlite3_mem_methods defaultMethods = {
15759: sqlite3MemMalloc,
15760: sqlite3MemFree,
15761: sqlite3MemRealloc,
15762: sqlite3MemSize,
15763: sqlite3MemRoundup,
15764: sqlite3MemInit,
15765: sqlite3MemShutdown,
15766: 0
15767: };
15768: sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
15769: }
15770:
15771: /*
15772: ** Set the "type" of an allocation.
15773: */
15774: SQLITE_PRIVATE void sqlite3MemdebugSetType(void *p, u8 eType){
15775: if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
15776: struct MemBlockHdr *pHdr;
15777: pHdr = sqlite3MemsysGetHeader(p);
15778: assert( pHdr->iForeGuard==FOREGUARD );
15779: pHdr->eType = eType;
15780: }
15781: }
15782:
15783: /*
15784: ** Return TRUE if the mask of type in eType matches the type of the
15785: ** allocation p. Also return true if p==NULL.
15786: **
15787: ** This routine is designed for use within an assert() statement, to
15788: ** verify the type of an allocation. For example:
15789: **
15790: ** assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
15791: */
15792: SQLITE_PRIVATE int sqlite3MemdebugHasType(void *p, u8 eType){
15793: int rc = 1;
15794: if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
15795: struct MemBlockHdr *pHdr;
15796: pHdr = sqlite3MemsysGetHeader(p);
15797: assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
15798: if( (pHdr->eType&eType)==0 ){
15799: rc = 0;
15800: }
15801: }
15802: return rc;
15803: }
15804:
15805: /*
15806: ** Return TRUE if the mask of type in eType matches no bits of the type of the
15807: ** allocation p. Also return true if p==NULL.
15808: **
15809: ** This routine is designed for use within an assert() statement, to
15810: ** verify the type of an allocation. For example:
15811: **
15812: ** assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
15813: */
15814: SQLITE_PRIVATE int sqlite3MemdebugNoType(void *p, u8 eType){
15815: int rc = 1;
15816: if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
15817: struct MemBlockHdr *pHdr;
15818: pHdr = sqlite3MemsysGetHeader(p);
15819: assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
15820: if( (pHdr->eType&eType)!=0 ){
15821: rc = 0;
15822: }
15823: }
15824: return rc;
15825: }
15826:
15827: /*
15828: ** Set the number of backtrace levels kept for each allocation.
15829: ** A value of zero turns off backtracing. The number is always rounded
15830: ** up to a multiple of 2.
15831: */
15832: SQLITE_PRIVATE void sqlite3MemdebugBacktrace(int depth){
15833: if( depth<0 ){ depth = 0; }
15834: if( depth>20 ){ depth = 20; }
15835: depth = (depth+1)&0xfe;
15836: mem.nBacktrace = depth;
15837: }
15838:
15839: SQLITE_PRIVATE void sqlite3MemdebugBacktraceCallback(void (*xBacktrace)(int, int, void **)){
15840: mem.xBacktrace = xBacktrace;
15841: }
15842:
15843: /*
15844: ** Set the title string for subsequent allocations.
15845: */
15846: SQLITE_PRIVATE void sqlite3MemdebugSettitle(const char *zTitle){
15847: unsigned int n = sqlite3Strlen30(zTitle) + 1;
15848: sqlite3_mutex_enter(mem.mutex);
15849: if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1;
15850: memcpy(mem.zTitle, zTitle, n);
15851: mem.zTitle[n] = 0;
15852: mem.nTitle = ROUND8(n);
15853: sqlite3_mutex_leave(mem.mutex);
15854: }
15855:
15856: SQLITE_PRIVATE void sqlite3MemdebugSync(){
15857: struct MemBlockHdr *pHdr;
15858: for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
15859: void **pBt = (void**)pHdr;
15860: pBt -= pHdr->nBacktraceSlots;
15861: mem.xBacktrace(pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
15862: }
15863: }
15864:
15865: /*
15866: ** Open the file indicated and write a log of all unfreed memory
15867: ** allocations into that log.
15868: */
15869: SQLITE_PRIVATE void sqlite3MemdebugDump(const char *zFilename){
15870: FILE *out;
15871: struct MemBlockHdr *pHdr;
15872: void **pBt;
15873: int i;
15874: out = fopen(zFilename, "w");
15875: if( out==0 ){
15876: fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
15877: zFilename);
15878: return;
15879: }
15880: for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
15881: char *z = (char*)pHdr;
15882: z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle;
15883: fprintf(out, "**** %lld bytes at %p from %s ****\n",
15884: pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???");
15885: if( pHdr->nBacktrace ){
15886: fflush(out);
15887: pBt = (void**)pHdr;
15888: pBt -= pHdr->nBacktraceSlots;
15889: backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
15890: fprintf(out, "\n");
15891: }
15892: }
15893: fprintf(out, "COUNTS:\n");
15894: for(i=0; i<NCSIZE-1; i++){
15895: if( mem.nAlloc[i] ){
15896: fprintf(out, " %5d: %10d %10d %10d\n",
15897: i*8, mem.nAlloc[i], mem.nCurrent[i], mem.mxCurrent[i]);
15898: }
15899: }
15900: if( mem.nAlloc[NCSIZE-1] ){
15901: fprintf(out, " %5d: %10d %10d %10d\n",
15902: NCSIZE*8-8, mem.nAlloc[NCSIZE-1],
15903: mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]);
15904: }
15905: fclose(out);
15906: }
15907:
15908: /*
15909: ** Return the number of times sqlite3MemMalloc() has been called.
15910: */
15911: SQLITE_PRIVATE int sqlite3MemdebugMallocCount(){
15912: int i;
15913: int nTotal = 0;
15914: for(i=0; i<NCSIZE; i++){
15915: nTotal += mem.nAlloc[i];
15916: }
15917: return nTotal;
15918: }
15919:
15920:
15921: #endif /* SQLITE_MEMDEBUG */
15922:
15923: /************** End of mem2.c ************************************************/
15924: /************** Begin file mem3.c ********************************************/
15925: /*
15926: ** 2007 October 14
15927: **
15928: ** The author disclaims copyright to this source code. In place of
15929: ** a legal notice, here is a blessing:
15930: **
15931: ** May you do good and not evil.
15932: ** May you find forgiveness for yourself and forgive others.
15933: ** May you share freely, never taking more than you give.
15934: **
15935: *************************************************************************
15936: ** This file contains the C functions that implement a memory
15937: ** allocation subsystem for use by SQLite.
15938: **
15939: ** This version of the memory allocation subsystem omits all
15940: ** use of malloc(). The SQLite user supplies a block of memory
15941: ** before calling sqlite3_initialize() from which allocations
15942: ** are made and returned by the xMalloc() and xRealloc()
15943: ** implementations. Once sqlite3_initialize() has been called,
15944: ** the amount of memory available to SQLite is fixed and cannot
15945: ** be changed.
15946: **
15947: ** This version of the memory allocation subsystem is included
15948: ** in the build only if SQLITE_ENABLE_MEMSYS3 is defined.
15949: */
15950:
15951: /*
15952: ** This version of the memory allocator is only built into the library
15953: ** SQLITE_ENABLE_MEMSYS3 is defined. Defining this symbol does not
15954: ** mean that the library will use a memory-pool by default, just that
15955: ** it is available. The mempool allocator is activated by calling
15956: ** sqlite3_config().
15957: */
15958: #ifdef SQLITE_ENABLE_MEMSYS3
15959:
15960: /*
15961: ** Maximum size (in Mem3Blocks) of a "small" chunk.
15962: */
15963: #define MX_SMALL 10
15964:
15965:
15966: /*
15967: ** Number of freelist hash slots
15968: */
15969: #define N_HASH 61
15970:
15971: /*
15972: ** A memory allocation (also called a "chunk") consists of two or
15973: ** more blocks where each block is 8 bytes. The first 8 bytes are
15974: ** a header that is not returned to the user.
15975: **
15976: ** A chunk is two or more blocks that is either checked out or
15977: ** free. The first block has format u.hdr. u.hdr.size4x is 4 times the
15978: ** size of the allocation in blocks if the allocation is free.
15979: ** The u.hdr.size4x&1 bit is true if the chunk is checked out and
15980: ** false if the chunk is on the freelist. The u.hdr.size4x&2 bit
15981: ** is true if the previous chunk is checked out and false if the
15982: ** previous chunk is free. The u.hdr.prevSize field is the size of
15983: ** the previous chunk in blocks if the previous chunk is on the
15984: ** freelist. If the previous chunk is checked out, then
15985: ** u.hdr.prevSize can be part of the data for that chunk and should
15986: ** not be read or written.
15987: **
15988: ** We often identify a chunk by its index in mem3.aPool[]. When
15989: ** this is done, the chunk index refers to the second block of
15990: ** the chunk. In this way, the first chunk has an index of 1.
15991: ** A chunk index of 0 means "no such chunk" and is the equivalent
15992: ** of a NULL pointer.
15993: **
15994: ** The second block of free chunks is of the form u.list. The
15995: ** two fields form a double-linked list of chunks of related sizes.
15996: ** Pointers to the head of the list are stored in mem3.aiSmall[]
15997: ** for smaller chunks and mem3.aiHash[] for larger chunks.
15998: **
15999: ** The second block of a chunk is user data if the chunk is checked
16000: ** out. If a chunk is checked out, the user data may extend into
16001: ** the u.hdr.prevSize value of the following chunk.
16002: */
16003: typedef struct Mem3Block Mem3Block;
16004: struct Mem3Block {
16005: union {
16006: struct {
16007: u32 prevSize; /* Size of previous chunk in Mem3Block elements */
16008: u32 size4x; /* 4x the size of current chunk in Mem3Block elements */
16009: } hdr;
16010: struct {
16011: u32 next; /* Index in mem3.aPool[] of next free chunk */
16012: u32 prev; /* Index in mem3.aPool[] of previous free chunk */
16013: } list;
16014: } u;
16015: };
16016:
16017: /*
16018: ** All of the static variables used by this module are collected
16019: ** into a single structure named "mem3". This is to keep the
16020: ** static variables organized and to reduce namespace pollution
16021: ** when this module is combined with other in the amalgamation.
16022: */
16023: static SQLITE_WSD struct Mem3Global {
16024: /*
16025: ** Memory available for allocation. nPool is the size of the array
16026: ** (in Mem3Blocks) pointed to by aPool less 2.
16027: */
16028: u32 nPool;
16029: Mem3Block *aPool;
16030:
16031: /*
16032: ** True if we are evaluating an out-of-memory callback.
16033: */
16034: int alarmBusy;
16035:
16036: /*
16037: ** Mutex to control access to the memory allocation subsystem.
16038: */
16039: sqlite3_mutex *mutex;
16040:
16041: /*
16042: ** The minimum amount of free space that we have seen.
16043: */
16044: u32 mnMaster;
16045:
16046: /*
16047: ** iMaster is the index of the master chunk. Most new allocations
16048: ** occur off of this chunk. szMaster is the size (in Mem3Blocks)
16049: ** of the current master. iMaster is 0 if there is not master chunk.
16050: ** The master chunk is not in either the aiHash[] or aiSmall[].
16051: */
16052: u32 iMaster;
16053: u32 szMaster;
16054:
16055: /*
16056: ** Array of lists of free blocks according to the block size
16057: ** for smaller chunks, or a hash on the block size for larger
16058: ** chunks.
16059: */
16060: u32 aiSmall[MX_SMALL-1]; /* For sizes 2 through MX_SMALL, inclusive */
16061: u32 aiHash[N_HASH]; /* For sizes MX_SMALL+1 and larger */
16062: } mem3 = { 97535575 };
16063:
16064: #define mem3 GLOBAL(struct Mem3Global, mem3)
16065:
16066: /*
16067: ** Unlink the chunk at mem3.aPool[i] from list it is currently
16068: ** on. *pRoot is the list that i is a member of.
16069: */
16070: static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
16071: u32 next = mem3.aPool[i].u.list.next;
16072: u32 prev = mem3.aPool[i].u.list.prev;
16073: assert( sqlite3_mutex_held(mem3.mutex) );
16074: if( prev==0 ){
16075: *pRoot = next;
16076: }else{
16077: mem3.aPool[prev].u.list.next = next;
16078: }
16079: if( next ){
16080: mem3.aPool[next].u.list.prev = prev;
16081: }
16082: mem3.aPool[i].u.list.next = 0;
16083: mem3.aPool[i].u.list.prev = 0;
16084: }
16085:
16086: /*
16087: ** Unlink the chunk at index i from
16088: ** whatever list is currently a member of.
16089: */
16090: static void memsys3Unlink(u32 i){
16091: u32 size, hash;
16092: assert( sqlite3_mutex_held(mem3.mutex) );
16093: assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
16094: assert( i>=1 );
16095: size = mem3.aPool[i-1].u.hdr.size4x/4;
16096: assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
16097: assert( size>=2 );
16098: if( size <= MX_SMALL ){
16099: memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]);
16100: }else{
16101: hash = size % N_HASH;
16102: memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
16103: }
16104: }
16105:
16106: /*
16107: ** Link the chunk at mem3.aPool[i] so that is on the list rooted
16108: ** at *pRoot.
16109: */
16110: static void memsys3LinkIntoList(u32 i, u32 *pRoot){
16111: assert( sqlite3_mutex_held(mem3.mutex) );
16112: mem3.aPool[i].u.list.next = *pRoot;
16113: mem3.aPool[i].u.list.prev = 0;
16114: if( *pRoot ){
16115: mem3.aPool[*pRoot].u.list.prev = i;
16116: }
16117: *pRoot = i;
16118: }
16119:
16120: /*
16121: ** Link the chunk at index i into either the appropriate
16122: ** small chunk list, or into the large chunk hash table.
16123: */
16124: static void memsys3Link(u32 i){
16125: u32 size, hash;
16126: assert( sqlite3_mutex_held(mem3.mutex) );
16127: assert( i>=1 );
16128: assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
16129: size = mem3.aPool[i-1].u.hdr.size4x/4;
16130: assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
16131: assert( size>=2 );
16132: if( size <= MX_SMALL ){
16133: memsys3LinkIntoList(i, &mem3.aiSmall[size-2]);
16134: }else{
16135: hash = size % N_HASH;
16136: memsys3LinkIntoList(i, &mem3.aiHash[hash]);
16137: }
16138: }
16139:
16140: /*
16141: ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
16142: ** will already be held (obtained by code in malloc.c) if
16143: ** sqlite3GlobalConfig.bMemStat is true.
16144: */
16145: static void memsys3Enter(void){
16146: if( sqlite3GlobalConfig.bMemstat==0 && mem3.mutex==0 ){
16147: mem3.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
16148: }
16149: sqlite3_mutex_enter(mem3.mutex);
16150: }
16151: static void memsys3Leave(void){
16152: sqlite3_mutex_leave(mem3.mutex);
16153: }
16154:
16155: /*
16156: ** Called when we are unable to satisfy an allocation of nBytes.
16157: */
16158: static void memsys3OutOfMemory(int nByte){
16159: if( !mem3.alarmBusy ){
16160: mem3.alarmBusy = 1;
16161: assert( sqlite3_mutex_held(mem3.mutex) );
16162: sqlite3_mutex_leave(mem3.mutex);
16163: sqlite3_release_memory(nByte);
16164: sqlite3_mutex_enter(mem3.mutex);
16165: mem3.alarmBusy = 0;
16166: }
16167: }
16168:
16169:
16170: /*
16171: ** Chunk i is a free chunk that has been unlinked. Adjust its
16172: ** size parameters for check-out and return a pointer to the
16173: ** user portion of the chunk.
16174: */
16175: static void *memsys3Checkout(u32 i, u32 nBlock){
16176: u32 x;
16177: assert( sqlite3_mutex_held(mem3.mutex) );
16178: assert( i>=1 );
16179: assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock );
16180: assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
16181: x = mem3.aPool[i-1].u.hdr.size4x;
16182: mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
16183: mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
16184: mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2;
16185: return &mem3.aPool[i];
16186: }
16187:
16188: /*
16189: ** Carve a piece off of the end of the mem3.iMaster free chunk.
16190: ** Return a pointer to the new allocation. Or, if the master chunk
16191: ** is not large enough, return 0.
16192: */
16193: static void *memsys3FromMaster(u32 nBlock){
16194: assert( sqlite3_mutex_held(mem3.mutex) );
16195: assert( mem3.szMaster>=nBlock );
16196: if( nBlock>=mem3.szMaster-1 ){
16197: /* Use the entire master */
16198: void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster);
16199: mem3.iMaster = 0;
16200: mem3.szMaster = 0;
16201: mem3.mnMaster = 0;
16202: return p;
16203: }else{
16204: /* Split the master block. Return the tail. */
16205: u32 newi, x;
16206: newi = mem3.iMaster + mem3.szMaster - nBlock;
16207: assert( newi > mem3.iMaster+1 );
16208: mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = nBlock;
16209: mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x |= 2;
16210: mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
16211: mem3.szMaster -= nBlock;
16212: mem3.aPool[newi-1].u.hdr.prevSize = mem3.szMaster;
16213: x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
16214: mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
16215: if( mem3.szMaster < mem3.mnMaster ){
16216: mem3.mnMaster = mem3.szMaster;
16217: }
16218: return (void*)&mem3.aPool[newi];
16219: }
16220: }
16221:
16222: /*
16223: ** *pRoot is the head of a list of free chunks of the same size
16224: ** or same size hash. In other words, *pRoot is an entry in either
16225: ** mem3.aiSmall[] or mem3.aiHash[].
16226: **
16227: ** This routine examines all entries on the given list and tries
16228: ** to coalesce each entries with adjacent free chunks.
16229: **
16230: ** If it sees a chunk that is larger than mem3.iMaster, it replaces
16231: ** the current mem3.iMaster with the new larger chunk. In order for
16232: ** this mem3.iMaster replacement to work, the master chunk must be
16233: ** linked into the hash tables. That is not the normal state of
16234: ** affairs, of course. The calling routine must link the master
16235: ** chunk before invoking this routine, then must unlink the (possibly
16236: ** changed) master chunk once this routine has finished.
16237: */
16238: static void memsys3Merge(u32 *pRoot){
16239: u32 iNext, prev, size, i, x;
16240:
16241: assert( sqlite3_mutex_held(mem3.mutex) );
16242: for(i=*pRoot; i>0; i=iNext){
16243: iNext = mem3.aPool[i].u.list.next;
16244: size = mem3.aPool[i-1].u.hdr.size4x;
16245: assert( (size&1)==0 );
16246: if( (size&2)==0 ){
16247: memsys3UnlinkFromList(i, pRoot);
16248: assert( i > mem3.aPool[i-1].u.hdr.prevSize );
16249: prev = i - mem3.aPool[i-1].u.hdr.prevSize;
16250: if( prev==iNext ){
16251: iNext = mem3.aPool[prev].u.list.next;
16252: }
16253: memsys3Unlink(prev);
16254: size = i + size/4 - prev;
16255: x = mem3.aPool[prev-1].u.hdr.size4x & 2;
16256: mem3.aPool[prev-1].u.hdr.size4x = size*4 | x;
16257: mem3.aPool[prev+size-1].u.hdr.prevSize = size;
16258: memsys3Link(prev);
16259: i = prev;
16260: }else{
16261: size /= 4;
16262: }
16263: if( size>mem3.szMaster ){
16264: mem3.iMaster = i;
16265: mem3.szMaster = size;
16266: }
16267: }
16268: }
16269:
16270: /*
16271: ** Return a block of memory of at least nBytes in size.
16272: ** Return NULL if unable.
16273: **
16274: ** This function assumes that the necessary mutexes, if any, are
16275: ** already held by the caller. Hence "Unsafe".
16276: */
16277: static void *memsys3MallocUnsafe(int nByte){
16278: u32 i;
16279: u32 nBlock;
16280: u32 toFree;
16281:
16282: assert( sqlite3_mutex_held(mem3.mutex) );
16283: assert( sizeof(Mem3Block)==8 );
16284: if( nByte<=12 ){
16285: nBlock = 2;
16286: }else{
16287: nBlock = (nByte + 11)/8;
16288: }
16289: assert( nBlock>=2 );
16290:
16291: /* STEP 1:
16292: ** Look for an entry of the correct size in either the small
16293: ** chunk table or in the large chunk hash table. This is
16294: ** successful most of the time (about 9 times out of 10).
16295: */
16296: if( nBlock <= MX_SMALL ){
16297: i = mem3.aiSmall[nBlock-2];
16298: if( i>0 ){
16299: memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock-2]);
16300: return memsys3Checkout(i, nBlock);
16301: }
16302: }else{
16303: int hash = nBlock % N_HASH;
16304: for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){
16305: if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){
16306: memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
16307: return memsys3Checkout(i, nBlock);
16308: }
16309: }
16310: }
16311:
16312: /* STEP 2:
16313: ** Try to satisfy the allocation by carving a piece off of the end
16314: ** of the master chunk. This step usually works if step 1 fails.
16315: */
16316: if( mem3.szMaster>=nBlock ){
16317: return memsys3FromMaster(nBlock);
16318: }
16319:
16320:
16321: /* STEP 3:
16322: ** Loop through the entire memory pool. Coalesce adjacent free
16323: ** chunks. Recompute the master chunk as the largest free chunk.
16324: ** Then try again to satisfy the allocation by carving a piece off
16325: ** of the end of the master chunk. This step happens very
16326: ** rarely (we hope!)
16327: */
16328: for(toFree=nBlock*16; toFree<(mem3.nPool*16); toFree *= 2){
16329: memsys3OutOfMemory(toFree);
16330: if( mem3.iMaster ){
16331: memsys3Link(mem3.iMaster);
16332: mem3.iMaster = 0;
16333: mem3.szMaster = 0;
16334: }
16335: for(i=0; i<N_HASH; i++){
16336: memsys3Merge(&mem3.aiHash[i]);
16337: }
16338: for(i=0; i<MX_SMALL-1; i++){
16339: memsys3Merge(&mem3.aiSmall[i]);
16340: }
16341: if( mem3.szMaster ){
16342: memsys3Unlink(mem3.iMaster);
16343: if( mem3.szMaster>=nBlock ){
16344: return memsys3FromMaster(nBlock);
16345: }
16346: }
16347: }
16348:
16349: /* If none of the above worked, then we fail. */
16350: return 0;
16351: }
16352:
16353: /*
16354: ** Free an outstanding memory allocation.
16355: **
16356: ** This function assumes that the necessary mutexes, if any, are
16357: ** already held by the caller. Hence "Unsafe".
16358: */
16359: static void memsys3FreeUnsafe(void *pOld){
16360: Mem3Block *p = (Mem3Block*)pOld;
16361: int i;
16362: u32 size, x;
16363: assert( sqlite3_mutex_held(mem3.mutex) );
16364: assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] );
16365: i = p - mem3.aPool;
16366: assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 );
16367: size = mem3.aPool[i-1].u.hdr.size4x/4;
16368: assert( i+size<=mem3.nPool+1 );
16369: mem3.aPool[i-1].u.hdr.size4x &= ~1;
16370: mem3.aPool[i+size-1].u.hdr.prevSize = size;
16371: mem3.aPool[i+size-1].u.hdr.size4x &= ~2;
16372: memsys3Link(i);
16373:
16374: /* Try to expand the master using the newly freed chunk */
16375: if( mem3.iMaster ){
16376: while( (mem3.aPool[mem3.iMaster-1].u.hdr.size4x&2)==0 ){
16377: size = mem3.aPool[mem3.iMaster-1].u.hdr.prevSize;
16378: mem3.iMaster -= size;
16379: mem3.szMaster += size;
16380: memsys3Unlink(mem3.iMaster);
16381: x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
16382: mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
16383: mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
16384: }
16385: x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
16386: while( (mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x&1)==0 ){
16387: memsys3Unlink(mem3.iMaster+mem3.szMaster);
16388: mem3.szMaster += mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x/4;
16389: mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
16390: mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
16391: }
16392: }
16393: }
16394:
16395: /*
16396: ** Return the size of an outstanding allocation, in bytes. The
16397: ** size returned omits the 8-byte header overhead. This only
16398: ** works for chunks that are currently checked out.
16399: */
16400: static int memsys3Size(void *p){
16401: Mem3Block *pBlock;
16402: if( p==0 ) return 0;
16403: pBlock = (Mem3Block*)p;
16404: assert( (pBlock[-1].u.hdr.size4x&1)!=0 );
16405: return (pBlock[-1].u.hdr.size4x&~3)*2 - 4;
16406: }
16407:
16408: /*
16409: ** Round up a request size to the next valid allocation size.
16410: */
16411: static int memsys3Roundup(int n){
16412: if( n<=12 ){
16413: return 12;
16414: }else{
16415: return ((n+11)&~7) - 4;
16416: }
16417: }
16418:
16419: /*
16420: ** Allocate nBytes of memory.
16421: */
16422: static void *memsys3Malloc(int nBytes){
16423: sqlite3_int64 *p;
16424: assert( nBytes>0 ); /* malloc.c filters out 0 byte requests */
16425: memsys3Enter();
16426: p = memsys3MallocUnsafe(nBytes);
16427: memsys3Leave();
16428: return (void*)p;
16429: }
16430:
16431: /*
16432: ** Free memory.
16433: */
16434: static void memsys3Free(void *pPrior){
16435: assert( pPrior );
16436: memsys3Enter();
16437: memsys3FreeUnsafe(pPrior);
16438: memsys3Leave();
16439: }
16440:
16441: /*
16442: ** Change the size of an existing memory allocation
16443: */
16444: static void *memsys3Realloc(void *pPrior, int nBytes){
16445: int nOld;
16446: void *p;
16447: if( pPrior==0 ){
16448: return sqlite3_malloc(nBytes);
16449: }
16450: if( nBytes<=0 ){
16451: sqlite3_free(pPrior);
16452: return 0;
16453: }
16454: nOld = memsys3Size(pPrior);
16455: if( nBytes<=nOld && nBytes>=nOld-128 ){
16456: return pPrior;
16457: }
16458: memsys3Enter();
16459: p = memsys3MallocUnsafe(nBytes);
16460: if( p ){
16461: if( nOld<nBytes ){
16462: memcpy(p, pPrior, nOld);
16463: }else{
16464: memcpy(p, pPrior, nBytes);
16465: }
16466: memsys3FreeUnsafe(pPrior);
16467: }
16468: memsys3Leave();
16469: return p;
16470: }
16471:
16472: /*
16473: ** Initialize this module.
16474: */
16475: static int memsys3Init(void *NotUsed){
16476: UNUSED_PARAMETER(NotUsed);
16477: if( !sqlite3GlobalConfig.pHeap ){
16478: return SQLITE_ERROR;
16479: }
16480:
16481: /* Store a pointer to the memory block in global structure mem3. */
16482: assert( sizeof(Mem3Block)==8 );
16483: mem3.aPool = (Mem3Block *)sqlite3GlobalConfig.pHeap;
16484: mem3.nPool = (sqlite3GlobalConfig.nHeap / sizeof(Mem3Block)) - 2;
16485:
16486: /* Initialize the master block. */
16487: mem3.szMaster = mem3.nPool;
16488: mem3.mnMaster = mem3.szMaster;
16489: mem3.iMaster = 1;
16490: mem3.aPool[0].u.hdr.size4x = (mem3.szMaster<<2) + 2;
16491: mem3.aPool[mem3.nPool].u.hdr.prevSize = mem3.nPool;
16492: mem3.aPool[mem3.nPool].u.hdr.size4x = 1;
16493:
16494: return SQLITE_OK;
16495: }
16496:
16497: /*
16498: ** Deinitialize this module.
16499: */
16500: static void memsys3Shutdown(void *NotUsed){
16501: UNUSED_PARAMETER(NotUsed);
16502: mem3.mutex = 0;
16503: return;
16504: }
16505:
16506:
16507:
16508: /*
16509: ** Open the file indicated and write a log of all unfreed memory
16510: ** allocations into that log.
16511: */
16512: SQLITE_PRIVATE void sqlite3Memsys3Dump(const char *zFilename){
16513: #ifdef SQLITE_DEBUG
16514: FILE *out;
16515: u32 i, j;
16516: u32 size;
16517: if( zFilename==0 || zFilename[0]==0 ){
16518: out = stdout;
16519: }else{
16520: out = fopen(zFilename, "w");
16521: if( out==0 ){
16522: fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
16523: zFilename);
16524: return;
16525: }
16526: }
16527: memsys3Enter();
16528: fprintf(out, "CHUNKS:\n");
16529: for(i=1; i<=mem3.nPool; i+=size/4){
16530: size = mem3.aPool[i-1].u.hdr.size4x;
16531: if( size/4<=1 ){
16532: fprintf(out, "%p size error\n", &mem3.aPool[i]);
16533: assert( 0 );
16534: break;
16535: }
16536: if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
16537: fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
16538: assert( 0 );
16539: break;
16540: }
16541: if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
16542: fprintf(out, "%p tail checkout bit is incorrect\n", &mem3.aPool[i]);
16543: assert( 0 );
16544: break;
16545: }
16546: if( size&1 ){
16547: fprintf(out, "%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8);
16548: }else{
16549: fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8,
16550: i==mem3.iMaster ? " **master**" : "");
16551: }
16552: }
16553: for(i=0; i<MX_SMALL-1; i++){
16554: if( mem3.aiSmall[i]==0 ) continue;
16555: fprintf(out, "small(%2d):", i);
16556: for(j = mem3.aiSmall[i]; j>0; j=mem3.aPool[j].u.list.next){
16557: fprintf(out, " %p(%d)", &mem3.aPool[j],
16558: (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
16559: }
16560: fprintf(out, "\n");
16561: }
16562: for(i=0; i<N_HASH; i++){
16563: if( mem3.aiHash[i]==0 ) continue;
16564: fprintf(out, "hash(%2d):", i);
16565: for(j = mem3.aiHash[i]; j>0; j=mem3.aPool[j].u.list.next){
16566: fprintf(out, " %p(%d)", &mem3.aPool[j],
16567: (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
16568: }
16569: fprintf(out, "\n");
16570: }
16571: fprintf(out, "master=%d\n", mem3.iMaster);
16572: fprintf(out, "nowUsed=%d\n", mem3.nPool*8 - mem3.szMaster*8);
16573: fprintf(out, "mxUsed=%d\n", mem3.nPool*8 - mem3.mnMaster*8);
16574: sqlite3_mutex_leave(mem3.mutex);
16575: if( out==stdout ){
16576: fflush(stdout);
16577: }else{
16578: fclose(out);
16579: }
16580: #else
16581: UNUSED_PARAMETER(zFilename);
16582: #endif
16583: }
16584:
16585: /*
16586: ** This routine is the only routine in this file with external
16587: ** linkage.
16588: **
16589: ** Populate the low-level memory allocation function pointers in
16590: ** sqlite3GlobalConfig.m with pointers to the routines in this file. The
16591: ** arguments specify the block of memory to manage.
16592: **
16593: ** This routine is only called by sqlite3_config(), and therefore
16594: ** is not required to be threadsafe (it is not).
16595: */
16596: SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys3(void){
16597: static const sqlite3_mem_methods mempoolMethods = {
16598: memsys3Malloc,
16599: memsys3Free,
16600: memsys3Realloc,
16601: memsys3Size,
16602: memsys3Roundup,
16603: memsys3Init,
16604: memsys3Shutdown,
16605: 0
16606: };
16607: return &mempoolMethods;
16608: }
16609:
16610: #endif /* SQLITE_ENABLE_MEMSYS3 */
16611:
16612: /************** End of mem3.c ************************************************/
16613: /************** Begin file mem5.c ********************************************/
16614: /*
16615: ** 2007 October 14
16616: **
16617: ** The author disclaims copyright to this source code. In place of
16618: ** a legal notice, here is a blessing:
16619: **
16620: ** May you do good and not evil.
16621: ** May you find forgiveness for yourself and forgive others.
16622: ** May you share freely, never taking more than you give.
16623: **
16624: *************************************************************************
16625: ** This file contains the C functions that implement a memory
16626: ** allocation subsystem for use by SQLite.
16627: **
16628: ** This version of the memory allocation subsystem omits all
16629: ** use of malloc(). The application gives SQLite a block of memory
16630: ** before calling sqlite3_initialize() from which allocations
16631: ** are made and returned by the xMalloc() and xRealloc()
16632: ** implementations. Once sqlite3_initialize() has been called,
16633: ** the amount of memory available to SQLite is fixed and cannot
16634: ** be changed.
16635: **
16636: ** This version of the memory allocation subsystem is included
16637: ** in the build only if SQLITE_ENABLE_MEMSYS5 is defined.
16638: **
16639: ** This memory allocator uses the following algorithm:
16640: **
16641: ** 1. All memory allocations sizes are rounded up to a power of 2.
16642: **
16643: ** 2. If two adjacent free blocks are the halves of a larger block,
16644: ** then the two blocks are coalesed into the single larger block.
16645: **
16646: ** 3. New memory is allocated from the first available free block.
16647: **
16648: ** This algorithm is described in: J. M. Robson. "Bounds for Some Functions
16649: ** Concerning Dynamic Storage Allocation". Journal of the Association for
16650: ** Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499.
16651: **
16652: ** Let n be the size of the largest allocation divided by the minimum
16653: ** allocation size (after rounding all sizes up to a power of 2.) Let M
16654: ** be the maximum amount of memory ever outstanding at one time. Let
16655: ** N be the total amount of memory available for allocation. Robson
16656: ** proved that this memory allocator will never breakdown due to
16657: ** fragmentation as long as the following constraint holds:
16658: **
16659: ** N >= M*(1 + log2(n)/2) - n + 1
16660: **
16661: ** The sqlite3_status() logic tracks the maximum values of n and M so
16662: ** that an application can, at any time, verify this constraint.
16663: */
16664:
16665: /*
16666: ** This version of the memory allocator is used only when
16667: ** SQLITE_ENABLE_MEMSYS5 is defined.
16668: */
16669: #ifdef SQLITE_ENABLE_MEMSYS5
16670:
16671: /*
16672: ** A minimum allocation is an instance of the following structure.
16673: ** Larger allocations are an array of these structures where the
16674: ** size of the array is a power of 2.
16675: **
16676: ** The size of this object must be a power of two. That fact is
16677: ** verified in memsys5Init().
16678: */
16679: typedef struct Mem5Link Mem5Link;
16680: struct Mem5Link {
16681: int next; /* Index of next free chunk */
16682: int prev; /* Index of previous free chunk */
16683: };
16684:
16685: /*
16686: ** Maximum size of any allocation is ((1<<LOGMAX)*mem5.szAtom). Since
16687: ** mem5.szAtom is always at least 8 and 32-bit integers are used,
16688: ** it is not actually possible to reach this limit.
16689: */
16690: #define LOGMAX 30
16691:
16692: /*
16693: ** Masks used for mem5.aCtrl[] elements.
16694: */
16695: #define CTRL_LOGSIZE 0x1f /* Log2 Size of this block */
16696: #define CTRL_FREE 0x20 /* True if not checked out */
16697:
16698: /*
16699: ** All of the static variables used by this module are collected
16700: ** into a single structure named "mem5". This is to keep the
16701: ** static variables organized and to reduce namespace pollution
16702: ** when this module is combined with other in the amalgamation.
16703: */
16704: static SQLITE_WSD struct Mem5Global {
16705: /*
16706: ** Memory available for allocation
16707: */
16708: int szAtom; /* Smallest possible allocation in bytes */
16709: int nBlock; /* Number of szAtom sized blocks in zPool */
16710: u8 *zPool; /* Memory available to be allocated */
16711:
16712: /*
16713: ** Mutex to control access to the memory allocation subsystem.
16714: */
16715: sqlite3_mutex *mutex;
16716:
16717: /*
16718: ** Performance statistics
16719: */
16720: u64 nAlloc; /* Total number of calls to malloc */
16721: u64 totalAlloc; /* Total of all malloc calls - includes internal frag */
16722: u64 totalExcess; /* Total internal fragmentation */
16723: u32 currentOut; /* Current checkout, including internal fragmentation */
16724: u32 currentCount; /* Current number of distinct checkouts */
16725: u32 maxOut; /* Maximum instantaneous currentOut */
16726: u32 maxCount; /* Maximum instantaneous currentCount */
16727: u32 maxRequest; /* Largest allocation (exclusive of internal frag) */
16728:
16729: /*
16730: ** Lists of free blocks. aiFreelist[0] is a list of free blocks of
16731: ** size mem5.szAtom. aiFreelist[1] holds blocks of size szAtom*2.
16732: ** and so forth.
16733: */
16734: int aiFreelist[LOGMAX+1];
16735:
16736: /*
16737: ** Space for tracking which blocks are checked out and the size
16738: ** of each block. One byte per block.
16739: */
16740: u8 *aCtrl;
16741:
16742: } mem5;
16743:
16744: /*
16745: ** Access the static variable through a macro for SQLITE_OMIT_WSD
16746: */
16747: #define mem5 GLOBAL(struct Mem5Global, mem5)
16748:
16749: /*
16750: ** Assuming mem5.zPool is divided up into an array of Mem5Link
16751: ** structures, return a pointer to the idx-th such lik.
16752: */
16753: #define MEM5LINK(idx) ((Mem5Link *)(&mem5.zPool[(idx)*mem5.szAtom]))
16754:
16755: /*
16756: ** Unlink the chunk at mem5.aPool[i] from list it is currently
16757: ** on. It should be found on mem5.aiFreelist[iLogsize].
16758: */
16759: static void memsys5Unlink(int i, int iLogsize){
16760: int next, prev;
16761: assert( i>=0 && i<mem5.nBlock );
16762: assert( iLogsize>=0 && iLogsize<=LOGMAX );
16763: assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
16764:
16765: next = MEM5LINK(i)->next;
16766: prev = MEM5LINK(i)->prev;
16767: if( prev<0 ){
16768: mem5.aiFreelist[iLogsize] = next;
16769: }else{
16770: MEM5LINK(prev)->next = next;
16771: }
16772: if( next>=0 ){
16773: MEM5LINK(next)->prev = prev;
16774: }
16775: }
16776:
16777: /*
16778: ** Link the chunk at mem5.aPool[i] so that is on the iLogsize
16779: ** free list.
16780: */
16781: static void memsys5Link(int i, int iLogsize){
16782: int x;
16783: assert( sqlite3_mutex_held(mem5.mutex) );
16784: assert( i>=0 && i<mem5.nBlock );
16785: assert( iLogsize>=0 && iLogsize<=LOGMAX );
16786: assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
16787:
16788: x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize];
16789: MEM5LINK(i)->prev = -1;
16790: if( x>=0 ){
16791: assert( x<mem5.nBlock );
16792: MEM5LINK(x)->prev = i;
16793: }
16794: mem5.aiFreelist[iLogsize] = i;
16795: }
16796:
16797: /*
16798: ** If the STATIC_MEM mutex is not already held, obtain it now. The mutex
16799: ** will already be held (obtained by code in malloc.c) if
16800: ** sqlite3GlobalConfig.bMemStat is true.
16801: */
16802: static void memsys5Enter(void){
16803: sqlite3_mutex_enter(mem5.mutex);
16804: }
16805: static void memsys5Leave(void){
16806: sqlite3_mutex_leave(mem5.mutex);
16807: }
16808:
16809: /*
16810: ** Return the size of an outstanding allocation, in bytes. The
16811: ** size returned omits the 8-byte header overhead. This only
16812: ** works for chunks that are currently checked out.
16813: */
16814: static int memsys5Size(void *p){
16815: int iSize = 0;
16816: if( p ){
16817: int i = ((u8 *)p-mem5.zPool)/mem5.szAtom;
16818: assert( i>=0 && i<mem5.nBlock );
16819: iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE));
16820: }
16821: return iSize;
16822: }
16823:
16824: /*
16825: ** Find the first entry on the freelist iLogsize. Unlink that
16826: ** entry and return its index.
16827: */
16828: static int memsys5UnlinkFirst(int iLogsize){
16829: int i;
16830: int iFirst;
16831:
16832: assert( iLogsize>=0 && iLogsize<=LOGMAX );
16833: i = iFirst = mem5.aiFreelist[iLogsize];
16834: assert( iFirst>=0 );
16835: while( i>0 ){
16836: if( i<iFirst ) iFirst = i;
16837: i = MEM5LINK(i)->next;
16838: }
16839: memsys5Unlink(iFirst, iLogsize);
16840: return iFirst;
16841: }
16842:
16843: /*
16844: ** Return a block of memory of at least nBytes in size.
16845: ** Return NULL if unable. Return NULL if nBytes==0.
16846: **
16847: ** The caller guarantees that nByte positive.
16848: **
16849: ** The caller has obtained a mutex prior to invoking this
16850: ** routine so there is never any chance that two or more
16851: ** threads can be in this routine at the same time.
16852: */
16853: static void *memsys5MallocUnsafe(int nByte){
16854: int i; /* Index of a mem5.aPool[] slot */
16855: int iBin; /* Index into mem5.aiFreelist[] */
16856: int iFullSz; /* Size of allocation rounded up to power of 2 */
16857: int iLogsize; /* Log2 of iFullSz/POW2_MIN */
16858:
16859: /* nByte must be a positive */
16860: assert( nByte>0 );
16861:
16862: /* Keep track of the maximum allocation request. Even unfulfilled
16863: ** requests are counted */
16864: if( (u32)nByte>mem5.maxRequest ){
16865: mem5.maxRequest = nByte;
16866: }
16867:
16868: /* Abort if the requested allocation size is larger than the largest
16869: ** power of two that we can represent using 32-bit signed integers.
16870: */
16871: if( nByte > 0x40000000 ){
16872: return 0;
16873: }
16874:
16875: /* Round nByte up to the next valid power of two */
16876: for(iFullSz=mem5.szAtom, iLogsize=0; iFullSz<nByte; iFullSz *= 2, iLogsize++){}
16877:
16878: /* Make sure mem5.aiFreelist[iLogsize] contains at least one free
16879: ** block. If not, then split a block of the next larger power of
16880: ** two in order to create a new free block of size iLogsize.
16881: */
16882: for(iBin=iLogsize; mem5.aiFreelist[iBin]<0 && iBin<=LOGMAX; iBin++){}
16883: if( iBin>LOGMAX ){
16884: testcase( sqlite3GlobalConfig.xLog!=0 );
16885: sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte);
16886: return 0;
16887: }
16888: i = memsys5UnlinkFirst(iBin);
16889: while( iBin>iLogsize ){
16890: int newSize;
16891:
16892: iBin--;
16893: newSize = 1 << iBin;
16894: mem5.aCtrl[i+newSize] = CTRL_FREE | iBin;
16895: memsys5Link(i+newSize, iBin);
16896: }
16897: mem5.aCtrl[i] = iLogsize;
16898:
16899: /* Update allocator performance statistics. */
16900: mem5.nAlloc++;
16901: mem5.totalAlloc += iFullSz;
16902: mem5.totalExcess += iFullSz - nByte;
16903: mem5.currentCount++;
16904: mem5.currentOut += iFullSz;
16905: if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
16906: if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
16907:
16908: /* Return a pointer to the allocated memory. */
16909: return (void*)&mem5.zPool[i*mem5.szAtom];
16910: }
16911:
16912: /*
16913: ** Free an outstanding memory allocation.
16914: */
16915: static void memsys5FreeUnsafe(void *pOld){
16916: u32 size, iLogsize;
16917: int iBlock;
16918:
16919: /* Set iBlock to the index of the block pointed to by pOld in
16920: ** the array of mem5.szAtom byte blocks pointed to by mem5.zPool.
16921: */
16922: iBlock = ((u8 *)pOld-mem5.zPool)/mem5.szAtom;
16923:
16924: /* Check that the pointer pOld points to a valid, non-free block. */
16925: assert( iBlock>=0 && iBlock<mem5.nBlock );
16926: assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );
16927: assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 );
16928:
16929: iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE;
16930: size = 1<<iLogsize;
16931: assert( iBlock+size-1<(u32)mem5.nBlock );
16932:
16933: mem5.aCtrl[iBlock] |= CTRL_FREE;
16934: mem5.aCtrl[iBlock+size-1] |= CTRL_FREE;
16935: assert( mem5.currentCount>0 );
16936: assert( mem5.currentOut>=(size*mem5.szAtom) );
16937: mem5.currentCount--;
16938: mem5.currentOut -= size*mem5.szAtom;
16939: assert( mem5.currentOut>0 || mem5.currentCount==0 );
16940: assert( mem5.currentCount>0 || mem5.currentOut==0 );
16941:
16942: mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
16943: while( ALWAYS(iLogsize<LOGMAX) ){
16944: int iBuddy;
16945: if( (iBlock>>iLogsize) & 1 ){
16946: iBuddy = iBlock - size;
16947: }else{
16948: iBuddy = iBlock + size;
16949: }
16950: assert( iBuddy>=0 );
16951: if( (iBuddy+(1<<iLogsize))>mem5.nBlock ) break;
16952: if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break;
16953: memsys5Unlink(iBuddy, iLogsize);
16954: iLogsize++;
16955: if( iBuddy<iBlock ){
16956: mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
16957: mem5.aCtrl[iBlock] = 0;
16958: iBlock = iBuddy;
16959: }else{
16960: mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
16961: mem5.aCtrl[iBuddy] = 0;
16962: }
16963: size *= 2;
16964: }
16965: memsys5Link(iBlock, iLogsize);
16966: }
16967:
16968: /*
16969: ** Allocate nBytes of memory
16970: */
16971: static void *memsys5Malloc(int nBytes){
16972: sqlite3_int64 *p = 0;
16973: if( nBytes>0 ){
16974: memsys5Enter();
16975: p = memsys5MallocUnsafe(nBytes);
16976: memsys5Leave();
16977: }
16978: return (void*)p;
16979: }
16980:
16981: /*
16982: ** Free memory.
16983: **
16984: ** The outer layer memory allocator prevents this routine from
16985: ** being called with pPrior==0.
16986: */
16987: static void memsys5Free(void *pPrior){
16988: assert( pPrior!=0 );
16989: memsys5Enter();
16990: memsys5FreeUnsafe(pPrior);
16991: memsys5Leave();
16992: }
16993:
16994: /*
16995: ** Change the size of an existing memory allocation.
16996: **
16997: ** The outer layer memory allocator prevents this routine from
16998: ** being called with pPrior==0.
16999: **
17000: ** nBytes is always a value obtained from a prior call to
17001: ** memsys5Round(). Hence nBytes is always a non-negative power
17002: ** of two. If nBytes==0 that means that an oversize allocation
17003: ** (an allocation larger than 0x40000000) was requested and this
17004: ** routine should return 0 without freeing pPrior.
17005: */
17006: static void *memsys5Realloc(void *pPrior, int nBytes){
17007: int nOld;
17008: void *p;
17009: assert( pPrior!=0 );
17010: assert( (nBytes&(nBytes-1))==0 ); /* EV: R-46199-30249 */
17011: assert( nBytes>=0 );
17012: if( nBytes==0 ){
17013: return 0;
17014: }
17015: nOld = memsys5Size(pPrior);
17016: if( nBytes<=nOld ){
17017: return pPrior;
17018: }
17019: memsys5Enter();
17020: p = memsys5MallocUnsafe(nBytes);
17021: if( p ){
17022: memcpy(p, pPrior, nOld);
17023: memsys5FreeUnsafe(pPrior);
17024: }
17025: memsys5Leave();
17026: return p;
17027: }
17028:
17029: /*
17030: ** Round up a request size to the next valid allocation size. If
17031: ** the allocation is too large to be handled by this allocation system,
17032: ** return 0.
17033: **
17034: ** All allocations must be a power of two and must be expressed by a
17035: ** 32-bit signed integer. Hence the largest allocation is 0x40000000
17036: ** or 1073741824 bytes.
17037: */
17038: static int memsys5Roundup(int n){
17039: int iFullSz;
17040: if( n > 0x40000000 ) return 0;
17041: for(iFullSz=mem5.szAtom; iFullSz<n; iFullSz *= 2);
17042: return iFullSz;
17043: }
17044:
17045: /*
17046: ** Return the ceiling of the logarithm base 2 of iValue.
17047: **
17048: ** Examples: memsys5Log(1) -> 0
17049: ** memsys5Log(2) -> 1
17050: ** memsys5Log(4) -> 2
17051: ** memsys5Log(5) -> 3
17052: ** memsys5Log(8) -> 3
17053: ** memsys5Log(9) -> 4
17054: */
17055: static int memsys5Log(int iValue){
17056: int iLog;
17057: for(iLog=0; (iLog<(int)((sizeof(int)*8)-1)) && (1<<iLog)<iValue; iLog++);
17058: return iLog;
17059: }
17060:
17061: /*
17062: ** Initialize the memory allocator.
17063: **
17064: ** This routine is not threadsafe. The caller must be holding a mutex
17065: ** to prevent multiple threads from entering at the same time.
17066: */
17067: static int memsys5Init(void *NotUsed){
17068: int ii; /* Loop counter */
17069: int nByte; /* Number of bytes of memory available to this allocator */
17070: u8 *zByte; /* Memory usable by this allocator */
17071: int nMinLog; /* Log base 2 of minimum allocation size in bytes */
17072: int iOffset; /* An offset into mem5.aCtrl[] */
17073:
17074: UNUSED_PARAMETER(NotUsed);
17075:
17076: /* For the purposes of this routine, disable the mutex */
17077: mem5.mutex = 0;
17078:
17079: /* The size of a Mem5Link object must be a power of two. Verify that
17080: ** this is case.
17081: */
17082: assert( (sizeof(Mem5Link)&(sizeof(Mem5Link)-1))==0 );
17083:
17084: nByte = sqlite3GlobalConfig.nHeap;
17085: zByte = (u8*)sqlite3GlobalConfig.pHeap;
17086: assert( zByte!=0 ); /* sqlite3_config() does not allow otherwise */
17087:
17088: /* boundaries on sqlite3GlobalConfig.mnReq are enforced in sqlite3_config() */
17089: nMinLog = memsys5Log(sqlite3GlobalConfig.mnReq);
17090: mem5.szAtom = (1<<nMinLog);
17091: while( (int)sizeof(Mem5Link)>mem5.szAtom ){
17092: mem5.szAtom = mem5.szAtom << 1;
17093: }
17094:
17095: mem5.nBlock = (nByte / (mem5.szAtom+sizeof(u8)));
17096: mem5.zPool = zByte;
17097: mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom];
17098:
17099: for(ii=0; ii<=LOGMAX; ii++){
17100: mem5.aiFreelist[ii] = -1;
17101: }
17102:
17103: iOffset = 0;
17104: for(ii=LOGMAX; ii>=0; ii--){
17105: int nAlloc = (1<<ii);
17106: if( (iOffset+nAlloc)<=mem5.nBlock ){
17107: mem5.aCtrl[iOffset] = ii | CTRL_FREE;
17108: memsys5Link(iOffset, ii);
17109: iOffset += nAlloc;
17110: }
17111: assert((iOffset+nAlloc)>mem5.nBlock);
17112: }
17113:
17114: /* If a mutex is required for normal operation, allocate one */
17115: if( sqlite3GlobalConfig.bMemstat==0 ){
17116: mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
17117: }
17118:
17119: return SQLITE_OK;
17120: }
17121:
17122: /*
17123: ** Deinitialize this module.
17124: */
17125: static void memsys5Shutdown(void *NotUsed){
17126: UNUSED_PARAMETER(NotUsed);
17127: mem5.mutex = 0;
17128: return;
17129: }
17130:
17131: #ifdef SQLITE_TEST
17132: /*
17133: ** Open the file indicated and write a log of all unfreed memory
17134: ** allocations into that log.
17135: */
17136: SQLITE_PRIVATE void sqlite3Memsys5Dump(const char *zFilename){
17137: FILE *out;
17138: int i, j, n;
17139: int nMinLog;
17140:
17141: if( zFilename==0 || zFilename[0]==0 ){
17142: out = stdout;
17143: }else{
17144: out = fopen(zFilename, "w");
17145: if( out==0 ){
17146: fprintf(stderr, "** Unable to output memory debug output log: %s **\n",
17147: zFilename);
17148: return;
17149: }
17150: }
17151: memsys5Enter();
17152: nMinLog = memsys5Log(mem5.szAtom);
17153: for(i=0; i<=LOGMAX && i+nMinLog<32; i++){
17154: for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){}
17155: fprintf(out, "freelist items of size %d: %d\n", mem5.szAtom << i, n);
17156: }
17157: fprintf(out, "mem5.nAlloc = %llu\n", mem5.nAlloc);
17158: fprintf(out, "mem5.totalAlloc = %llu\n", mem5.totalAlloc);
17159: fprintf(out, "mem5.totalExcess = %llu\n", mem5.totalExcess);
17160: fprintf(out, "mem5.currentOut = %u\n", mem5.currentOut);
17161: fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
17162: fprintf(out, "mem5.maxOut = %u\n", mem5.maxOut);
17163: fprintf(out, "mem5.maxCount = %u\n", mem5.maxCount);
17164: fprintf(out, "mem5.maxRequest = %u\n", mem5.maxRequest);
17165: memsys5Leave();
17166: if( out==stdout ){
17167: fflush(stdout);
17168: }else{
17169: fclose(out);
17170: }
17171: }
17172: #endif
17173:
17174: /*
17175: ** This routine is the only routine in this file with external
17176: ** linkage. It returns a pointer to a static sqlite3_mem_methods
17177: ** struct populated with the memsys5 methods.
17178: */
17179: SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetMemsys5(void){
17180: static const sqlite3_mem_methods memsys5Methods = {
17181: memsys5Malloc,
17182: memsys5Free,
17183: memsys5Realloc,
17184: memsys5Size,
17185: memsys5Roundup,
17186: memsys5Init,
17187: memsys5Shutdown,
17188: 0
17189: };
17190: return &memsys5Methods;
17191: }
17192:
17193: #endif /* SQLITE_ENABLE_MEMSYS5 */
17194:
17195: /************** End of mem5.c ************************************************/
17196: /************** Begin file mutex.c *******************************************/
17197: /*
17198: ** 2007 August 14
17199: **
17200: ** The author disclaims copyright to this source code. In place of
17201: ** a legal notice, here is a blessing:
17202: **
17203: ** May you do good and not evil.
17204: ** May you find forgiveness for yourself and forgive others.
17205: ** May you share freely, never taking more than you give.
17206: **
17207: *************************************************************************
17208: ** This file contains the C functions that implement mutexes.
17209: **
17210: ** This file contains code that is common across all mutex implementations.
17211: */
17212:
17213: #if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT)
17214: /*
17215: ** For debugging purposes, record when the mutex subsystem is initialized
17216: ** and uninitialized so that we can assert() if there is an attempt to
17217: ** allocate a mutex while the system is uninitialized.
17218: */
17219: static SQLITE_WSD int mutexIsInit = 0;
17220: #endif /* SQLITE_DEBUG */
17221:
17222:
17223: #ifndef SQLITE_MUTEX_OMIT
17224: /*
17225: ** Initialize the mutex system.
17226: */
17227: SQLITE_PRIVATE int sqlite3MutexInit(void){
17228: int rc = SQLITE_OK;
17229: if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
17230: /* If the xMutexAlloc method has not been set, then the user did not
17231: ** install a mutex implementation via sqlite3_config() prior to
17232: ** sqlite3_initialize() being called. This block copies pointers to
17233: ** the default implementation into the sqlite3GlobalConfig structure.
17234: */
17235: sqlite3_mutex_methods const *pFrom;
17236: sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
17237:
17238: if( sqlite3GlobalConfig.bCoreMutex ){
17239: pFrom = sqlite3DefaultMutex();
17240: }else{
17241: pFrom = sqlite3NoopMutex();
17242: }
17243: memcpy(pTo, pFrom, offsetof(sqlite3_mutex_methods, xMutexAlloc));
17244: memcpy(&pTo->xMutexFree, &pFrom->xMutexFree,
17245: sizeof(*pTo) - offsetof(sqlite3_mutex_methods, xMutexFree));
17246: pTo->xMutexAlloc = pFrom->xMutexAlloc;
17247: }
17248: rc = sqlite3GlobalConfig.mutex.xMutexInit();
17249:
17250: #ifdef SQLITE_DEBUG
17251: GLOBAL(int, mutexIsInit) = 1;
17252: #endif
17253:
17254: return rc;
17255: }
17256:
17257: /*
17258: ** Shutdown the mutex system. This call frees resources allocated by
17259: ** sqlite3MutexInit().
17260: */
17261: SQLITE_PRIVATE int sqlite3MutexEnd(void){
17262: int rc = SQLITE_OK;
17263: if( sqlite3GlobalConfig.mutex.xMutexEnd ){
17264: rc = sqlite3GlobalConfig.mutex.xMutexEnd();
17265: }
17266:
17267: #ifdef SQLITE_DEBUG
17268: GLOBAL(int, mutexIsInit) = 0;
17269: #endif
17270:
17271: return rc;
17272: }
17273:
17274: /*
17275: ** Retrieve a pointer to a static mutex or allocate a new dynamic one.
17276: */
17277: SQLITE_API sqlite3_mutex *sqlite3_mutex_alloc(int id){
17278: #ifndef SQLITE_OMIT_AUTOINIT
17279: if( sqlite3_initialize() ) return 0;
17280: #endif
17281: return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
17282: }
17283:
17284: SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int id){
17285: if( !sqlite3GlobalConfig.bCoreMutex ){
17286: return 0;
17287: }
17288: assert( GLOBAL(int, mutexIsInit) );
17289: return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
17290: }
17291:
17292: /*
17293: ** Free a dynamic mutex.
17294: */
17295: SQLITE_API void sqlite3_mutex_free(sqlite3_mutex *p){
17296: if( p ){
17297: sqlite3GlobalConfig.mutex.xMutexFree(p);
17298: }
17299: }
17300:
17301: /*
17302: ** Obtain the mutex p. If some other thread already has the mutex, block
17303: ** until it can be obtained.
17304: */
17305: SQLITE_API void sqlite3_mutex_enter(sqlite3_mutex *p){
17306: if( p ){
17307: sqlite3GlobalConfig.mutex.xMutexEnter(p);
17308: }
17309: }
17310:
17311: /*
17312: ** Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
17313: ** thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
17314: */
17315: SQLITE_API int sqlite3_mutex_try(sqlite3_mutex *p){
17316: int rc = SQLITE_OK;
17317: if( p ){
17318: return sqlite3GlobalConfig.mutex.xMutexTry(p);
17319: }
17320: return rc;
17321: }
17322:
17323: /*
17324: ** The sqlite3_mutex_leave() routine exits a mutex that was previously
17325: ** entered by the same thread. The behavior is undefined if the mutex
17326: ** is not currently entered. If a NULL pointer is passed as an argument
17327: ** this function is a no-op.
17328: */
17329: SQLITE_API void sqlite3_mutex_leave(sqlite3_mutex *p){
17330: if( p ){
17331: sqlite3GlobalConfig.mutex.xMutexLeave(p);
17332: }
17333: }
17334:
17335: #ifndef NDEBUG
17336: /*
17337: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
17338: ** intended for use inside assert() statements.
17339: */
17340: SQLITE_API int sqlite3_mutex_held(sqlite3_mutex *p){
17341: return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
17342: }
17343: SQLITE_API int sqlite3_mutex_notheld(sqlite3_mutex *p){
17344: return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
17345: }
17346: #endif
17347:
17348: #endif /* !defined(SQLITE_MUTEX_OMIT) */
17349:
17350: /************** End of mutex.c ***********************************************/
17351: /************** Begin file mutex_noop.c **************************************/
17352: /*
17353: ** 2008 October 07
17354: **
17355: ** The author disclaims copyright to this source code. In place of
17356: ** a legal notice, here is a blessing:
17357: **
17358: ** May you do good and not evil.
17359: ** May you find forgiveness for yourself and forgive others.
17360: ** May you share freely, never taking more than you give.
17361: **
17362: *************************************************************************
17363: ** This file contains the C functions that implement mutexes.
17364: **
17365: ** This implementation in this file does not provide any mutual
17366: ** exclusion and is thus suitable for use only in applications
17367: ** that use SQLite in a single thread. The routines defined
17368: ** here are place-holders. Applications can substitute working
17369: ** mutex routines at start-time using the
17370: **
17371: ** sqlite3_config(SQLITE_CONFIG_MUTEX,...)
17372: **
17373: ** interface.
17374: **
17375: ** If compiled with SQLITE_DEBUG, then additional logic is inserted
17376: ** that does error checking on mutexes to make sure they are being
17377: ** called correctly.
17378: */
17379:
17380: #ifndef SQLITE_MUTEX_OMIT
17381:
17382: #ifndef SQLITE_DEBUG
17383: /*
17384: ** Stub routines for all mutex methods.
17385: **
17386: ** This routines provide no mutual exclusion or error checking.
17387: */
17388: static int noopMutexInit(void){ return SQLITE_OK; }
17389: static int noopMutexEnd(void){ return SQLITE_OK; }
17390: static sqlite3_mutex *noopMutexAlloc(int id){
17391: UNUSED_PARAMETER(id);
17392: return (sqlite3_mutex*)8;
17393: }
17394: static void noopMutexFree(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
17395: static void noopMutexEnter(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
17396: static int noopMutexTry(sqlite3_mutex *p){
17397: UNUSED_PARAMETER(p);
17398: return SQLITE_OK;
17399: }
17400: static void noopMutexLeave(sqlite3_mutex *p){ UNUSED_PARAMETER(p); return; }
17401:
17402: SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){
17403: static const sqlite3_mutex_methods sMutex = {
17404: noopMutexInit,
17405: noopMutexEnd,
17406: noopMutexAlloc,
17407: noopMutexFree,
17408: noopMutexEnter,
17409: noopMutexTry,
17410: noopMutexLeave,
17411:
17412: 0,
17413: 0,
17414: };
17415:
17416: return &sMutex;
17417: }
17418: #endif /* !SQLITE_DEBUG */
17419:
17420: #ifdef SQLITE_DEBUG
17421: /*
17422: ** In this implementation, error checking is provided for testing
17423: ** and debugging purposes. The mutexes still do not provide any
17424: ** mutual exclusion.
17425: */
17426:
17427: /*
17428: ** The mutex object
17429: */
17430: typedef struct sqlite3_debug_mutex {
17431: int id; /* The mutex type */
17432: int cnt; /* Number of entries without a matching leave */
17433: } sqlite3_debug_mutex;
17434:
17435: /*
17436: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
17437: ** intended for use inside assert() statements.
17438: */
17439: static int debugMutexHeld(sqlite3_mutex *pX){
17440: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
17441: return p==0 || p->cnt>0;
17442: }
17443: static int debugMutexNotheld(sqlite3_mutex *pX){
17444: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
17445: return p==0 || p->cnt==0;
17446: }
17447:
17448: /*
17449: ** Initialize and deinitialize the mutex subsystem.
17450: */
17451: static int debugMutexInit(void){ return SQLITE_OK; }
17452: static int debugMutexEnd(void){ return SQLITE_OK; }
17453:
17454: /*
17455: ** The sqlite3_mutex_alloc() routine allocates a new
17456: ** mutex and returns a pointer to it. If it returns NULL
17457: ** that means that a mutex could not be allocated.
17458: */
17459: static sqlite3_mutex *debugMutexAlloc(int id){
17460: static sqlite3_debug_mutex aStatic[6];
17461: sqlite3_debug_mutex *pNew = 0;
17462: switch( id ){
17463: case SQLITE_MUTEX_FAST:
17464: case SQLITE_MUTEX_RECURSIVE: {
17465: pNew = sqlite3Malloc(sizeof(*pNew));
17466: if( pNew ){
17467: pNew->id = id;
17468: pNew->cnt = 0;
17469: }
17470: break;
17471: }
17472: default: {
17473: assert( id-2 >= 0 );
17474: assert( id-2 < (int)(sizeof(aStatic)/sizeof(aStatic[0])) );
17475: pNew = &aStatic[id-2];
17476: pNew->id = id;
17477: break;
17478: }
17479: }
17480: return (sqlite3_mutex*)pNew;
17481: }
17482:
17483: /*
17484: ** This routine deallocates a previously allocated mutex.
17485: */
17486: static void debugMutexFree(sqlite3_mutex *pX){
17487: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
17488: assert( p->cnt==0 );
17489: assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
17490: sqlite3_free(p);
17491: }
17492:
17493: /*
17494: ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
17495: ** to enter a mutex. If another thread is already within the mutex,
17496: ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
17497: ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
17498: ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
17499: ** be entered multiple times by the same thread. In such cases the,
17500: ** mutex must be exited an equal number of times before another thread
17501: ** can enter. If the same thread tries to enter any other kind of mutex
17502: ** more than once, the behavior is undefined.
17503: */
17504: static void debugMutexEnter(sqlite3_mutex *pX){
17505: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
17506: assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
17507: p->cnt++;
17508: }
17509: static int debugMutexTry(sqlite3_mutex *pX){
17510: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
17511: assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
17512: p->cnt++;
17513: return SQLITE_OK;
17514: }
17515:
17516: /*
17517: ** The sqlite3_mutex_leave() routine exits a mutex that was
17518: ** previously entered by the same thread. The behavior
17519: ** is undefined if the mutex is not currently entered or
17520: ** is not currently allocated. SQLite will never do either.
17521: */
17522: static void debugMutexLeave(sqlite3_mutex *pX){
17523: sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
17524: assert( debugMutexHeld(pX) );
17525: p->cnt--;
17526: assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
17527: }
17528:
17529: SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3NoopMutex(void){
17530: static const sqlite3_mutex_methods sMutex = {
17531: debugMutexInit,
17532: debugMutexEnd,
17533: debugMutexAlloc,
17534: debugMutexFree,
17535: debugMutexEnter,
17536: debugMutexTry,
17537: debugMutexLeave,
17538:
17539: debugMutexHeld,
17540: debugMutexNotheld
17541: };
17542:
17543: return &sMutex;
17544: }
17545: #endif /* SQLITE_DEBUG */
17546:
17547: /*
17548: ** If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
17549: ** is used regardless of the run-time threadsafety setting.
17550: */
17551: #ifdef SQLITE_MUTEX_NOOP
17552: SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
17553: return sqlite3NoopMutex();
17554: }
17555: #endif /* defined(SQLITE_MUTEX_NOOP) */
17556: #endif /* !defined(SQLITE_MUTEX_OMIT) */
17557:
17558: /************** End of mutex_noop.c ******************************************/
17559: /************** Begin file mutex_os2.c ***************************************/
17560: /*
17561: ** 2007 August 28
17562: **
17563: ** The author disclaims copyright to this source code. In place of
17564: ** a legal notice, here is a blessing:
17565: **
17566: ** May you do good and not evil.
17567: ** May you find forgiveness for yourself and forgive others.
17568: ** May you share freely, never taking more than you give.
17569: **
17570: *************************************************************************
17571: ** This file contains the C functions that implement mutexes for OS/2
17572: */
17573:
17574: /*
17575: ** The code in this file is only used if SQLITE_MUTEX_OS2 is defined.
17576: ** See the mutex.h file for details.
17577: */
17578: #ifdef SQLITE_MUTEX_OS2
17579:
17580: /********************** OS/2 Mutex Implementation **********************
17581: **
17582: ** This implementation of mutexes is built using the OS/2 API.
17583: */
17584:
17585: /*
17586: ** The mutex object
17587: ** Each recursive mutex is an instance of the following structure.
17588: */
17589: struct sqlite3_mutex {
17590: HMTX mutex; /* Mutex controlling the lock */
17591: int id; /* Mutex type */
17592: #ifdef SQLITE_DEBUG
17593: int trace; /* True to trace changes */
17594: #endif
17595: };
17596:
17597: #ifdef SQLITE_DEBUG
17598: #define SQLITE3_MUTEX_INITIALIZER { 0, 0, 0 }
17599: #else
17600: #define SQLITE3_MUTEX_INITIALIZER { 0, 0 }
17601: #endif
17602:
17603: /*
17604: ** Initialize and deinitialize the mutex subsystem.
17605: */
17606: static int os2MutexInit(void){ return SQLITE_OK; }
17607: static int os2MutexEnd(void){ return SQLITE_OK; }
17608:
17609: /*
17610: ** The sqlite3_mutex_alloc() routine allocates a new
17611: ** mutex and returns a pointer to it. If it returns NULL
17612: ** that means that a mutex could not be allocated.
17613: ** SQLite will unwind its stack and return an error. The argument
17614: ** to sqlite3_mutex_alloc() is one of these integer constants:
17615: **
17616: ** <ul>
17617: ** <li> SQLITE_MUTEX_FAST
17618: ** <li> SQLITE_MUTEX_RECURSIVE
17619: ** <li> SQLITE_MUTEX_STATIC_MASTER
17620: ** <li> SQLITE_MUTEX_STATIC_MEM
17621: ** <li> SQLITE_MUTEX_STATIC_MEM2
17622: ** <li> SQLITE_MUTEX_STATIC_PRNG
17623: ** <li> SQLITE_MUTEX_STATIC_LRU
17624: ** <li> SQLITE_MUTEX_STATIC_LRU2
17625: ** </ul>
17626: **
17627: ** The first two constants cause sqlite3_mutex_alloc() to create
17628: ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
17629: ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
17630: ** The mutex implementation does not need to make a distinction
17631: ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
17632: ** not want to. But SQLite will only request a recursive mutex in
17633: ** cases where it really needs one. If a faster non-recursive mutex
17634: ** implementation is available on the host platform, the mutex subsystem
17635: ** might return such a mutex in response to SQLITE_MUTEX_FAST.
17636: **
17637: ** The other allowed parameters to sqlite3_mutex_alloc() each return
17638: ** a pointer to a static preexisting mutex. Six static mutexes are
17639: ** used by the current version of SQLite. Future versions of SQLite
17640: ** may add additional static mutexes. Static mutexes are for internal
17641: ** use by SQLite only. Applications that use SQLite mutexes should
17642: ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
17643: ** SQLITE_MUTEX_RECURSIVE.
17644: **
17645: ** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
17646: ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
17647: ** returns a different mutex on every call. But for the static
17648: ** mutex types, the same mutex is returned on every call that has
17649: ** the same type number.
17650: */
17651: static sqlite3_mutex *os2MutexAlloc(int iType){
17652: sqlite3_mutex *p = NULL;
17653: switch( iType ){
17654: case SQLITE_MUTEX_FAST:
17655: case SQLITE_MUTEX_RECURSIVE: {
17656: p = sqlite3MallocZero( sizeof(*p) );
17657: if( p ){
17658: p->id = iType;
17659: if( DosCreateMutexSem( 0, &p->mutex, 0, FALSE ) != NO_ERROR ){
17660: sqlite3_free( p );
17661: p = NULL;
17662: }
17663: }
17664: break;
17665: }
17666: default: {
17667: static volatile int isInit = 0;
17668: static sqlite3_mutex staticMutexes[6] = {
17669: SQLITE3_MUTEX_INITIALIZER,
17670: SQLITE3_MUTEX_INITIALIZER,
17671: SQLITE3_MUTEX_INITIALIZER,
17672: SQLITE3_MUTEX_INITIALIZER,
17673: SQLITE3_MUTEX_INITIALIZER,
17674: SQLITE3_MUTEX_INITIALIZER,
17675: };
17676: if ( !isInit ){
17677: APIRET rc;
17678: PTIB ptib;
17679: PPIB ppib;
17680: HMTX mutex;
17681: char name[32];
17682: DosGetInfoBlocks( &ptib, &ppib );
17683: sqlite3_snprintf( sizeof(name), name, "\\SEM32\\SQLITE%04x",
17684: ppib->pib_ulpid );
17685: while( !isInit ){
17686: mutex = 0;
17687: rc = DosCreateMutexSem( name, &mutex, 0, FALSE);
17688: if( rc == NO_ERROR ){
17689: unsigned int i;
17690: if( !isInit ){
17691: for( i = 0; i < sizeof(staticMutexes)/sizeof(staticMutexes[0]); i++ ){
17692: DosCreateMutexSem( 0, &staticMutexes[i].mutex, 0, FALSE );
17693: }
17694: isInit = 1;
17695: }
17696: DosCloseMutexSem( mutex );
17697: }else if( rc == ERROR_DUPLICATE_NAME ){
17698: DosSleep( 1 );
17699: }else{
17700: return p;
17701: }
17702: }
17703: }
17704: assert( iType-2 >= 0 );
17705: assert( iType-2 < sizeof(staticMutexes)/sizeof(staticMutexes[0]) );
17706: p = &staticMutexes[iType-2];
17707: p->id = iType;
17708: break;
17709: }
17710: }
17711: return p;
17712: }
17713:
17714:
17715: /*
17716: ** This routine deallocates a previously allocated mutex.
17717: ** SQLite is careful to deallocate every mutex that it allocates.
17718: */
17719: static void os2MutexFree(sqlite3_mutex *p){
17720: #ifdef SQLITE_DEBUG
17721: TID tid;
17722: PID pid;
17723: ULONG ulCount;
17724: DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
17725: assert( ulCount==0 );
17726: assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
17727: #endif
17728: DosCloseMutexSem( p->mutex );
17729: sqlite3_free( p );
17730: }
17731:
17732: #ifdef SQLITE_DEBUG
17733: /*
17734: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
17735: ** intended for use inside assert() statements.
17736: */
17737: static int os2MutexHeld(sqlite3_mutex *p){
17738: TID tid;
17739: PID pid;
17740: ULONG ulCount;
17741: PTIB ptib;
17742: DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
17743: if( ulCount==0 || ( ulCount>1 && p->id!=SQLITE_MUTEX_RECURSIVE ) )
17744: return 0;
17745: DosGetInfoBlocks(&ptib, NULL);
17746: return tid==ptib->tib_ptib2->tib2_ultid;
17747: }
17748: static int os2MutexNotheld(sqlite3_mutex *p){
17749: TID tid;
17750: PID pid;
17751: ULONG ulCount;
17752: PTIB ptib;
17753: DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
17754: if( ulCount==0 )
17755: return 1;
17756: DosGetInfoBlocks(&ptib, NULL);
17757: return tid!=ptib->tib_ptib2->tib2_ultid;
17758: }
17759: static void os2MutexTrace(sqlite3_mutex *p, char *pAction){
17760: TID tid;
17761: PID pid;
17762: ULONG ulCount;
17763: DosQueryMutexSem(p->mutex, &pid, &tid, &ulCount);
17764: printf("%s mutex %p (%d) with nRef=%ld\n", pAction, (void*)p, p->trace, ulCount);
17765: }
17766: #endif
17767:
17768: /*
17769: ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
17770: ** to enter a mutex. If another thread is already within the mutex,
17771: ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
17772: ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
17773: ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
17774: ** be entered multiple times by the same thread. In such cases the,
17775: ** mutex must be exited an equal number of times before another thread
17776: ** can enter. If the same thread tries to enter any other kind of mutex
17777: ** more than once, the behavior is undefined.
17778: */
17779: static void os2MutexEnter(sqlite3_mutex *p){
17780: assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) );
17781: DosRequestMutexSem(p->mutex, SEM_INDEFINITE_WAIT);
17782: #ifdef SQLITE_DEBUG
17783: if( p->trace ) os2MutexTrace(p, "enter");
17784: #endif
17785: }
17786: static int os2MutexTry(sqlite3_mutex *p){
17787: int rc = SQLITE_BUSY;
17788: assert( p->id==SQLITE_MUTEX_RECURSIVE || os2MutexNotheld(p) );
17789: if( DosRequestMutexSem(p->mutex, SEM_IMMEDIATE_RETURN) == NO_ERROR ) {
17790: rc = SQLITE_OK;
17791: #ifdef SQLITE_DEBUG
17792: if( p->trace ) os2MutexTrace(p, "try");
17793: #endif
17794: }
17795: return rc;
17796: }
17797:
17798: /*
17799: ** The sqlite3_mutex_leave() routine exits a mutex that was
17800: ** previously entered by the same thread. The behavior
17801: ** is undefined if the mutex is not currently entered or
17802: ** is not currently allocated. SQLite will never do either.
17803: */
17804: static void os2MutexLeave(sqlite3_mutex *p){
17805: assert( os2MutexHeld(p) );
17806: DosReleaseMutexSem(p->mutex);
17807: #ifdef SQLITE_DEBUG
17808: if( p->trace ) os2MutexTrace(p, "leave");
17809: #endif
17810: }
17811:
17812: SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
17813: static const sqlite3_mutex_methods sMutex = {
17814: os2MutexInit,
17815: os2MutexEnd,
17816: os2MutexAlloc,
17817: os2MutexFree,
17818: os2MutexEnter,
17819: os2MutexTry,
17820: os2MutexLeave,
17821: #ifdef SQLITE_DEBUG
17822: os2MutexHeld,
17823: os2MutexNotheld
17824: #else
17825: 0,
17826: 0
17827: #endif
17828: };
17829:
17830: return &sMutex;
17831: }
17832: #endif /* SQLITE_MUTEX_OS2 */
17833:
17834: /************** End of mutex_os2.c *******************************************/
17835: /************** Begin file mutex_unix.c **************************************/
17836: /*
17837: ** 2007 August 28
17838: **
17839: ** The author disclaims copyright to this source code. In place of
17840: ** a legal notice, here is a blessing:
17841: **
17842: ** May you do good and not evil.
17843: ** May you find forgiveness for yourself and forgive others.
17844: ** May you share freely, never taking more than you give.
17845: **
17846: *************************************************************************
17847: ** This file contains the C functions that implement mutexes for pthreads
17848: */
17849:
17850: /*
17851: ** The code in this file is only used if we are compiling threadsafe
17852: ** under unix with pthreads.
17853: **
17854: ** Note that this implementation requires a version of pthreads that
17855: ** supports recursive mutexes.
17856: */
17857: #ifdef SQLITE_MUTEX_PTHREADS
17858:
17859: #include <pthread.h>
17860:
17861: /*
17862: ** The sqlite3_mutex.id, sqlite3_mutex.nRef, and sqlite3_mutex.owner fields
17863: ** are necessary under two condidtions: (1) Debug builds and (2) using
17864: ** home-grown mutexes. Encapsulate these conditions into a single #define.
17865: */
17866: #if defined(SQLITE_DEBUG) || defined(SQLITE_HOMEGROWN_RECURSIVE_MUTEX)
17867: # define SQLITE_MUTEX_NREF 1
17868: #else
17869: # define SQLITE_MUTEX_NREF 0
17870: #endif
17871:
17872: /*
17873: ** Each recursive mutex is an instance of the following structure.
17874: */
17875: struct sqlite3_mutex {
17876: pthread_mutex_t mutex; /* Mutex controlling the lock */
17877: #if SQLITE_MUTEX_NREF
17878: int id; /* Mutex type */
17879: volatile int nRef; /* Number of entrances */
17880: volatile pthread_t owner; /* Thread that is within this mutex */
17881: int trace; /* True to trace changes */
17882: #endif
17883: };
17884: #if SQLITE_MUTEX_NREF
17885: #define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER, 0, 0, (pthread_t)0, 0 }
17886: #else
17887: #define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }
17888: #endif
17889:
17890: /*
17891: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
17892: ** intended for use only inside assert() statements. On some platforms,
17893: ** there might be race conditions that can cause these routines to
17894: ** deliver incorrect results. In particular, if pthread_equal() is
17895: ** not an atomic operation, then these routines might delivery
17896: ** incorrect results. On most platforms, pthread_equal() is a
17897: ** comparison of two integers and is therefore atomic. But we are
17898: ** told that HPUX is not such a platform. If so, then these routines
17899: ** will not always work correctly on HPUX.
17900: **
17901: ** On those platforms where pthread_equal() is not atomic, SQLite
17902: ** should be compiled without -DSQLITE_DEBUG and with -DNDEBUG to
17903: ** make sure no assert() statements are evaluated and hence these
17904: ** routines are never called.
17905: */
17906: #if !defined(NDEBUG) || defined(SQLITE_DEBUG)
17907: static int pthreadMutexHeld(sqlite3_mutex *p){
17908: return (p->nRef!=0 && pthread_equal(p->owner, pthread_self()));
17909: }
17910: static int pthreadMutexNotheld(sqlite3_mutex *p){
17911: return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0;
17912: }
17913: #endif
17914:
17915: /*
17916: ** Initialize and deinitialize the mutex subsystem.
17917: */
17918: static int pthreadMutexInit(void){ return SQLITE_OK; }
17919: static int pthreadMutexEnd(void){ return SQLITE_OK; }
17920:
17921: /*
17922: ** The sqlite3_mutex_alloc() routine allocates a new
17923: ** mutex and returns a pointer to it. If it returns NULL
17924: ** that means that a mutex could not be allocated. SQLite
17925: ** will unwind its stack and return an error. The argument
17926: ** to sqlite3_mutex_alloc() is one of these integer constants:
17927: **
17928: ** <ul>
17929: ** <li> SQLITE_MUTEX_FAST
17930: ** <li> SQLITE_MUTEX_RECURSIVE
17931: ** <li> SQLITE_MUTEX_STATIC_MASTER
17932: ** <li> SQLITE_MUTEX_STATIC_MEM
17933: ** <li> SQLITE_MUTEX_STATIC_MEM2
17934: ** <li> SQLITE_MUTEX_STATIC_PRNG
17935: ** <li> SQLITE_MUTEX_STATIC_LRU
17936: ** <li> SQLITE_MUTEX_STATIC_PMEM
17937: ** </ul>
17938: **
17939: ** The first two constants cause sqlite3_mutex_alloc() to create
17940: ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
17941: ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
17942: ** The mutex implementation does not need to make a distinction
17943: ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
17944: ** not want to. But SQLite will only request a recursive mutex in
17945: ** cases where it really needs one. If a faster non-recursive mutex
17946: ** implementation is available on the host platform, the mutex subsystem
17947: ** might return such a mutex in response to SQLITE_MUTEX_FAST.
17948: **
17949: ** The other allowed parameters to sqlite3_mutex_alloc() each return
17950: ** a pointer to a static preexisting mutex. Six static mutexes are
17951: ** used by the current version of SQLite. Future versions of SQLite
17952: ** may add additional static mutexes. Static mutexes are for internal
17953: ** use by SQLite only. Applications that use SQLite mutexes should
17954: ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
17955: ** SQLITE_MUTEX_RECURSIVE.
17956: **
17957: ** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
17958: ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
17959: ** returns a different mutex on every call. But for the static
17960: ** mutex types, the same mutex is returned on every call that has
17961: ** the same type number.
17962: */
17963: static sqlite3_mutex *pthreadMutexAlloc(int iType){
17964: static sqlite3_mutex staticMutexes[] = {
17965: SQLITE3_MUTEX_INITIALIZER,
17966: SQLITE3_MUTEX_INITIALIZER,
17967: SQLITE3_MUTEX_INITIALIZER,
17968: SQLITE3_MUTEX_INITIALIZER,
17969: SQLITE3_MUTEX_INITIALIZER,
17970: SQLITE3_MUTEX_INITIALIZER
17971: };
17972: sqlite3_mutex *p;
17973: switch( iType ){
17974: case SQLITE_MUTEX_RECURSIVE: {
17975: p = sqlite3MallocZero( sizeof(*p) );
17976: if( p ){
17977: #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
17978: /* If recursive mutexes are not available, we will have to
17979: ** build our own. See below. */
17980: pthread_mutex_init(&p->mutex, 0);
17981: #else
17982: /* Use a recursive mutex if it is available */
17983: pthread_mutexattr_t recursiveAttr;
17984: pthread_mutexattr_init(&recursiveAttr);
17985: pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE);
17986: pthread_mutex_init(&p->mutex, &recursiveAttr);
17987: pthread_mutexattr_destroy(&recursiveAttr);
17988: #endif
17989: #if SQLITE_MUTEX_NREF
17990: p->id = iType;
17991: #endif
17992: }
17993: break;
17994: }
17995: case SQLITE_MUTEX_FAST: {
17996: p = sqlite3MallocZero( sizeof(*p) );
17997: if( p ){
17998: #if SQLITE_MUTEX_NREF
17999: p->id = iType;
18000: #endif
18001: pthread_mutex_init(&p->mutex, 0);
18002: }
18003: break;
18004: }
18005: default: {
18006: assert( iType-2 >= 0 );
18007: assert( iType-2 < ArraySize(staticMutexes) );
18008: p = &staticMutexes[iType-2];
18009: #if SQLITE_MUTEX_NREF
18010: p->id = iType;
18011: #endif
18012: break;
18013: }
18014: }
18015: return p;
18016: }
18017:
18018:
18019: /*
18020: ** This routine deallocates a previously
18021: ** allocated mutex. SQLite is careful to deallocate every
18022: ** mutex that it allocates.
18023: */
18024: static void pthreadMutexFree(sqlite3_mutex *p){
18025: assert( p->nRef==0 );
18026: assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
18027: pthread_mutex_destroy(&p->mutex);
18028: sqlite3_free(p);
18029: }
18030:
18031: /*
18032: ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
18033: ** to enter a mutex. If another thread is already within the mutex,
18034: ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
18035: ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
18036: ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
18037: ** be entered multiple times by the same thread. In such cases the,
18038: ** mutex must be exited an equal number of times before another thread
18039: ** can enter. If the same thread tries to enter any other kind of mutex
18040: ** more than once, the behavior is undefined.
18041: */
18042: static void pthreadMutexEnter(sqlite3_mutex *p){
18043: assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
18044:
18045: #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
18046: /* If recursive mutexes are not available, then we have to grow
18047: ** our own. This implementation assumes that pthread_equal()
18048: ** is atomic - that it cannot be deceived into thinking self
18049: ** and p->owner are equal if p->owner changes between two values
18050: ** that are not equal to self while the comparison is taking place.
18051: ** This implementation also assumes a coherent cache - that
18052: ** separate processes cannot read different values from the same
18053: ** address at the same time. If either of these two conditions
18054: ** are not met, then the mutexes will fail and problems will result.
18055: */
18056: {
18057: pthread_t self = pthread_self();
18058: if( p->nRef>0 && pthread_equal(p->owner, self) ){
18059: p->nRef++;
18060: }else{
18061: pthread_mutex_lock(&p->mutex);
18062: assert( p->nRef==0 );
18063: p->owner = self;
18064: p->nRef = 1;
18065: }
18066: }
18067: #else
18068: /* Use the built-in recursive mutexes if they are available.
18069: */
18070: pthread_mutex_lock(&p->mutex);
18071: #if SQLITE_MUTEX_NREF
18072: assert( p->nRef>0 || p->owner==0 );
18073: p->owner = pthread_self();
18074: p->nRef++;
18075: #endif
18076: #endif
18077:
18078: #ifdef SQLITE_DEBUG
18079: if( p->trace ){
18080: printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
18081: }
18082: #endif
18083: }
18084: static int pthreadMutexTry(sqlite3_mutex *p){
18085: int rc;
18086: assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
18087:
18088: #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
18089: /* If recursive mutexes are not available, then we have to grow
18090: ** our own. This implementation assumes that pthread_equal()
18091: ** is atomic - that it cannot be deceived into thinking self
18092: ** and p->owner are equal if p->owner changes between two values
18093: ** that are not equal to self while the comparison is taking place.
18094: ** This implementation also assumes a coherent cache - that
18095: ** separate processes cannot read different values from the same
18096: ** address at the same time. If either of these two conditions
18097: ** are not met, then the mutexes will fail and problems will result.
18098: */
18099: {
18100: pthread_t self = pthread_self();
18101: if( p->nRef>0 && pthread_equal(p->owner, self) ){
18102: p->nRef++;
18103: rc = SQLITE_OK;
18104: }else if( pthread_mutex_trylock(&p->mutex)==0 ){
18105: assert( p->nRef==0 );
18106: p->owner = self;
18107: p->nRef = 1;
18108: rc = SQLITE_OK;
18109: }else{
18110: rc = SQLITE_BUSY;
18111: }
18112: }
18113: #else
18114: /* Use the built-in recursive mutexes if they are available.
18115: */
18116: if( pthread_mutex_trylock(&p->mutex)==0 ){
18117: #if SQLITE_MUTEX_NREF
18118: p->owner = pthread_self();
18119: p->nRef++;
18120: #endif
18121: rc = SQLITE_OK;
18122: }else{
18123: rc = SQLITE_BUSY;
18124: }
18125: #endif
18126:
18127: #ifdef SQLITE_DEBUG
18128: if( rc==SQLITE_OK && p->trace ){
18129: printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
18130: }
18131: #endif
18132: return rc;
18133: }
18134:
18135: /*
18136: ** The sqlite3_mutex_leave() routine exits a mutex that was
18137: ** previously entered by the same thread. The behavior
18138: ** is undefined if the mutex is not currently entered or
18139: ** is not currently allocated. SQLite will never do either.
18140: */
18141: static void pthreadMutexLeave(sqlite3_mutex *p){
18142: assert( pthreadMutexHeld(p) );
18143: #if SQLITE_MUTEX_NREF
18144: p->nRef--;
18145: if( p->nRef==0 ) p->owner = 0;
18146: #endif
18147: assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
18148:
18149: #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
18150: if( p->nRef==0 ){
18151: pthread_mutex_unlock(&p->mutex);
18152: }
18153: #else
18154: pthread_mutex_unlock(&p->mutex);
18155: #endif
18156:
18157: #ifdef SQLITE_DEBUG
18158: if( p->trace ){
18159: printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
18160: }
18161: #endif
18162: }
18163:
18164: SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
18165: static const sqlite3_mutex_methods sMutex = {
18166: pthreadMutexInit,
18167: pthreadMutexEnd,
18168: pthreadMutexAlloc,
18169: pthreadMutexFree,
18170: pthreadMutexEnter,
18171: pthreadMutexTry,
18172: pthreadMutexLeave,
18173: #ifdef SQLITE_DEBUG
18174: pthreadMutexHeld,
18175: pthreadMutexNotheld
18176: #else
18177: 0,
18178: 0
18179: #endif
18180: };
18181:
18182: return &sMutex;
18183: }
18184:
18185: #endif /* SQLITE_MUTEX_PTHREADS */
18186:
18187: /************** End of mutex_unix.c ******************************************/
18188: /************** Begin file mutex_w32.c ***************************************/
18189: /*
18190: ** 2007 August 14
18191: **
18192: ** The author disclaims copyright to this source code. In place of
18193: ** a legal notice, here is a blessing:
18194: **
18195: ** May you do good and not evil.
18196: ** May you find forgiveness for yourself and forgive others.
18197: ** May you share freely, never taking more than you give.
18198: **
18199: *************************************************************************
18200: ** This file contains the C functions that implement mutexes for win32
18201: */
18202:
18203: /*
18204: ** The code in this file is only used if we are compiling multithreaded
18205: ** on a win32 system.
18206: */
18207: #ifdef SQLITE_MUTEX_W32
18208:
18209: /*
18210: ** Each recursive mutex is an instance of the following structure.
18211: */
18212: struct sqlite3_mutex {
18213: CRITICAL_SECTION mutex; /* Mutex controlling the lock */
18214: int id; /* Mutex type */
18215: #ifdef SQLITE_DEBUG
18216: volatile int nRef; /* Number of enterances */
18217: volatile DWORD owner; /* Thread holding this mutex */
18218: int trace; /* True to trace changes */
18219: #endif
18220: };
18221: #define SQLITE_W32_MUTEX_INITIALIZER { 0 }
18222: #ifdef SQLITE_DEBUG
18223: #define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0, 0L, (DWORD)0, 0 }
18224: #else
18225: #define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0 }
18226: #endif
18227:
18228: /*
18229: ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
18230: ** or WinCE. Return false (zero) for Win95, Win98, or WinME.
18231: **
18232: ** Here is an interesting observation: Win95, Win98, and WinME lack
18233: ** the LockFileEx() API. But we can still statically link against that
18234: ** API as long as we don't call it win running Win95/98/ME. A call to
18235: ** this routine is used to determine if the host is Win95/98/ME or
18236: ** WinNT/2K/XP so that we will know whether or not we can safely call
18237: ** the LockFileEx() API.
18238: **
18239: ** mutexIsNT() is only used for the TryEnterCriticalSection() API call,
18240: ** which is only available if your application was compiled with
18241: ** _WIN32_WINNT defined to a value >= 0x0400. Currently, the only
18242: ** call to TryEnterCriticalSection() is #ifdef'ed out, so #ifdef
18243: ** this out as well.
18244: */
18245: #if 0
18246: #if SQLITE_OS_WINCE
18247: # define mutexIsNT() (1)
18248: #else
18249: static int mutexIsNT(void){
18250: static int osType = 0;
18251: if( osType==0 ){
18252: OSVERSIONINFO sInfo;
18253: sInfo.dwOSVersionInfoSize = sizeof(sInfo);
18254: GetVersionEx(&sInfo);
18255: osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
18256: }
18257: return osType==2;
18258: }
18259: #endif /* SQLITE_OS_WINCE */
18260: #endif
18261:
18262: #ifdef SQLITE_DEBUG
18263: /*
18264: ** The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
18265: ** intended for use only inside assert() statements.
18266: */
18267: static int winMutexHeld(sqlite3_mutex *p){
18268: return p->nRef!=0 && p->owner==GetCurrentThreadId();
18269: }
18270: static int winMutexNotheld2(sqlite3_mutex *p, DWORD tid){
18271: return p->nRef==0 || p->owner!=tid;
18272: }
18273: static int winMutexNotheld(sqlite3_mutex *p){
18274: DWORD tid = GetCurrentThreadId();
18275: return winMutexNotheld2(p, tid);
18276: }
18277: #endif
18278:
18279:
18280: /*
18281: ** Initialize and deinitialize the mutex subsystem.
18282: */
18283: static sqlite3_mutex winMutex_staticMutexes[6] = {
18284: SQLITE3_MUTEX_INITIALIZER,
18285: SQLITE3_MUTEX_INITIALIZER,
18286: SQLITE3_MUTEX_INITIALIZER,
18287: SQLITE3_MUTEX_INITIALIZER,
18288: SQLITE3_MUTEX_INITIALIZER,
18289: SQLITE3_MUTEX_INITIALIZER
18290: };
18291: static int winMutex_isInit = 0;
18292: /* As winMutexInit() and winMutexEnd() are called as part
18293: ** of the sqlite3_initialize and sqlite3_shutdown()
18294: ** processing, the "interlocked" magic is probably not
18295: ** strictly necessary.
18296: */
18297: static long winMutex_lock = 0;
18298:
18299: static int winMutexInit(void){
18300: /* The first to increment to 1 does actual initialization */
18301: if( InterlockedCompareExchange(&winMutex_lock, 1, 0)==0 ){
18302: int i;
18303: for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
18304: InitializeCriticalSection(&winMutex_staticMutexes[i].mutex);
18305: }
18306: winMutex_isInit = 1;
18307: }else{
18308: /* Someone else is in the process of initing the static mutexes */
18309: while( !winMutex_isInit ){
18310: Sleep(1);
18311: }
18312: }
18313: return SQLITE_OK;
18314: }
18315:
18316: static int winMutexEnd(void){
18317: /* The first to decrement to 0 does actual shutdown
18318: ** (which should be the last to shutdown.) */
18319: if( InterlockedCompareExchange(&winMutex_lock, 0, 1)==1 ){
18320: if( winMutex_isInit==1 ){
18321: int i;
18322: for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
18323: DeleteCriticalSection(&winMutex_staticMutexes[i].mutex);
18324: }
18325: winMutex_isInit = 0;
18326: }
18327: }
18328: return SQLITE_OK;
18329: }
18330:
18331: /*
18332: ** The sqlite3_mutex_alloc() routine allocates a new
18333: ** mutex and returns a pointer to it. If it returns NULL
18334: ** that means that a mutex could not be allocated. SQLite
18335: ** will unwind its stack and return an error. The argument
18336: ** to sqlite3_mutex_alloc() is one of these integer constants:
18337: **
18338: ** <ul>
18339: ** <li> SQLITE_MUTEX_FAST
18340: ** <li> SQLITE_MUTEX_RECURSIVE
18341: ** <li> SQLITE_MUTEX_STATIC_MASTER
18342: ** <li> SQLITE_MUTEX_STATIC_MEM
18343: ** <li> SQLITE_MUTEX_STATIC_MEM2
18344: ** <li> SQLITE_MUTEX_STATIC_PRNG
18345: ** <li> SQLITE_MUTEX_STATIC_LRU
18346: ** <li> SQLITE_MUTEX_STATIC_PMEM
18347: ** </ul>
18348: **
18349: ** The first two constants cause sqlite3_mutex_alloc() to create
18350: ** a new mutex. The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
18351: ** is used but not necessarily so when SQLITE_MUTEX_FAST is used.
18352: ** The mutex implementation does not need to make a distinction
18353: ** between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
18354: ** not want to. But SQLite will only request a recursive mutex in
18355: ** cases where it really needs one. If a faster non-recursive mutex
18356: ** implementation is available on the host platform, the mutex subsystem
18357: ** might return such a mutex in response to SQLITE_MUTEX_FAST.
18358: **
18359: ** The other allowed parameters to sqlite3_mutex_alloc() each return
18360: ** a pointer to a static preexisting mutex. Six static mutexes are
18361: ** used by the current version of SQLite. Future versions of SQLite
18362: ** may add additional static mutexes. Static mutexes are for internal
18363: ** use by SQLite only. Applications that use SQLite mutexes should
18364: ** use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
18365: ** SQLITE_MUTEX_RECURSIVE.
18366: **
18367: ** Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
18368: ** or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
18369: ** returns a different mutex on every call. But for the static
18370: ** mutex types, the same mutex is returned on every call that has
18371: ** the same type number.
18372: */
18373: static sqlite3_mutex *winMutexAlloc(int iType){
18374: sqlite3_mutex *p;
18375:
18376: switch( iType ){
18377: case SQLITE_MUTEX_FAST:
18378: case SQLITE_MUTEX_RECURSIVE: {
18379: p = sqlite3MallocZero( sizeof(*p) );
18380: if( p ){
18381: #ifdef SQLITE_DEBUG
18382: p->id = iType;
18383: #endif
18384: InitializeCriticalSection(&p->mutex);
18385: }
18386: break;
18387: }
18388: default: {
18389: assert( winMutex_isInit==1 );
18390: assert( iType-2 >= 0 );
18391: assert( iType-2 < ArraySize(winMutex_staticMutexes) );
18392: p = &winMutex_staticMutexes[iType-2];
18393: #ifdef SQLITE_DEBUG
18394: p->id = iType;
18395: #endif
18396: break;
18397: }
18398: }
18399: return p;
18400: }
18401:
18402:
18403: /*
18404: ** This routine deallocates a previously
18405: ** allocated mutex. SQLite is careful to deallocate every
18406: ** mutex that it allocates.
18407: */
18408: static void winMutexFree(sqlite3_mutex *p){
18409: assert( p );
18410: assert( p->nRef==0 && p->owner==0 );
18411: assert( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE );
18412: DeleteCriticalSection(&p->mutex);
18413: sqlite3_free(p);
18414: }
18415:
18416: /*
18417: ** The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
18418: ** to enter a mutex. If another thread is already within the mutex,
18419: ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
18420: ** SQLITE_BUSY. The sqlite3_mutex_try() interface returns SQLITE_OK
18421: ** upon successful entry. Mutexes created using SQLITE_MUTEX_RECURSIVE can
18422: ** be entered multiple times by the same thread. In such cases the,
18423: ** mutex must be exited an equal number of times before another thread
18424: ** can enter. If the same thread tries to enter any other kind of mutex
18425: ** more than once, the behavior is undefined.
18426: */
18427: static void winMutexEnter(sqlite3_mutex *p){
18428: #ifdef SQLITE_DEBUG
18429: DWORD tid = GetCurrentThreadId();
18430: assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
18431: #endif
18432: EnterCriticalSection(&p->mutex);
18433: #ifdef SQLITE_DEBUG
18434: assert( p->nRef>0 || p->owner==0 );
18435: p->owner = tid;
18436: p->nRef++;
18437: if( p->trace ){
18438: printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
18439: }
18440: #endif
18441: }
18442: static int winMutexTry(sqlite3_mutex *p){
18443: #ifndef NDEBUG
18444: DWORD tid = GetCurrentThreadId();
18445: #endif
18446: int rc = SQLITE_BUSY;
18447: assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
18448: /*
18449: ** The sqlite3_mutex_try() routine is very rarely used, and when it
18450: ** is used it is merely an optimization. So it is OK for it to always
18451: ** fail.
18452: **
18453: ** The TryEnterCriticalSection() interface is only available on WinNT.
18454: ** And some windows compilers complain if you try to use it without
18455: ** first doing some #defines that prevent SQLite from building on Win98.
18456: ** For that reason, we will omit this optimization for now. See
18457: ** ticket #2685.
18458: */
18459: #if 0
18460: if( mutexIsNT() && TryEnterCriticalSection(&p->mutex) ){
18461: p->owner = tid;
18462: p->nRef++;
18463: rc = SQLITE_OK;
18464: }
18465: #else
18466: UNUSED_PARAMETER(p);
18467: #endif
18468: #ifdef SQLITE_DEBUG
18469: if( rc==SQLITE_OK && p->trace ){
18470: printf("try mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
18471: }
18472: #endif
18473: return rc;
18474: }
18475:
18476: /*
18477: ** The sqlite3_mutex_leave() routine exits a mutex that was
18478: ** previously entered by the same thread. The behavior
18479: ** is undefined if the mutex is not currently entered or
18480: ** is not currently allocated. SQLite will never do either.
18481: */
18482: static void winMutexLeave(sqlite3_mutex *p){
18483: #ifndef NDEBUG
18484: DWORD tid = GetCurrentThreadId();
18485: assert( p->nRef>0 );
18486: assert( p->owner==tid );
18487: p->nRef--;
18488: if( p->nRef==0 ) p->owner = 0;
18489: assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
18490: #endif
18491: LeaveCriticalSection(&p->mutex);
18492: #ifdef SQLITE_DEBUG
18493: if( p->trace ){
18494: printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
18495: }
18496: #endif
18497: }
18498:
18499: SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
18500: static const sqlite3_mutex_methods sMutex = {
18501: winMutexInit,
18502: winMutexEnd,
18503: winMutexAlloc,
18504: winMutexFree,
18505: winMutexEnter,
18506: winMutexTry,
18507: winMutexLeave,
18508: #ifdef SQLITE_DEBUG
18509: winMutexHeld,
18510: winMutexNotheld
18511: #else
18512: 0,
18513: 0
18514: #endif
18515: };
18516:
18517: return &sMutex;
18518: }
18519: #endif /* SQLITE_MUTEX_W32 */
18520:
18521: /************** End of mutex_w32.c *******************************************/
18522: /************** Begin file malloc.c ******************************************/
18523: /*
18524: ** 2001 September 15
18525: **
18526: ** The author disclaims copyright to this source code. In place of
18527: ** a legal notice, here is a blessing:
18528: **
18529: ** May you do good and not evil.
18530: ** May you find forgiveness for yourself and forgive others.
18531: ** May you share freely, never taking more than you give.
18532: **
18533: *************************************************************************
18534: **
18535: ** Memory allocation functions used throughout sqlite.
18536: */
18537: /* #include <stdarg.h> */
18538:
18539: /*
18540: ** Attempt to release up to n bytes of non-essential memory currently
18541: ** held by SQLite. An example of non-essential memory is memory used to
18542: ** cache database pages that are not currently in use.
18543: */
18544: SQLITE_API int sqlite3_release_memory(int n){
18545: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
18546: return sqlite3PcacheReleaseMemory(n);
18547: #else
18548: /* IMPLEMENTATION-OF: R-34391-24921 The sqlite3_release_memory() routine
18549: ** is a no-op returning zero if SQLite is not compiled with
18550: ** SQLITE_ENABLE_MEMORY_MANAGEMENT. */
18551: UNUSED_PARAMETER(n);
18552: return 0;
18553: #endif
18554: }
18555:
18556: /*
18557: ** An instance of the following object records the location of
18558: ** each unused scratch buffer.
18559: */
18560: typedef struct ScratchFreeslot {
18561: struct ScratchFreeslot *pNext; /* Next unused scratch buffer */
18562: } ScratchFreeslot;
18563:
18564: /*
18565: ** State information local to the memory allocation subsystem.
18566: */
18567: static SQLITE_WSD struct Mem0Global {
18568: sqlite3_mutex *mutex; /* Mutex to serialize access */
18569:
18570: /*
18571: ** The alarm callback and its arguments. The mem0.mutex lock will
18572: ** be held while the callback is running. Recursive calls into
18573: ** the memory subsystem are allowed, but no new callbacks will be
18574: ** issued.
18575: */
18576: sqlite3_int64 alarmThreshold;
18577: void (*alarmCallback)(void*, sqlite3_int64,int);
18578: void *alarmArg;
18579:
18580: /*
18581: ** Pointers to the end of sqlite3GlobalConfig.pScratch memory
18582: ** (so that a range test can be used to determine if an allocation
18583: ** being freed came from pScratch) and a pointer to the list of
18584: ** unused scratch allocations.
18585: */
18586: void *pScratchEnd;
18587: ScratchFreeslot *pScratchFree;
18588: u32 nScratchFree;
18589:
18590: /*
18591: ** True if heap is nearly "full" where "full" is defined by the
18592: ** sqlite3_soft_heap_limit() setting.
18593: */
18594: int nearlyFull;
18595: } mem0 = { 0, 0, 0, 0, 0, 0, 0, 0 };
18596:
18597: #define mem0 GLOBAL(struct Mem0Global, mem0)
18598:
18599: /*
18600: ** This routine runs when the memory allocator sees that the
18601: ** total memory allocation is about to exceed the soft heap
18602: ** limit.
18603: */
18604: static void softHeapLimitEnforcer(
18605: void *NotUsed,
18606: sqlite3_int64 NotUsed2,
18607: int allocSize
18608: ){
18609: UNUSED_PARAMETER2(NotUsed, NotUsed2);
18610: sqlite3_release_memory(allocSize);
18611: }
18612:
18613: /*
18614: ** Change the alarm callback
18615: */
18616: static int sqlite3MemoryAlarm(
18617: void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
18618: void *pArg,
18619: sqlite3_int64 iThreshold
18620: ){
18621: int nUsed;
18622: sqlite3_mutex_enter(mem0.mutex);
18623: mem0.alarmCallback = xCallback;
18624: mem0.alarmArg = pArg;
18625: mem0.alarmThreshold = iThreshold;
18626: nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
18627: mem0.nearlyFull = (iThreshold>0 && iThreshold<=nUsed);
18628: sqlite3_mutex_leave(mem0.mutex);
18629: return SQLITE_OK;
18630: }
18631:
18632: #ifndef SQLITE_OMIT_DEPRECATED
18633: /*
18634: ** Deprecated external interface. Internal/core SQLite code
18635: ** should call sqlite3MemoryAlarm.
18636: */
18637: SQLITE_API int sqlite3_memory_alarm(
18638: void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
18639: void *pArg,
18640: sqlite3_int64 iThreshold
18641: ){
18642: return sqlite3MemoryAlarm(xCallback, pArg, iThreshold);
18643: }
18644: #endif
18645:
18646: /*
18647: ** Set the soft heap-size limit for the library. Passing a zero or
18648: ** negative value indicates no limit.
18649: */
18650: SQLITE_API sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 n){
18651: sqlite3_int64 priorLimit;
18652: sqlite3_int64 excess;
18653: #ifndef SQLITE_OMIT_AUTOINIT
18654: int rc = sqlite3_initialize();
18655: if( rc ) return -1;
18656: #endif
18657: sqlite3_mutex_enter(mem0.mutex);
18658: priorLimit = mem0.alarmThreshold;
18659: sqlite3_mutex_leave(mem0.mutex);
18660: if( n<0 ) return priorLimit;
18661: if( n>0 ){
18662: sqlite3MemoryAlarm(softHeapLimitEnforcer, 0, n);
18663: }else{
18664: sqlite3MemoryAlarm(0, 0, 0);
18665: }
18666: excess = sqlite3_memory_used() - n;
18667: if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
18668: return priorLimit;
18669: }
18670: SQLITE_API void sqlite3_soft_heap_limit(int n){
18671: if( n<0 ) n = 0;
18672: sqlite3_soft_heap_limit64(n);
18673: }
18674:
18675: /*
18676: ** Initialize the memory allocation subsystem.
18677: */
18678: SQLITE_PRIVATE int sqlite3MallocInit(void){
18679: if( sqlite3GlobalConfig.m.xMalloc==0 ){
18680: sqlite3MemSetDefault();
18681: }
18682: memset(&mem0, 0, sizeof(mem0));
18683: if( sqlite3GlobalConfig.bCoreMutex ){
18684: mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
18685: }
18686: if( sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch>=100
18687: && sqlite3GlobalConfig.nScratch>0 ){
18688: int i, n, sz;
18689: ScratchFreeslot *pSlot;
18690: sz = ROUNDDOWN8(sqlite3GlobalConfig.szScratch);
18691: sqlite3GlobalConfig.szScratch = sz;
18692: pSlot = (ScratchFreeslot*)sqlite3GlobalConfig.pScratch;
18693: n = sqlite3GlobalConfig.nScratch;
18694: mem0.pScratchFree = pSlot;
18695: mem0.nScratchFree = n;
18696: for(i=0; i<n-1; i++){
18697: pSlot->pNext = (ScratchFreeslot*)(sz+(char*)pSlot);
18698: pSlot = pSlot->pNext;
18699: }
18700: pSlot->pNext = 0;
18701: mem0.pScratchEnd = (void*)&pSlot[1];
18702: }else{
18703: mem0.pScratchEnd = 0;
18704: sqlite3GlobalConfig.pScratch = 0;
18705: sqlite3GlobalConfig.szScratch = 0;
18706: sqlite3GlobalConfig.nScratch = 0;
18707: }
18708: if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512
18709: || sqlite3GlobalConfig.nPage<1 ){
18710: sqlite3GlobalConfig.pPage = 0;
18711: sqlite3GlobalConfig.szPage = 0;
18712: sqlite3GlobalConfig.nPage = 0;
18713: }
18714: return sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
18715: }
18716:
18717: /*
18718: ** Return true if the heap is currently under memory pressure - in other
18719: ** words if the amount of heap used is close to the limit set by
18720: ** sqlite3_soft_heap_limit().
18721: */
18722: SQLITE_PRIVATE int sqlite3HeapNearlyFull(void){
18723: return mem0.nearlyFull;
18724: }
18725:
18726: /*
18727: ** Deinitialize the memory allocation subsystem.
18728: */
18729: SQLITE_PRIVATE void sqlite3MallocEnd(void){
18730: if( sqlite3GlobalConfig.m.xShutdown ){
18731: sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
18732: }
18733: memset(&mem0, 0, sizeof(mem0));
18734: }
18735:
18736: /*
18737: ** Return the amount of memory currently checked out.
18738: */
18739: SQLITE_API sqlite3_int64 sqlite3_memory_used(void){
18740: int n, mx;
18741: sqlite3_int64 res;
18742: sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, 0);
18743: res = (sqlite3_int64)n; /* Work around bug in Borland C. Ticket #3216 */
18744: return res;
18745: }
18746:
18747: /*
18748: ** Return the maximum amount of memory that has ever been
18749: ** checked out since either the beginning of this process
18750: ** or since the most recent reset.
18751: */
18752: SQLITE_API sqlite3_int64 sqlite3_memory_highwater(int resetFlag){
18753: int n, mx;
18754: sqlite3_int64 res;
18755: sqlite3_status(SQLITE_STATUS_MEMORY_USED, &n, &mx, resetFlag);
18756: res = (sqlite3_int64)mx; /* Work around bug in Borland C. Ticket #3216 */
18757: return res;
18758: }
18759:
18760: /*
18761: ** Trigger the alarm
18762: */
18763: static void sqlite3MallocAlarm(int nByte){
18764: void (*xCallback)(void*,sqlite3_int64,int);
18765: sqlite3_int64 nowUsed;
18766: void *pArg;
18767: if( mem0.alarmCallback==0 ) return;
18768: xCallback = mem0.alarmCallback;
18769: nowUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
18770: pArg = mem0.alarmArg;
18771: mem0.alarmCallback = 0;
18772: sqlite3_mutex_leave(mem0.mutex);
18773: xCallback(pArg, nowUsed, nByte);
18774: sqlite3_mutex_enter(mem0.mutex);
18775: mem0.alarmCallback = xCallback;
18776: mem0.alarmArg = pArg;
18777: }
18778:
18779: /*
18780: ** Do a memory allocation with statistics and alarms. Assume the
18781: ** lock is already held.
18782: */
18783: static int mallocWithAlarm(int n, void **pp){
18784: int nFull;
18785: void *p;
18786: assert( sqlite3_mutex_held(mem0.mutex) );
18787: nFull = sqlite3GlobalConfig.m.xRoundup(n);
18788: sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, n);
18789: if( mem0.alarmCallback!=0 ){
18790: int nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
18791: if( nUsed >= mem0.alarmThreshold - nFull ){
18792: mem0.nearlyFull = 1;
18793: sqlite3MallocAlarm(nFull);
18794: }else{
18795: mem0.nearlyFull = 0;
18796: }
18797: }
18798: p = sqlite3GlobalConfig.m.xMalloc(nFull);
18799: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
18800: if( p==0 && mem0.alarmCallback ){
18801: sqlite3MallocAlarm(nFull);
18802: p = sqlite3GlobalConfig.m.xMalloc(nFull);
18803: }
18804: #endif
18805: if( p ){
18806: nFull = sqlite3MallocSize(p);
18807: sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nFull);
18808: sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, 1);
18809: }
18810: *pp = p;
18811: return nFull;
18812: }
18813:
18814: /*
18815: ** Allocate memory. This routine is like sqlite3_malloc() except that it
18816: ** assumes the memory subsystem has already been initialized.
18817: */
18818: SQLITE_PRIVATE void *sqlite3Malloc(int n){
18819: void *p;
18820: if( n<=0 /* IMP: R-65312-04917 */
18821: || n>=0x7fffff00
18822: ){
18823: /* A memory allocation of a number of bytes which is near the maximum
18824: ** signed integer value might cause an integer overflow inside of the
18825: ** xMalloc(). Hence we limit the maximum size to 0x7fffff00, giving
18826: ** 255 bytes of overhead. SQLite itself will never use anything near
18827: ** this amount. The only way to reach the limit is with sqlite3_malloc() */
18828: p = 0;
18829: }else if( sqlite3GlobalConfig.bMemstat ){
18830: sqlite3_mutex_enter(mem0.mutex);
18831: mallocWithAlarm(n, &p);
18832: sqlite3_mutex_leave(mem0.mutex);
18833: }else{
18834: p = sqlite3GlobalConfig.m.xMalloc(n);
18835: }
18836: assert( EIGHT_BYTE_ALIGNMENT(p) ); /* IMP: R-04675-44850 */
18837: return p;
18838: }
18839:
18840: /*
18841: ** This version of the memory allocation is for use by the application.
18842: ** First make sure the memory subsystem is initialized, then do the
18843: ** allocation.
18844: */
18845: SQLITE_API void *sqlite3_malloc(int n){
18846: #ifndef SQLITE_OMIT_AUTOINIT
18847: if( sqlite3_initialize() ) return 0;
18848: #endif
18849: return sqlite3Malloc(n);
18850: }
18851:
18852: /*
18853: ** Each thread may only have a single outstanding allocation from
18854: ** xScratchMalloc(). We verify this constraint in the single-threaded
18855: ** case by setting scratchAllocOut to 1 when an allocation
18856: ** is outstanding clearing it when the allocation is freed.
18857: */
18858: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
18859: static int scratchAllocOut = 0;
18860: #endif
18861:
18862:
18863: /*
18864: ** Allocate memory that is to be used and released right away.
18865: ** This routine is similar to alloca() in that it is not intended
18866: ** for situations where the memory might be held long-term. This
18867: ** routine is intended to get memory to old large transient data
18868: ** structures that would not normally fit on the stack of an
18869: ** embedded processor.
18870: */
18871: SQLITE_PRIVATE void *sqlite3ScratchMalloc(int n){
18872: void *p;
18873: assert( n>0 );
18874:
18875: sqlite3_mutex_enter(mem0.mutex);
18876: if( mem0.nScratchFree && sqlite3GlobalConfig.szScratch>=n ){
18877: p = mem0.pScratchFree;
18878: mem0.pScratchFree = mem0.pScratchFree->pNext;
18879: mem0.nScratchFree--;
18880: sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, 1);
18881: sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
18882: sqlite3_mutex_leave(mem0.mutex);
18883: }else{
18884: if( sqlite3GlobalConfig.bMemstat ){
18885: sqlite3StatusSet(SQLITE_STATUS_SCRATCH_SIZE, n);
18886: n = mallocWithAlarm(n, &p);
18887: if( p ) sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, n);
18888: sqlite3_mutex_leave(mem0.mutex);
18889: }else{
18890: sqlite3_mutex_leave(mem0.mutex);
18891: p = sqlite3GlobalConfig.m.xMalloc(n);
18892: }
18893: sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);
18894: }
18895: assert( sqlite3_mutex_notheld(mem0.mutex) );
18896:
18897:
18898: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
18899: /* Verify that no more than two scratch allocations per thread
18900: ** are outstanding at one time. (This is only checked in the
18901: ** single-threaded case since checking in the multi-threaded case
18902: ** would be much more complicated.) */
18903: assert( scratchAllocOut<=1 );
18904: if( p ) scratchAllocOut++;
18905: #endif
18906:
18907: return p;
18908: }
18909: SQLITE_PRIVATE void sqlite3ScratchFree(void *p){
18910: if( p ){
18911:
18912: #if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
18913: /* Verify that no more than two scratch allocation per thread
18914: ** is outstanding at one time. (This is only checked in the
18915: ** single-threaded case since checking in the multi-threaded case
18916: ** would be much more complicated.) */
18917: assert( scratchAllocOut>=1 && scratchAllocOut<=2 );
18918: scratchAllocOut--;
18919: #endif
18920:
18921: if( p>=sqlite3GlobalConfig.pScratch && p<mem0.pScratchEnd ){
18922: /* Release memory from the SQLITE_CONFIG_SCRATCH allocation */
18923: ScratchFreeslot *pSlot;
18924: pSlot = (ScratchFreeslot*)p;
18925: sqlite3_mutex_enter(mem0.mutex);
18926: pSlot->pNext = mem0.pScratchFree;
18927: mem0.pScratchFree = pSlot;
18928: mem0.nScratchFree++;
18929: assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
18930: sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_USED, -1);
18931: sqlite3_mutex_leave(mem0.mutex);
18932: }else{
18933: /* Release memory back to the heap */
18934: assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) );
18935: assert( sqlite3MemdebugNoType(p, ~MEMTYPE_SCRATCH) );
18936: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
18937: if( sqlite3GlobalConfig.bMemstat ){
18938: int iSize = sqlite3MallocSize(p);
18939: sqlite3_mutex_enter(mem0.mutex);
18940: sqlite3StatusAdd(SQLITE_STATUS_SCRATCH_OVERFLOW, -iSize);
18941: sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -iSize);
18942: sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
18943: sqlite3GlobalConfig.m.xFree(p);
18944: sqlite3_mutex_leave(mem0.mutex);
18945: }else{
18946: sqlite3GlobalConfig.m.xFree(p);
18947: }
18948: }
18949: }
18950: }
18951:
18952: /*
18953: ** TRUE if p is a lookaside memory allocation from db
18954: */
18955: #ifndef SQLITE_OMIT_LOOKASIDE
18956: static int isLookaside(sqlite3 *db, void *p){
18957: return p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
18958: }
18959: #else
18960: #define isLookaside(A,B) 0
18961: #endif
18962:
18963: /*
18964: ** Return the size of a memory allocation previously obtained from
18965: ** sqlite3Malloc() or sqlite3_malloc().
18966: */
18967: SQLITE_PRIVATE int sqlite3MallocSize(void *p){
18968: assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
18969: assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
18970: return sqlite3GlobalConfig.m.xSize(p);
18971: }
18972: SQLITE_PRIVATE int sqlite3DbMallocSize(sqlite3 *db, void *p){
18973: assert( db==0 || sqlite3_mutex_held(db->mutex) );
18974: if( db && isLookaside(db, p) ){
18975: return db->lookaside.sz;
18976: }else{
18977: assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
18978: assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
18979: assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
18980: return sqlite3GlobalConfig.m.xSize(p);
18981: }
18982: }
18983:
18984: /*
18985: ** Free memory previously obtained from sqlite3Malloc().
18986: */
18987: SQLITE_API void sqlite3_free(void *p){
18988: if( p==0 ) return; /* IMP: R-49053-54554 */
18989: assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
18990: assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
18991: if( sqlite3GlobalConfig.bMemstat ){
18992: sqlite3_mutex_enter(mem0.mutex);
18993: sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, -sqlite3MallocSize(p));
18994: sqlite3StatusAdd(SQLITE_STATUS_MALLOC_COUNT, -1);
18995: sqlite3GlobalConfig.m.xFree(p);
18996: sqlite3_mutex_leave(mem0.mutex);
18997: }else{
18998: sqlite3GlobalConfig.m.xFree(p);
18999: }
19000: }
19001:
19002: /*
19003: ** Free memory that might be associated with a particular database
19004: ** connection.
19005: */
19006: SQLITE_PRIVATE void sqlite3DbFree(sqlite3 *db, void *p){
19007: assert( db==0 || sqlite3_mutex_held(db->mutex) );
19008: if( db ){
19009: if( db->pnBytesFreed ){
19010: *db->pnBytesFreed += sqlite3DbMallocSize(db, p);
19011: return;
19012: }
19013: if( isLookaside(db, p) ){
19014: LookasideSlot *pBuf = (LookasideSlot*)p;
19015: pBuf->pNext = db->lookaside.pFree;
19016: db->lookaside.pFree = pBuf;
19017: db->lookaside.nOut--;
19018: return;
19019: }
19020: }
19021: assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
19022: assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
19023: assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
19024: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
19025: sqlite3_free(p);
19026: }
19027:
19028: /*
19029: ** Change the size of an existing memory allocation
19030: */
19031: SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, int nBytes){
19032: int nOld, nNew, nDiff;
19033: void *pNew;
19034: if( pOld==0 ){
19035: return sqlite3Malloc(nBytes); /* IMP: R-28354-25769 */
19036: }
19037: if( nBytes<=0 ){
19038: sqlite3_free(pOld); /* IMP: R-31593-10574 */
19039: return 0;
19040: }
19041: if( nBytes>=0x7fffff00 ){
19042: /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */
19043: return 0;
19044: }
19045: nOld = sqlite3MallocSize(pOld);
19046: /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second
19047: ** argument to xRealloc is always a value returned by a prior call to
19048: ** xRoundup. */
19049: nNew = sqlite3GlobalConfig.m.xRoundup(nBytes);
19050: if( nOld==nNew ){
19051: pNew = pOld;
19052: }else if( sqlite3GlobalConfig.bMemstat ){
19053: sqlite3_mutex_enter(mem0.mutex);
19054: sqlite3StatusSet(SQLITE_STATUS_MALLOC_SIZE, nBytes);
19055: nDiff = nNew - nOld;
19056: if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >=
19057: mem0.alarmThreshold-nDiff ){
19058: sqlite3MallocAlarm(nDiff);
19059: }
19060: assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
19061: assert( sqlite3MemdebugNoType(pOld, ~MEMTYPE_HEAP) );
19062: pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
19063: if( pNew==0 && mem0.alarmCallback ){
19064: sqlite3MallocAlarm(nBytes);
19065: pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
19066: }
19067: if( pNew ){
19068: nNew = sqlite3MallocSize(pNew);
19069: sqlite3StatusAdd(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
19070: }
19071: sqlite3_mutex_leave(mem0.mutex);
19072: }else{
19073: pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
19074: }
19075: assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-04675-44850 */
19076: return pNew;
19077: }
19078:
19079: /*
19080: ** The public interface to sqlite3Realloc. Make sure that the memory
19081: ** subsystem is initialized prior to invoking sqliteRealloc.
19082: */
19083: SQLITE_API void *sqlite3_realloc(void *pOld, int n){
19084: #ifndef SQLITE_OMIT_AUTOINIT
19085: if( sqlite3_initialize() ) return 0;
19086: #endif
19087: return sqlite3Realloc(pOld, n);
19088: }
19089:
19090:
19091: /*
19092: ** Allocate and zero memory.
19093: */
19094: SQLITE_PRIVATE void *sqlite3MallocZero(int n){
19095: void *p = sqlite3Malloc(n);
19096: if( p ){
19097: memset(p, 0, n);
19098: }
19099: return p;
19100: }
19101:
19102: /*
19103: ** Allocate and zero memory. If the allocation fails, make
19104: ** the mallocFailed flag in the connection pointer.
19105: */
19106: SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, int n){
19107: void *p = sqlite3DbMallocRaw(db, n);
19108: if( p ){
19109: memset(p, 0, n);
19110: }
19111: return p;
19112: }
19113:
19114: /*
19115: ** Allocate and zero memory. If the allocation fails, make
19116: ** the mallocFailed flag in the connection pointer.
19117: **
19118: ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
19119: ** failure on the same database connection) then always return 0.
19120: ** Hence for a particular database connection, once malloc starts
19121: ** failing, it fails consistently until mallocFailed is reset.
19122: ** This is an important assumption. There are many places in the
19123: ** code that do things like this:
19124: **
19125: ** int *a = (int*)sqlite3DbMallocRaw(db, 100);
19126: ** int *b = (int*)sqlite3DbMallocRaw(db, 200);
19127: ** if( b ) a[10] = 9;
19128: **
19129: ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
19130: ** that all prior mallocs (ex: "a") worked too.
19131: */
19132: SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, int n){
19133: void *p;
19134: assert( db==0 || sqlite3_mutex_held(db->mutex) );
19135: assert( db==0 || db->pnBytesFreed==0 );
19136: #ifndef SQLITE_OMIT_LOOKASIDE
19137: if( db ){
19138: LookasideSlot *pBuf;
19139: if( db->mallocFailed ){
19140: return 0;
19141: }
19142: if( db->lookaside.bEnabled ){
19143: if( n>db->lookaside.sz ){
19144: db->lookaside.anStat[1]++;
19145: }else if( (pBuf = db->lookaside.pFree)==0 ){
19146: db->lookaside.anStat[2]++;
19147: }else{
19148: db->lookaside.pFree = pBuf->pNext;
19149: db->lookaside.nOut++;
19150: db->lookaside.anStat[0]++;
19151: if( db->lookaside.nOut>db->lookaside.mxOut ){
19152: db->lookaside.mxOut = db->lookaside.nOut;
19153: }
19154: return (void*)pBuf;
19155: }
19156: }
19157: }
19158: #else
19159: if( db && db->mallocFailed ){
19160: return 0;
19161: }
19162: #endif
19163: p = sqlite3Malloc(n);
19164: if( !p && db ){
19165: db->mallocFailed = 1;
19166: }
19167: sqlite3MemdebugSetType(p, MEMTYPE_DB |
19168: ((db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
19169: return p;
19170: }
19171:
19172: /*
19173: ** Resize the block of memory pointed to by p to n bytes. If the
19174: ** resize fails, set the mallocFailed flag in the connection object.
19175: */
19176: SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, int n){
19177: void *pNew = 0;
19178: assert( db!=0 );
19179: assert( sqlite3_mutex_held(db->mutex) );
19180: if( db->mallocFailed==0 ){
19181: if( p==0 ){
19182: return sqlite3DbMallocRaw(db, n);
19183: }
19184: if( isLookaside(db, p) ){
19185: if( n<=db->lookaside.sz ){
19186: return p;
19187: }
19188: pNew = sqlite3DbMallocRaw(db, n);
19189: if( pNew ){
19190: memcpy(pNew, p, db->lookaside.sz);
19191: sqlite3DbFree(db, p);
19192: }
19193: }else{
19194: assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
19195: assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
19196: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
19197: pNew = sqlite3_realloc(p, n);
19198: if( !pNew ){
19199: sqlite3MemdebugSetType(p, MEMTYPE_DB|MEMTYPE_HEAP);
19200: db->mallocFailed = 1;
19201: }
19202: sqlite3MemdebugSetType(pNew, MEMTYPE_DB |
19203: (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
19204: }
19205: }
19206: return pNew;
19207: }
19208:
19209: /*
19210: ** Attempt to reallocate p. If the reallocation fails, then free p
19211: ** and set the mallocFailed flag in the database connection.
19212: */
19213: SQLITE_PRIVATE void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
19214: void *pNew;
19215: pNew = sqlite3DbRealloc(db, p, n);
19216: if( !pNew ){
19217: sqlite3DbFree(db, p);
19218: }
19219: return pNew;
19220: }
19221:
19222: /*
19223: ** Make a copy of a string in memory obtained from sqliteMalloc(). These
19224: ** functions call sqlite3MallocRaw() directly instead of sqliteMalloc(). This
19225: ** is because when memory debugging is turned on, these two functions are
19226: ** called via macros that record the current file and line number in the
19227: ** ThreadData structure.
19228: */
19229: SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){
19230: char *zNew;
19231: size_t n;
19232: if( z==0 ){
19233: return 0;
19234: }
19235: n = sqlite3Strlen30(z) + 1;
19236: assert( (n&0x7fffffff)==n );
19237: zNew = sqlite3DbMallocRaw(db, (int)n);
19238: if( zNew ){
19239: memcpy(zNew, z, n);
19240: }
19241: return zNew;
19242: }
19243: SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){
19244: char *zNew;
19245: if( z==0 ){
19246: return 0;
19247: }
19248: assert( (n&0x7fffffff)==n );
19249: zNew = sqlite3DbMallocRaw(db, n+1);
19250: if( zNew ){
19251: memcpy(zNew, z, n);
19252: zNew[n] = 0;
19253: }
19254: return zNew;
19255: }
19256:
19257: /*
19258: ** Create a string from the zFromat argument and the va_list that follows.
19259: ** Store the string in memory obtained from sqliteMalloc() and make *pz
19260: ** point to that string.
19261: */
19262: SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zFormat, ...){
19263: va_list ap;
19264: char *z;
19265:
19266: va_start(ap, zFormat);
19267: z = sqlite3VMPrintf(db, zFormat, ap);
19268: va_end(ap);
19269: sqlite3DbFree(db, *pz);
19270: *pz = z;
19271: }
19272:
19273:
19274: /*
19275: ** This function must be called before exiting any API function (i.e.
19276: ** returning control to the user) that has called sqlite3_malloc or
19277: ** sqlite3_realloc.
19278: **
19279: ** The returned value is normally a copy of the second argument to this
19280: ** function. However, if a malloc() failure has occurred since the previous
19281: ** invocation SQLITE_NOMEM is returned instead.
19282: **
19283: ** If the first argument, db, is not NULL and a malloc() error has occurred,
19284: ** then the connection error-code (the value returned by sqlite3_errcode())
19285: ** is set to SQLITE_NOMEM.
19286: */
19287: SQLITE_PRIVATE int sqlite3ApiExit(sqlite3* db, int rc){
19288: /* If the db handle is not NULL, then we must hold the connection handle
19289: ** mutex here. Otherwise the read (and possible write) of db->mallocFailed
19290: ** is unsafe, as is the call to sqlite3Error().
19291: */
19292: assert( !db || sqlite3_mutex_held(db->mutex) );
19293: if( db && (db->mallocFailed || rc==SQLITE_IOERR_NOMEM) ){
19294: sqlite3Error(db, SQLITE_NOMEM, 0);
19295: db->mallocFailed = 0;
19296: rc = SQLITE_NOMEM;
19297: }
19298: return rc & (db ? db->errMask : 0xff);
19299: }
19300:
19301: /************** End of malloc.c **********************************************/
19302: /************** Begin file printf.c ******************************************/
19303: /*
19304: ** The "printf" code that follows dates from the 1980's. It is in
19305: ** the public domain. The original comments are included here for
19306: ** completeness. They are very out-of-date but might be useful as
19307: ** an historical reference. Most of the "enhancements" have been backed
19308: ** out so that the functionality is now the same as standard printf().
19309: **
19310: **************************************************************************
19311: **
19312: ** This file contains code for a set of "printf"-like routines. These
19313: ** routines format strings much like the printf() from the standard C
19314: ** library, though the implementation here has enhancements to support
19315: ** SQLlite.
19316: */
19317:
19318: /*
19319: ** Conversion types fall into various categories as defined by the
19320: ** following enumeration.
19321: */
19322: #define etRADIX 1 /* Integer types. %d, %x, %o, and so forth */
19323: #define etFLOAT 2 /* Floating point. %f */
19324: #define etEXP 3 /* Exponentional notation. %e and %E */
19325: #define etGENERIC 4 /* Floating or exponential, depending on exponent. %g */
19326: #define etSIZE 5 /* Return number of characters processed so far. %n */
19327: #define etSTRING 6 /* Strings. %s */
19328: #define etDYNSTRING 7 /* Dynamically allocated strings. %z */
19329: #define etPERCENT 8 /* Percent symbol. %% */
19330: #define etCHARX 9 /* Characters. %c */
19331: /* The rest are extensions, not normally found in printf() */
19332: #define etSQLESCAPE 10 /* Strings with '\'' doubled. %q */
19333: #define etSQLESCAPE2 11 /* Strings with '\'' doubled and enclosed in '',
19334: NULL pointers replaced by SQL NULL. %Q */
19335: #define etTOKEN 12 /* a pointer to a Token structure */
19336: #define etSRCLIST 13 /* a pointer to a SrcList */
19337: #define etPOINTER 14 /* The %p conversion */
19338: #define etSQLESCAPE3 15 /* %w -> Strings with '\"' doubled */
19339: #define etORDINAL 16 /* %r -> 1st, 2nd, 3rd, 4th, etc. English only */
19340:
19341: #define etINVALID 0 /* Any unrecognized conversion type */
19342:
19343:
19344: /*
19345: ** An "etByte" is an 8-bit unsigned value.
19346: */
19347: typedef unsigned char etByte;
19348:
19349: /*
19350: ** Each builtin conversion character (ex: the 'd' in "%d") is described
19351: ** by an instance of the following structure
19352: */
19353: typedef struct et_info { /* Information about each format field */
19354: char fmttype; /* The format field code letter */
19355: etByte base; /* The base for radix conversion */
19356: etByte flags; /* One or more of FLAG_ constants below */
19357: etByte type; /* Conversion paradigm */
19358: etByte charset; /* Offset into aDigits[] of the digits string */
19359: etByte prefix; /* Offset into aPrefix[] of the prefix string */
19360: } et_info;
19361:
19362: /*
19363: ** Allowed values for et_info.flags
19364: */
19365: #define FLAG_SIGNED 1 /* True if the value to convert is signed */
19366: #define FLAG_INTERN 2 /* True if for internal use only */
19367: #define FLAG_STRING 4 /* Allow infinity precision */
19368:
19369:
19370: /*
19371: ** The following table is searched linearly, so it is good to put the
19372: ** most frequently used conversion types first.
19373: */
19374: static const char aDigits[] = "0123456789ABCDEF0123456789abcdef";
19375: static const char aPrefix[] = "-x0\000X0";
19376: static const et_info fmtinfo[] = {
19377: { 'd', 10, 1, etRADIX, 0, 0 },
19378: { 's', 0, 4, etSTRING, 0, 0 },
19379: { 'g', 0, 1, etGENERIC, 30, 0 },
19380: { 'z', 0, 4, etDYNSTRING, 0, 0 },
19381: { 'q', 0, 4, etSQLESCAPE, 0, 0 },
19382: { 'Q', 0, 4, etSQLESCAPE2, 0, 0 },
19383: { 'w', 0, 4, etSQLESCAPE3, 0, 0 },
19384: { 'c', 0, 0, etCHARX, 0, 0 },
19385: { 'o', 8, 0, etRADIX, 0, 2 },
19386: { 'u', 10, 0, etRADIX, 0, 0 },
19387: { 'x', 16, 0, etRADIX, 16, 1 },
19388: { 'X', 16, 0, etRADIX, 0, 4 },
19389: #ifndef SQLITE_OMIT_FLOATING_POINT
19390: { 'f', 0, 1, etFLOAT, 0, 0 },
19391: { 'e', 0, 1, etEXP, 30, 0 },
19392: { 'E', 0, 1, etEXP, 14, 0 },
19393: { 'G', 0, 1, etGENERIC, 14, 0 },
19394: #endif
19395: { 'i', 10, 1, etRADIX, 0, 0 },
19396: { 'n', 0, 0, etSIZE, 0, 0 },
19397: { '%', 0, 0, etPERCENT, 0, 0 },
19398: { 'p', 16, 0, etPOINTER, 0, 1 },
19399:
19400: /* All the rest have the FLAG_INTERN bit set and are thus for internal
19401: ** use only */
19402: { 'T', 0, 2, etTOKEN, 0, 0 },
19403: { 'S', 0, 2, etSRCLIST, 0, 0 },
19404: { 'r', 10, 3, etORDINAL, 0, 0 },
19405: };
19406:
19407: /*
19408: ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
19409: ** conversions will work.
19410: */
19411: #ifndef SQLITE_OMIT_FLOATING_POINT
19412: /*
19413: ** "*val" is a double such that 0.1 <= *val < 10.0
19414: ** Return the ascii code for the leading digit of *val, then
19415: ** multiply "*val" by 10.0 to renormalize.
19416: **
19417: ** Example:
19418: ** input: *val = 3.14159
19419: ** output: *val = 1.4159 function return = '3'
19420: **
19421: ** The counter *cnt is incremented each time. After counter exceeds
19422: ** 16 (the number of significant digits in a 64-bit float) '0' is
19423: ** always returned.
19424: */
19425: static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
19426: int digit;
19427: LONGDOUBLE_TYPE d;
19428: if( (*cnt)++ >= 16 ) return '0';
19429: digit = (int)*val;
19430: d = digit;
19431: digit += '0';
19432: *val = (*val - d)*10.0;
19433: return (char)digit;
19434: }
19435: #endif /* SQLITE_OMIT_FLOATING_POINT */
19436:
19437: /*
19438: ** Append N space characters to the given string buffer.
19439: */
19440: SQLITE_PRIVATE void sqlite3AppendSpace(StrAccum *pAccum, int N){
19441: static const char zSpaces[] = " ";
19442: while( N>=(int)sizeof(zSpaces)-1 ){
19443: sqlite3StrAccumAppend(pAccum, zSpaces, sizeof(zSpaces)-1);
19444: N -= sizeof(zSpaces)-1;
19445: }
19446: if( N>0 ){
19447: sqlite3StrAccumAppend(pAccum, zSpaces, N);
19448: }
19449: }
19450:
19451: /*
19452: ** On machines with a small stack size, you can redefine the
19453: ** SQLITE_PRINT_BUF_SIZE to be something smaller, if desired.
19454: */
19455: #ifndef SQLITE_PRINT_BUF_SIZE
19456: # define SQLITE_PRINT_BUF_SIZE 70
19457: #endif
19458: #define etBUFSIZE SQLITE_PRINT_BUF_SIZE /* Size of the output buffer */
19459:
19460: /*
19461: ** Render a string given by "fmt" into the StrAccum object.
19462: */
19463: SQLITE_PRIVATE void sqlite3VXPrintf(
19464: StrAccum *pAccum, /* Accumulate results here */
19465: int useExtended, /* Allow extended %-conversions */
19466: const char *fmt, /* Format string */
19467: va_list ap /* arguments */
19468: ){
19469: int c; /* Next character in the format string */
19470: char *bufpt; /* Pointer to the conversion buffer */
19471: int precision; /* Precision of the current field */
19472: int length; /* Length of the field */
19473: int idx; /* A general purpose loop counter */
19474: int width; /* Width of the current field */
19475: etByte flag_leftjustify; /* True if "-" flag is present */
19476: etByte flag_plussign; /* True if "+" flag is present */
19477: etByte flag_blanksign; /* True if " " flag is present */
19478: etByte flag_alternateform; /* True if "#" flag is present */
19479: etByte flag_altform2; /* True if "!" flag is present */
19480: etByte flag_zeropad; /* True if field width constant starts with zero */
19481: etByte flag_long; /* True if "l" flag is present */
19482: etByte flag_longlong; /* True if the "ll" flag is present */
19483: etByte done; /* Loop termination flag */
19484: etByte xtype = 0; /* Conversion paradigm */
19485: char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */
19486: sqlite_uint64 longvalue; /* Value for integer types */
19487: LONGDOUBLE_TYPE realvalue; /* Value for real types */
19488: const et_info *infop; /* Pointer to the appropriate info structure */
19489: char *zOut; /* Rendering buffer */
19490: int nOut; /* Size of the rendering buffer */
19491: char *zExtra; /* Malloced memory used by some conversion */
19492: #ifndef SQLITE_OMIT_FLOATING_POINT
19493: int exp, e2; /* exponent of real numbers */
19494: int nsd; /* Number of significant digits returned */
19495: double rounder; /* Used for rounding floating point values */
19496: etByte flag_dp; /* True if decimal point should be shown */
19497: etByte flag_rtz; /* True if trailing zeros should be removed */
19498: #endif
19499: char buf[etBUFSIZE]; /* Conversion buffer */
19500:
19501: bufpt = 0;
19502: for(; (c=(*fmt))!=0; ++fmt){
19503: if( c!='%' ){
19504: int amt;
19505: bufpt = (char *)fmt;
19506: amt = 1;
19507: while( (c=(*++fmt))!='%' && c!=0 ) amt++;
19508: sqlite3StrAccumAppend(pAccum, bufpt, amt);
19509: if( c==0 ) break;
19510: }
19511: if( (c=(*++fmt))==0 ){
19512: sqlite3StrAccumAppend(pAccum, "%", 1);
19513: break;
19514: }
19515: /* Find out what flags are present */
19516: flag_leftjustify = flag_plussign = flag_blanksign =
19517: flag_alternateform = flag_altform2 = flag_zeropad = 0;
19518: done = 0;
19519: do{
19520: switch( c ){
19521: case '-': flag_leftjustify = 1; break;
19522: case '+': flag_plussign = 1; break;
19523: case ' ': flag_blanksign = 1; break;
19524: case '#': flag_alternateform = 1; break;
19525: case '!': flag_altform2 = 1; break;
19526: case '0': flag_zeropad = 1; break;
19527: default: done = 1; break;
19528: }
19529: }while( !done && (c=(*++fmt))!=0 );
19530: /* Get the field width */
19531: width = 0;
19532: if( c=='*' ){
19533: width = va_arg(ap,int);
19534: if( width<0 ){
19535: flag_leftjustify = 1;
19536: width = -width;
19537: }
19538: c = *++fmt;
19539: }else{
19540: while( c>='0' && c<='9' ){
19541: width = width*10 + c - '0';
19542: c = *++fmt;
19543: }
19544: }
19545: /* Get the precision */
19546: if( c=='.' ){
19547: precision = 0;
19548: c = *++fmt;
19549: if( c=='*' ){
19550: precision = va_arg(ap,int);
19551: if( precision<0 ) precision = -precision;
19552: c = *++fmt;
19553: }else{
19554: while( c>='0' && c<='9' ){
19555: precision = precision*10 + c - '0';
19556: c = *++fmt;
19557: }
19558: }
19559: }else{
19560: precision = -1;
19561: }
19562: /* Get the conversion type modifier */
19563: if( c=='l' ){
19564: flag_long = 1;
19565: c = *++fmt;
19566: if( c=='l' ){
19567: flag_longlong = 1;
19568: c = *++fmt;
19569: }else{
19570: flag_longlong = 0;
19571: }
19572: }else{
19573: flag_long = flag_longlong = 0;
19574: }
19575: /* Fetch the info entry for the field */
19576: infop = &fmtinfo[0];
19577: xtype = etINVALID;
19578: for(idx=0; idx<ArraySize(fmtinfo); idx++){
19579: if( c==fmtinfo[idx].fmttype ){
19580: infop = &fmtinfo[idx];
19581: if( useExtended || (infop->flags & FLAG_INTERN)==0 ){
19582: xtype = infop->type;
19583: }else{
19584: return;
19585: }
19586: break;
19587: }
19588: }
19589: zExtra = 0;
19590:
19591: /*
19592: ** At this point, variables are initialized as follows:
19593: **
19594: ** flag_alternateform TRUE if a '#' is present.
19595: ** flag_altform2 TRUE if a '!' is present.
19596: ** flag_plussign TRUE if a '+' is present.
19597: ** flag_leftjustify TRUE if a '-' is present or if the
19598: ** field width was negative.
19599: ** flag_zeropad TRUE if the width began with 0.
19600: ** flag_long TRUE if the letter 'l' (ell) prefixed
19601: ** the conversion character.
19602: ** flag_longlong TRUE if the letter 'll' (ell ell) prefixed
19603: ** the conversion character.
19604: ** flag_blanksign TRUE if a ' ' is present.
19605: ** width The specified field width. This is
19606: ** always non-negative. Zero is the default.
19607: ** precision The specified precision. The default
19608: ** is -1.
19609: ** xtype The class of the conversion.
19610: ** infop Pointer to the appropriate info struct.
19611: */
19612: switch( xtype ){
19613: case etPOINTER:
19614: flag_longlong = sizeof(char*)==sizeof(i64);
19615: flag_long = sizeof(char*)==sizeof(long int);
19616: /* Fall through into the next case */
19617: case etORDINAL:
19618: case etRADIX:
19619: if( infop->flags & FLAG_SIGNED ){
19620: i64 v;
19621: if( flag_longlong ){
19622: v = va_arg(ap,i64);
19623: }else if( flag_long ){
19624: v = va_arg(ap,long int);
19625: }else{
19626: v = va_arg(ap,int);
19627: }
19628: if( v<0 ){
19629: if( v==SMALLEST_INT64 ){
19630: longvalue = ((u64)1)<<63;
19631: }else{
19632: longvalue = -v;
19633: }
19634: prefix = '-';
19635: }else{
19636: longvalue = v;
19637: if( flag_plussign ) prefix = '+';
19638: else if( flag_blanksign ) prefix = ' ';
19639: else prefix = 0;
19640: }
19641: }else{
19642: if( flag_longlong ){
19643: longvalue = va_arg(ap,u64);
19644: }else if( flag_long ){
19645: longvalue = va_arg(ap,unsigned long int);
19646: }else{
19647: longvalue = va_arg(ap,unsigned int);
19648: }
19649: prefix = 0;
19650: }
19651: if( longvalue==0 ) flag_alternateform = 0;
19652: if( flag_zeropad && precision<width-(prefix!=0) ){
19653: precision = width-(prefix!=0);
19654: }
19655: if( precision<etBUFSIZE-10 ){
19656: nOut = etBUFSIZE;
19657: zOut = buf;
19658: }else{
19659: nOut = precision + 10;
19660: zOut = zExtra = sqlite3Malloc( nOut );
19661: if( zOut==0 ){
19662: pAccum->mallocFailed = 1;
19663: return;
19664: }
19665: }
19666: bufpt = &zOut[nOut-1];
19667: if( xtype==etORDINAL ){
19668: static const char zOrd[] = "thstndrd";
19669: int x = (int)(longvalue % 10);
19670: if( x>=4 || (longvalue/10)%10==1 ){
19671: x = 0;
19672: }
19673: *(--bufpt) = zOrd[x*2+1];
19674: *(--bufpt) = zOrd[x*2];
19675: }
19676: {
19677: register const char *cset; /* Use registers for speed */
19678: register int base;
19679: cset = &aDigits[infop->charset];
19680: base = infop->base;
19681: do{ /* Convert to ascii */
19682: *(--bufpt) = cset[longvalue%base];
19683: longvalue = longvalue/base;
19684: }while( longvalue>0 );
19685: }
19686: length = (int)(&zOut[nOut-1]-bufpt);
19687: for(idx=precision-length; idx>0; idx--){
19688: *(--bufpt) = '0'; /* Zero pad */
19689: }
19690: if( prefix ) *(--bufpt) = prefix; /* Add sign */
19691: if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */
19692: const char *pre;
19693: char x;
19694: pre = &aPrefix[infop->prefix];
19695: for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
19696: }
19697: length = (int)(&zOut[nOut-1]-bufpt);
19698: break;
19699: case etFLOAT:
19700: case etEXP:
19701: case etGENERIC:
19702: realvalue = va_arg(ap,double);
19703: #ifdef SQLITE_OMIT_FLOATING_POINT
19704: length = 0;
19705: #else
19706: if( precision<0 ) precision = 6; /* Set default precision */
19707: if( realvalue<0.0 ){
19708: realvalue = -realvalue;
19709: prefix = '-';
19710: }else{
19711: if( flag_plussign ) prefix = '+';
19712: else if( flag_blanksign ) prefix = ' ';
19713: else prefix = 0;
19714: }
19715: if( xtype==etGENERIC && precision>0 ) precision--;
19716: #if 0
19717: /* Rounding works like BSD when the constant 0.4999 is used. Wierd! */
19718: for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1);
19719: #else
19720: /* It makes more sense to use 0.5 */
19721: for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){}
19722: #endif
19723: if( xtype==etFLOAT ) realvalue += rounder;
19724: /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
19725: exp = 0;
19726: if( sqlite3IsNaN((double)realvalue) ){
19727: bufpt = "NaN";
19728: length = 3;
19729: break;
19730: }
19731: if( realvalue>0.0 ){
19732: while( realvalue>=1e32 && exp<=350 ){ realvalue *= 1e-32; exp+=32; }
19733: while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; }
19734: while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; }
19735: while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
19736: while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
19737: if( exp>350 ){
19738: if( prefix=='-' ){
19739: bufpt = "-Inf";
19740: }else if( prefix=='+' ){
19741: bufpt = "+Inf";
19742: }else{
19743: bufpt = "Inf";
19744: }
19745: length = sqlite3Strlen30(bufpt);
19746: break;
19747: }
19748: }
19749: bufpt = buf;
19750: /*
19751: ** If the field type is etGENERIC, then convert to either etEXP
19752: ** or etFLOAT, as appropriate.
19753: */
19754: if( xtype!=etFLOAT ){
19755: realvalue += rounder;
19756: if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
19757: }
19758: if( xtype==etGENERIC ){
19759: flag_rtz = !flag_alternateform;
19760: if( exp<-4 || exp>precision ){
19761: xtype = etEXP;
19762: }else{
19763: precision = precision - exp;
19764: xtype = etFLOAT;
19765: }
19766: }else{
19767: flag_rtz = 0;
19768: }
19769: if( xtype==etEXP ){
19770: e2 = 0;
19771: }else{
19772: e2 = exp;
19773: }
19774: if( e2+precision+width > etBUFSIZE - 15 ){
19775: bufpt = zExtra = sqlite3Malloc( e2+precision+width+15 );
19776: if( bufpt==0 ){
19777: pAccum->mallocFailed = 1;
19778: return;
19779: }
19780: }
19781: zOut = bufpt;
19782: nsd = 0;
19783: flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
19784: /* The sign in front of the number */
19785: if( prefix ){
19786: *(bufpt++) = prefix;
19787: }
19788: /* Digits prior to the decimal point */
19789: if( e2<0 ){
19790: *(bufpt++) = '0';
19791: }else{
19792: for(; e2>=0; e2--){
19793: *(bufpt++) = et_getdigit(&realvalue,&nsd);
19794: }
19795: }
19796: /* The decimal point */
19797: if( flag_dp ){
19798: *(bufpt++) = '.';
19799: }
19800: /* "0" digits after the decimal point but before the first
19801: ** significant digit of the number */
19802: for(e2++; e2<0; precision--, e2++){
19803: assert( precision>0 );
19804: *(bufpt++) = '0';
19805: }
19806: /* Significant digits after the decimal point */
19807: while( (precision--)>0 ){
19808: *(bufpt++) = et_getdigit(&realvalue,&nsd);
19809: }
19810: /* Remove trailing zeros and the "." if no digits follow the "." */
19811: if( flag_rtz && flag_dp ){
19812: while( bufpt[-1]=='0' ) *(--bufpt) = 0;
19813: assert( bufpt>zOut );
19814: if( bufpt[-1]=='.' ){
19815: if( flag_altform2 ){
19816: *(bufpt++) = '0';
19817: }else{
19818: *(--bufpt) = 0;
19819: }
19820: }
19821: }
19822: /* Add the "eNNN" suffix */
19823: if( xtype==etEXP ){
19824: *(bufpt++) = aDigits[infop->charset];
19825: if( exp<0 ){
19826: *(bufpt++) = '-'; exp = -exp;
19827: }else{
19828: *(bufpt++) = '+';
19829: }
19830: if( exp>=100 ){
19831: *(bufpt++) = (char)((exp/100)+'0'); /* 100's digit */
19832: exp %= 100;
19833: }
19834: *(bufpt++) = (char)(exp/10+'0'); /* 10's digit */
19835: *(bufpt++) = (char)(exp%10+'0'); /* 1's digit */
19836: }
19837: *bufpt = 0;
19838:
19839: /* The converted number is in buf[] and zero terminated. Output it.
19840: ** Note that the number is in the usual order, not reversed as with
19841: ** integer conversions. */
19842: length = (int)(bufpt-zOut);
19843: bufpt = zOut;
19844:
19845: /* Special case: Add leading zeros if the flag_zeropad flag is
19846: ** set and we are not left justified */
19847: if( flag_zeropad && !flag_leftjustify && length < width){
19848: int i;
19849: int nPad = width - length;
19850: for(i=width; i>=nPad; i--){
19851: bufpt[i] = bufpt[i-nPad];
19852: }
19853: i = prefix!=0;
19854: while( nPad-- ) bufpt[i++] = '0';
19855: length = width;
19856: }
19857: #endif /* !defined(SQLITE_OMIT_FLOATING_POINT) */
19858: break;
19859: case etSIZE:
19860: *(va_arg(ap,int*)) = pAccum->nChar;
19861: length = width = 0;
19862: break;
19863: case etPERCENT:
19864: buf[0] = '%';
19865: bufpt = buf;
19866: length = 1;
19867: break;
19868: case etCHARX:
19869: c = va_arg(ap,int);
19870: buf[0] = (char)c;
19871: if( precision>=0 ){
19872: for(idx=1; idx<precision; idx++) buf[idx] = (char)c;
19873: length = precision;
19874: }else{
19875: length =1;
19876: }
19877: bufpt = buf;
19878: break;
19879: case etSTRING:
19880: case etDYNSTRING:
19881: bufpt = va_arg(ap,char*);
19882: if( bufpt==0 ){
19883: bufpt = "";
19884: }else if( xtype==etDYNSTRING ){
19885: zExtra = bufpt;
19886: }
19887: if( precision>=0 ){
19888: for(length=0; length<precision && bufpt[length]; length++){}
19889: }else{
19890: length = sqlite3Strlen30(bufpt);
19891: }
19892: break;
19893: case etSQLESCAPE:
19894: case etSQLESCAPE2:
19895: case etSQLESCAPE3: {
19896: int i, j, k, n, isnull;
19897: int needQuote;
19898: char ch;
19899: char q = ((xtype==etSQLESCAPE3)?'"':'\''); /* Quote character */
19900: char *escarg = va_arg(ap,char*);
19901: isnull = escarg==0;
19902: if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
19903: k = precision;
19904: for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
19905: if( ch==q ) n++;
19906: }
19907: needQuote = !isnull && xtype==etSQLESCAPE2;
19908: n += i + 1 + needQuote*2;
19909: if( n>etBUFSIZE ){
19910: bufpt = zExtra = sqlite3Malloc( n );
19911: if( bufpt==0 ){
19912: pAccum->mallocFailed = 1;
19913: return;
19914: }
19915: }else{
19916: bufpt = buf;
19917: }
19918: j = 0;
19919: if( needQuote ) bufpt[j++] = q;
19920: k = i;
19921: for(i=0; i<k; i++){
19922: bufpt[j++] = ch = escarg[i];
19923: if( ch==q ) bufpt[j++] = ch;
19924: }
19925: if( needQuote ) bufpt[j++] = q;
19926: bufpt[j] = 0;
19927: length = j;
19928: /* The precision in %q and %Q means how many input characters to
19929: ** consume, not the length of the output...
19930: ** if( precision>=0 && precision<length ) length = precision; */
19931: break;
19932: }
19933: case etTOKEN: {
19934: Token *pToken = va_arg(ap, Token*);
19935: if( pToken ){
19936: sqlite3StrAccumAppend(pAccum, (const char*)pToken->z, pToken->n);
19937: }
19938: length = width = 0;
19939: break;
19940: }
19941: case etSRCLIST: {
19942: SrcList *pSrc = va_arg(ap, SrcList*);
19943: int k = va_arg(ap, int);
19944: struct SrcList_item *pItem = &pSrc->a[k];
19945: assert( k>=0 && k<pSrc->nSrc );
19946: if( pItem->zDatabase ){
19947: sqlite3StrAccumAppend(pAccum, pItem->zDatabase, -1);
19948: sqlite3StrAccumAppend(pAccum, ".", 1);
19949: }
19950: sqlite3StrAccumAppend(pAccum, pItem->zName, -1);
19951: length = width = 0;
19952: break;
19953: }
19954: default: {
19955: assert( xtype==etINVALID );
19956: return;
19957: }
19958: }/* End switch over the format type */
19959: /*
19960: ** The text of the conversion is pointed to by "bufpt" and is
19961: ** "length" characters long. The field width is "width". Do
19962: ** the output.
19963: */
19964: if( !flag_leftjustify ){
19965: register int nspace;
19966: nspace = width-length;
19967: if( nspace>0 ){
19968: sqlite3AppendSpace(pAccum, nspace);
19969: }
19970: }
19971: if( length>0 ){
19972: sqlite3StrAccumAppend(pAccum, bufpt, length);
19973: }
19974: if( flag_leftjustify ){
19975: register int nspace;
19976: nspace = width-length;
19977: if( nspace>0 ){
19978: sqlite3AppendSpace(pAccum, nspace);
19979: }
19980: }
19981: sqlite3_free(zExtra);
19982: }/* End for loop over the format string */
19983: } /* End of function */
19984:
19985: /*
19986: ** Append N bytes of text from z to the StrAccum object.
19987: */
19988: SQLITE_PRIVATE void sqlite3StrAccumAppend(StrAccum *p, const char *z, int N){
19989: assert( z!=0 || N==0 );
19990: if( p->tooBig | p->mallocFailed ){
19991: testcase(p->tooBig);
19992: testcase(p->mallocFailed);
19993: return;
19994: }
19995: assert( p->zText!=0 || p->nChar==0 );
19996: if( N<0 ){
19997: N = sqlite3Strlen30(z);
19998: }
19999: if( N==0 || NEVER(z==0) ){
20000: return;
20001: }
20002: if( p->nChar+N >= p->nAlloc ){
20003: char *zNew;
20004: if( !p->useMalloc ){
20005: p->tooBig = 1;
20006: N = p->nAlloc - p->nChar - 1;
20007: if( N<=0 ){
20008: return;
20009: }
20010: }else{
20011: char *zOld = (p->zText==p->zBase ? 0 : p->zText);
20012: i64 szNew = p->nChar;
20013: szNew += N + 1;
20014: if( szNew > p->mxAlloc ){
20015: sqlite3StrAccumReset(p);
20016: p->tooBig = 1;
20017: return;
20018: }else{
20019: p->nAlloc = (int)szNew;
20020: }
20021: if( p->useMalloc==1 ){
20022: zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
20023: }else{
20024: zNew = sqlite3_realloc(zOld, p->nAlloc);
20025: }
20026: if( zNew ){
20027: if( zOld==0 && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
20028: p->zText = zNew;
20029: }else{
20030: p->mallocFailed = 1;
20031: sqlite3StrAccumReset(p);
20032: return;
20033: }
20034: }
20035: }
20036: assert( p->zText );
20037: memcpy(&p->zText[p->nChar], z, N);
20038: p->nChar += N;
20039: }
20040:
20041: /*
20042: ** Finish off a string by making sure it is zero-terminated.
20043: ** Return a pointer to the resulting string. Return a NULL
20044: ** pointer if any kind of error was encountered.
20045: */
20046: SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
20047: if( p->zText ){
20048: p->zText[p->nChar] = 0;
20049: if( p->useMalloc && p->zText==p->zBase ){
20050: if( p->useMalloc==1 ){
20051: p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
20052: }else{
20053: p->zText = sqlite3_malloc(p->nChar+1);
20054: }
20055: if( p->zText ){
20056: memcpy(p->zText, p->zBase, p->nChar+1);
20057: }else{
20058: p->mallocFailed = 1;
20059: }
20060: }
20061: }
20062: return p->zText;
20063: }
20064:
20065: /*
20066: ** Reset an StrAccum string. Reclaim all malloced memory.
20067: */
20068: SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum *p){
20069: if( p->zText!=p->zBase ){
20070: if( p->useMalloc==1 ){
20071: sqlite3DbFree(p->db, p->zText);
20072: }else{
20073: sqlite3_free(p->zText);
20074: }
20075: }
20076: p->zText = 0;
20077: }
20078:
20079: /*
20080: ** Initialize a string accumulator
20081: */
20082: SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, char *zBase, int n, int mx){
20083: p->zText = p->zBase = zBase;
20084: p->db = 0;
20085: p->nChar = 0;
20086: p->nAlloc = n;
20087: p->mxAlloc = mx;
20088: p->useMalloc = 1;
20089: p->tooBig = 0;
20090: p->mallocFailed = 0;
20091: }
20092:
20093: /*
20094: ** Print into memory obtained from sqliteMalloc(). Use the internal
20095: ** %-conversion extensions.
20096: */
20097: SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
20098: char *z;
20099: char zBase[SQLITE_PRINT_BUF_SIZE];
20100: StrAccum acc;
20101: assert( db!=0 );
20102: sqlite3StrAccumInit(&acc, zBase, sizeof(zBase),
20103: db->aLimit[SQLITE_LIMIT_LENGTH]);
20104: acc.db = db;
20105: sqlite3VXPrintf(&acc, 1, zFormat, ap);
20106: z = sqlite3StrAccumFinish(&acc);
20107: if( acc.mallocFailed ){
20108: db->mallocFailed = 1;
20109: }
20110: return z;
20111: }
20112:
20113: /*
20114: ** Print into memory obtained from sqliteMalloc(). Use the internal
20115: ** %-conversion extensions.
20116: */
20117: SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){
20118: va_list ap;
20119: char *z;
20120: va_start(ap, zFormat);
20121: z = sqlite3VMPrintf(db, zFormat, ap);
20122: va_end(ap);
20123: return z;
20124: }
20125:
20126: /*
20127: ** Like sqlite3MPrintf(), but call sqlite3DbFree() on zStr after formatting
20128: ** the string and before returnning. This routine is intended to be used
20129: ** to modify an existing string. For example:
20130: **
20131: ** x = sqlite3MPrintf(db, x, "prefix %s suffix", x);
20132: **
20133: */
20134: SQLITE_PRIVATE char *sqlite3MAppendf(sqlite3 *db, char *zStr, const char *zFormat, ...){
20135: va_list ap;
20136: char *z;
20137: va_start(ap, zFormat);
20138: z = sqlite3VMPrintf(db, zFormat, ap);
20139: va_end(ap);
20140: sqlite3DbFree(db, zStr);
20141: return z;
20142: }
20143:
20144: /*
20145: ** Print into memory obtained from sqlite3_malloc(). Omit the internal
20146: ** %-conversion extensions.
20147: */
20148: SQLITE_API char *sqlite3_vmprintf(const char *zFormat, va_list ap){
20149: char *z;
20150: char zBase[SQLITE_PRINT_BUF_SIZE];
20151: StrAccum acc;
20152: #ifndef SQLITE_OMIT_AUTOINIT
20153: if( sqlite3_initialize() ) return 0;
20154: #endif
20155: sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
20156: acc.useMalloc = 2;
20157: sqlite3VXPrintf(&acc, 0, zFormat, ap);
20158: z = sqlite3StrAccumFinish(&acc);
20159: return z;
20160: }
20161:
20162: /*
20163: ** Print into memory obtained from sqlite3_malloc()(). Omit the internal
20164: ** %-conversion extensions.
20165: */
20166: SQLITE_API char *sqlite3_mprintf(const char *zFormat, ...){
20167: va_list ap;
20168: char *z;
20169: #ifndef SQLITE_OMIT_AUTOINIT
20170: if( sqlite3_initialize() ) return 0;
20171: #endif
20172: va_start(ap, zFormat);
20173: z = sqlite3_vmprintf(zFormat, ap);
20174: va_end(ap);
20175: return z;
20176: }
20177:
20178: /*
20179: ** sqlite3_snprintf() works like snprintf() except that it ignores the
20180: ** current locale settings. This is important for SQLite because we
20181: ** are not able to use a "," as the decimal point in place of "." as
20182: ** specified by some locales.
20183: **
20184: ** Oops: The first two arguments of sqlite3_snprintf() are backwards
20185: ** from the snprintf() standard. Unfortunately, it is too late to change
20186: ** this without breaking compatibility, so we just have to live with the
20187: ** mistake.
20188: **
20189: ** sqlite3_vsnprintf() is the varargs version.
20190: */
20191: SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
20192: StrAccum acc;
20193: if( n<=0 ) return zBuf;
20194: sqlite3StrAccumInit(&acc, zBuf, n, 0);
20195: acc.useMalloc = 0;
20196: sqlite3VXPrintf(&acc, 0, zFormat, ap);
20197: return sqlite3StrAccumFinish(&acc);
20198: }
20199: SQLITE_API char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
20200: char *z;
20201: va_list ap;
20202: va_start(ap,zFormat);
20203: z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
20204: va_end(ap);
20205: return z;
20206: }
20207:
20208: /*
20209: ** This is the routine that actually formats the sqlite3_log() message.
20210: ** We house it in a separate routine from sqlite3_log() to avoid using
20211: ** stack space on small-stack systems when logging is disabled.
20212: **
20213: ** sqlite3_log() must render into a static buffer. It cannot dynamically
20214: ** allocate memory because it might be called while the memory allocator
20215: ** mutex is held.
20216: */
20217: static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
20218: StrAccum acc; /* String accumulator */
20219: char zMsg[SQLITE_PRINT_BUF_SIZE*3]; /* Complete log message */
20220:
20221: sqlite3StrAccumInit(&acc, zMsg, sizeof(zMsg), 0);
20222: acc.useMalloc = 0;
20223: sqlite3VXPrintf(&acc, 0, zFormat, ap);
20224: sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
20225: sqlite3StrAccumFinish(&acc));
20226: }
20227:
20228: /*
20229: ** Format and write a message to the log if logging is enabled.
20230: */
20231: SQLITE_API void sqlite3_log(int iErrCode, const char *zFormat, ...){
20232: va_list ap; /* Vararg list */
20233: if( sqlite3GlobalConfig.xLog ){
20234: va_start(ap, zFormat);
20235: renderLogMsg(iErrCode, zFormat, ap);
20236: va_end(ap);
20237: }
20238: }
20239:
20240: #if defined(SQLITE_DEBUG)
20241: /*
20242: ** A version of printf() that understands %lld. Used for debugging.
20243: ** The printf() built into some versions of windows does not understand %lld
20244: ** and segfaults if you give it a long long int.
20245: */
20246: SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){
20247: va_list ap;
20248: StrAccum acc;
20249: char zBuf[500];
20250: sqlite3StrAccumInit(&acc, zBuf, sizeof(zBuf), 0);
20251: acc.useMalloc = 0;
20252: va_start(ap,zFormat);
20253: sqlite3VXPrintf(&acc, 0, zFormat, ap);
20254: va_end(ap);
20255: sqlite3StrAccumFinish(&acc);
20256: fprintf(stdout,"%s", zBuf);
20257: fflush(stdout);
20258: }
20259: #endif
20260:
20261: #ifndef SQLITE_OMIT_TRACE
20262: /*
20263: ** variable-argument wrapper around sqlite3VXPrintf().
20264: */
20265: SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, const char *zFormat, ...){
20266: va_list ap;
20267: va_start(ap,zFormat);
20268: sqlite3VXPrintf(p, 1, zFormat, ap);
20269: va_end(ap);
20270: }
20271: #endif
20272:
20273: /************** End of printf.c **********************************************/
20274: /************** Begin file random.c ******************************************/
20275: /*
20276: ** 2001 September 15
20277: **
20278: ** The author disclaims copyright to this source code. In place of
20279: ** a legal notice, here is a blessing:
20280: **
20281: ** May you do good and not evil.
20282: ** May you find forgiveness for yourself and forgive others.
20283: ** May you share freely, never taking more than you give.
20284: **
20285: *************************************************************************
20286: ** This file contains code to implement a pseudo-random number
20287: ** generator (PRNG) for SQLite.
20288: **
20289: ** Random numbers are used by some of the database backends in order
20290: ** to generate random integer keys for tables or random filenames.
20291: */
20292:
20293:
20294: /* All threads share a single random number generator.
20295: ** This structure is the current state of the generator.
20296: */
20297: static SQLITE_WSD struct sqlite3PrngType {
20298: unsigned char isInit; /* True if initialized */
20299: unsigned char i, j; /* State variables */
20300: unsigned char s[256]; /* State variables */
20301: } sqlite3Prng;
20302:
20303: /*
20304: ** Get a single 8-bit random value from the RC4 PRNG. The Mutex
20305: ** must be held while executing this routine.
20306: **
20307: ** Why not just use a library random generator like lrand48() for this?
20308: ** Because the OP_NewRowid opcode in the VDBE depends on having a very
20309: ** good source of random numbers. The lrand48() library function may
20310: ** well be good enough. But maybe not. Or maybe lrand48() has some
20311: ** subtle problems on some systems that could cause problems. It is hard
20312: ** to know. To minimize the risk of problems due to bad lrand48()
20313: ** implementations, SQLite uses this random number generator based
20314: ** on RC4, which we know works very well.
20315: **
20316: ** (Later): Actually, OP_NewRowid does not depend on a good source of
20317: ** randomness any more. But we will leave this code in all the same.
20318: */
20319: static u8 randomByte(void){
20320: unsigned char t;
20321:
20322:
20323: /* The "wsdPrng" macro will resolve to the pseudo-random number generator
20324: ** state vector. If writable static data is unsupported on the target,
20325: ** we have to locate the state vector at run-time. In the more common
20326: ** case where writable static data is supported, wsdPrng can refer directly
20327: ** to the "sqlite3Prng" state vector declared above.
20328: */
20329: #ifdef SQLITE_OMIT_WSD
20330: struct sqlite3PrngType *p = &GLOBAL(struct sqlite3PrngType, sqlite3Prng);
20331: # define wsdPrng p[0]
20332: #else
20333: # define wsdPrng sqlite3Prng
20334: #endif
20335:
20336:
20337: /* Initialize the state of the random number generator once,
20338: ** the first time this routine is called. The seed value does
20339: ** not need to contain a lot of randomness since we are not
20340: ** trying to do secure encryption or anything like that...
20341: **
20342: ** Nothing in this file or anywhere else in SQLite does any kind of
20343: ** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random
20344: ** number generator) not as an encryption device.
20345: */
20346: if( !wsdPrng.isInit ){
20347: int i;
20348: char k[256];
20349: wsdPrng.j = 0;
20350: wsdPrng.i = 0;
20351: sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
20352: for(i=0; i<256; i++){
20353: wsdPrng.s[i] = (u8)i;
20354: }
20355: for(i=0; i<256; i++){
20356: wsdPrng.j += wsdPrng.s[i] + k[i];
20357: t = wsdPrng.s[wsdPrng.j];
20358: wsdPrng.s[wsdPrng.j] = wsdPrng.s[i];
20359: wsdPrng.s[i] = t;
20360: }
20361: wsdPrng.isInit = 1;
20362: }
20363:
20364: /* Generate and return single random byte
20365: */
20366: wsdPrng.i++;
20367: t = wsdPrng.s[wsdPrng.i];
20368: wsdPrng.j += t;
20369: wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j];
20370: wsdPrng.s[wsdPrng.j] = t;
20371: t += wsdPrng.s[wsdPrng.i];
20372: return wsdPrng.s[t];
20373: }
20374:
20375: /*
20376: ** Return N random bytes.
20377: */
20378: SQLITE_API void sqlite3_randomness(int N, void *pBuf){
20379: unsigned char *zBuf = pBuf;
20380: #if SQLITE_THREADSAFE
20381: sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG);
20382: #endif
20383: sqlite3_mutex_enter(mutex);
20384: while( N-- ){
20385: *(zBuf++) = randomByte();
20386: }
20387: sqlite3_mutex_leave(mutex);
20388: }
20389:
20390: #ifndef SQLITE_OMIT_BUILTIN_TEST
20391: /*
20392: ** For testing purposes, we sometimes want to preserve the state of
20393: ** PRNG and restore the PRNG to its saved state at a later time, or
20394: ** to reset the PRNG to its initial state. These routines accomplish
20395: ** those tasks.
20396: **
20397: ** The sqlite3_test_control() interface calls these routines to
20398: ** control the PRNG.
20399: */
20400: static SQLITE_WSD struct sqlite3PrngType sqlite3SavedPrng;
20401: SQLITE_PRIVATE void sqlite3PrngSaveState(void){
20402: memcpy(
20403: &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng),
20404: &GLOBAL(struct sqlite3PrngType, sqlite3Prng),
20405: sizeof(sqlite3Prng)
20406: );
20407: }
20408: SQLITE_PRIVATE void sqlite3PrngRestoreState(void){
20409: memcpy(
20410: &GLOBAL(struct sqlite3PrngType, sqlite3Prng),
20411: &GLOBAL(struct sqlite3PrngType, sqlite3SavedPrng),
20412: sizeof(sqlite3Prng)
20413: );
20414: }
20415: SQLITE_PRIVATE void sqlite3PrngResetState(void){
20416: GLOBAL(struct sqlite3PrngType, sqlite3Prng).isInit = 0;
20417: }
20418: #endif /* SQLITE_OMIT_BUILTIN_TEST */
20419:
20420: /************** End of random.c **********************************************/
20421: /************** Begin file utf.c *********************************************/
20422: /*
20423: ** 2004 April 13
20424: **
20425: ** The author disclaims copyright to this source code. In place of
20426: ** a legal notice, here is a blessing:
20427: **
20428: ** May you do good and not evil.
20429: ** May you find forgiveness for yourself and forgive others.
20430: ** May you share freely, never taking more than you give.
20431: **
20432: *************************************************************************
20433: ** This file contains routines used to translate between UTF-8,
20434: ** UTF-16, UTF-16BE, and UTF-16LE.
20435: **
20436: ** Notes on UTF-8:
20437: **
20438: ** Byte-0 Byte-1 Byte-2 Byte-3 Value
20439: ** 0xxxxxxx 00000000 00000000 0xxxxxxx
20440: ** 110yyyyy 10xxxxxx 00000000 00000yyy yyxxxxxx
20441: ** 1110zzzz 10yyyyyy 10xxxxxx 00000000 zzzzyyyy yyxxxxxx
20442: ** 11110uuu 10uuzzzz 10yyyyyy 10xxxxxx 000uuuuu zzzzyyyy yyxxxxxx
20443: **
20444: **
20445: ** Notes on UTF-16: (with wwww+1==uuuuu)
20446: **
20447: ** Word-0 Word-1 Value
20448: ** 110110ww wwzzzzyy 110111yy yyxxxxxx 000uuuuu zzzzyyyy yyxxxxxx
20449: ** zzzzyyyy yyxxxxxx 00000000 zzzzyyyy yyxxxxxx
20450: **
20451: **
20452: ** BOM or Byte Order Mark:
20453: ** 0xff 0xfe little-endian utf-16 follows
20454: ** 0xfe 0xff big-endian utf-16 follows
20455: **
20456: */
20457: /* #include <assert.h> */
20458:
20459: #ifndef SQLITE_AMALGAMATION
20460: /*
20461: ** The following constant value is used by the SQLITE_BIGENDIAN and
20462: ** SQLITE_LITTLEENDIAN macros.
20463: */
20464: SQLITE_PRIVATE const int sqlite3one = 1;
20465: #endif /* SQLITE_AMALGAMATION */
20466:
20467: /*
20468: ** This lookup table is used to help decode the first byte of
20469: ** a multi-byte UTF8 character.
20470: */
20471: static const unsigned char sqlite3Utf8Trans1[] = {
20472: 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
20473: 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
20474: 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
20475: 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
20476: 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
20477: 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
20478: 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
20479: 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
20480: };
20481:
20482:
20483: #define WRITE_UTF8(zOut, c) { \
20484: if( c<0x00080 ){ \
20485: *zOut++ = (u8)(c&0xFF); \
20486: } \
20487: else if( c<0x00800 ){ \
20488: *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \
20489: *zOut++ = 0x80 + (u8)(c & 0x3F); \
20490: } \
20491: else if( c<0x10000 ){ \
20492: *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \
20493: *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
20494: *zOut++ = 0x80 + (u8)(c & 0x3F); \
20495: }else{ \
20496: *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \
20497: *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \
20498: *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \
20499: *zOut++ = 0x80 + (u8)(c & 0x3F); \
20500: } \
20501: }
20502:
20503: #define WRITE_UTF16LE(zOut, c) { \
20504: if( c<=0xFFFF ){ \
20505: *zOut++ = (u8)(c&0x00FF); \
20506: *zOut++ = (u8)((c>>8)&0x00FF); \
20507: }else{ \
20508: *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
20509: *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
20510: *zOut++ = (u8)(c&0x00FF); \
20511: *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \
20512: } \
20513: }
20514:
20515: #define WRITE_UTF16BE(zOut, c) { \
20516: if( c<=0xFFFF ){ \
20517: *zOut++ = (u8)((c>>8)&0x00FF); \
20518: *zOut++ = (u8)(c&0x00FF); \
20519: }else{ \
20520: *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \
20521: *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \
20522: *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \
20523: *zOut++ = (u8)(c&0x00FF); \
20524: } \
20525: }
20526:
20527: #define READ_UTF16LE(zIn, TERM, c){ \
20528: c = (*zIn++); \
20529: c += ((*zIn++)<<8); \
20530: if( c>=0xD800 && c<0xE000 && TERM ){ \
20531: int c2 = (*zIn++); \
20532: c2 += ((*zIn++)<<8); \
20533: c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \
20534: } \
20535: }
20536:
20537: #define READ_UTF16BE(zIn, TERM, c){ \
20538: c = ((*zIn++)<<8); \
20539: c += (*zIn++); \
20540: if( c>=0xD800 && c<0xE000 && TERM ){ \
20541: int c2 = ((*zIn++)<<8); \
20542: c2 += (*zIn++); \
20543: c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \
20544: } \
20545: }
20546:
20547: /*
20548: ** Translate a single UTF-8 character. Return the unicode value.
20549: **
20550: ** During translation, assume that the byte that zTerm points
20551: ** is a 0x00.
20552: **
20553: ** Write a pointer to the next unread byte back into *pzNext.
20554: **
20555: ** Notes On Invalid UTF-8:
20556: **
20557: ** * This routine never allows a 7-bit character (0x00 through 0x7f) to
20558: ** be encoded as a multi-byte character. Any multi-byte character that
20559: ** attempts to encode a value between 0x00 and 0x7f is rendered as 0xfffd.
20560: **
20561: ** * This routine never allows a UTF16 surrogate value to be encoded.
20562: ** If a multi-byte character attempts to encode a value between
20563: ** 0xd800 and 0xe000 then it is rendered as 0xfffd.
20564: **
20565: ** * Bytes in the range of 0x80 through 0xbf which occur as the first
20566: ** byte of a character are interpreted as single-byte characters
20567: ** and rendered as themselves even though they are technically
20568: ** invalid characters.
20569: **
20570: ** * This routine accepts an infinite number of different UTF8 encodings
20571: ** for unicode values 0x80 and greater. It do not change over-length
20572: ** encodings to 0xfffd as some systems recommend.
20573: */
20574: #define READ_UTF8(zIn, zTerm, c) \
20575: c = *(zIn++); \
20576: if( c>=0xc0 ){ \
20577: c = sqlite3Utf8Trans1[c-0xc0]; \
20578: while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \
20579: c = (c<<6) + (0x3f & *(zIn++)); \
20580: } \
20581: if( c<0x80 \
20582: || (c&0xFFFFF800)==0xD800 \
20583: || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \
20584: }
20585: SQLITE_PRIVATE u32 sqlite3Utf8Read(
20586: const unsigned char *zIn, /* First byte of UTF-8 character */
20587: const unsigned char **pzNext /* Write first byte past UTF-8 char here */
20588: ){
20589: unsigned int c;
20590:
20591: /* Same as READ_UTF8() above but without the zTerm parameter.
20592: ** For this routine, we assume the UTF8 string is always zero-terminated.
20593: */
20594: c = *(zIn++);
20595: if( c>=0xc0 ){
20596: c = sqlite3Utf8Trans1[c-0xc0];
20597: while( (*zIn & 0xc0)==0x80 ){
20598: c = (c<<6) + (0x3f & *(zIn++));
20599: }
20600: if( c<0x80
20601: || (c&0xFFFFF800)==0xD800
20602: || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; }
20603: }
20604: *pzNext = zIn;
20605: return c;
20606: }
20607:
20608:
20609:
20610:
20611: /*
20612: ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
20613: ** printed on stderr on the way into and out of sqlite3VdbeMemTranslate().
20614: */
20615: /* #define TRANSLATE_TRACE 1 */
20616:
20617: #ifndef SQLITE_OMIT_UTF16
20618: /*
20619: ** This routine transforms the internal text encoding used by pMem to
20620: ** desiredEnc. It is an error if the string is already of the desired
20621: ** encoding, or if *pMem does not contain a string value.
20622: */
20623: SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
20624: int len; /* Maximum length of output string in bytes */
20625: unsigned char *zOut; /* Output buffer */
20626: unsigned char *zIn; /* Input iterator */
20627: unsigned char *zTerm; /* End of input */
20628: unsigned char *z; /* Output iterator */
20629: unsigned int c;
20630:
20631: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
20632: assert( pMem->flags&MEM_Str );
20633: assert( pMem->enc!=desiredEnc );
20634: assert( pMem->enc!=0 );
20635: assert( pMem->n>=0 );
20636:
20637: #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
20638: {
20639: char zBuf[100];
20640: sqlite3VdbeMemPrettyPrint(pMem, zBuf);
20641: fprintf(stderr, "INPUT: %s\n", zBuf);
20642: }
20643: #endif
20644:
20645: /* If the translation is between UTF-16 little and big endian, then
20646: ** all that is required is to swap the byte order. This case is handled
20647: ** differently from the others.
20648: */
20649: if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
20650: u8 temp;
20651: int rc;
20652: rc = sqlite3VdbeMemMakeWriteable(pMem);
20653: if( rc!=SQLITE_OK ){
20654: assert( rc==SQLITE_NOMEM );
20655: return SQLITE_NOMEM;
20656: }
20657: zIn = (u8*)pMem->z;
20658: zTerm = &zIn[pMem->n&~1];
20659: while( zIn<zTerm ){
20660: temp = *zIn;
20661: *zIn = *(zIn+1);
20662: zIn++;
20663: *zIn++ = temp;
20664: }
20665: pMem->enc = desiredEnc;
20666: goto translate_out;
20667: }
20668:
20669: /* Set len to the maximum number of bytes required in the output buffer. */
20670: if( desiredEnc==SQLITE_UTF8 ){
20671: /* When converting from UTF-16, the maximum growth results from
20672: ** translating a 2-byte character to a 4-byte UTF-8 character.
20673: ** A single byte is required for the output string
20674: ** nul-terminator.
20675: */
20676: pMem->n &= ~1;
20677: len = pMem->n * 2 + 1;
20678: }else{
20679: /* When converting from UTF-8 to UTF-16 the maximum growth is caused
20680: ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16
20681: ** character. Two bytes are required in the output buffer for the
20682: ** nul-terminator.
20683: */
20684: len = pMem->n * 2 + 2;
20685: }
20686:
20687: /* Set zIn to point at the start of the input buffer and zTerm to point 1
20688: ** byte past the end.
20689: **
20690: ** Variable zOut is set to point at the output buffer, space obtained
20691: ** from sqlite3_malloc().
20692: */
20693: zIn = (u8*)pMem->z;
20694: zTerm = &zIn[pMem->n];
20695: zOut = sqlite3DbMallocRaw(pMem->db, len);
20696: if( !zOut ){
20697: return SQLITE_NOMEM;
20698: }
20699: z = zOut;
20700:
20701: if( pMem->enc==SQLITE_UTF8 ){
20702: if( desiredEnc==SQLITE_UTF16LE ){
20703: /* UTF-8 -> UTF-16 Little-endian */
20704: while( zIn<zTerm ){
20705: /* c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
20706: READ_UTF8(zIn, zTerm, c);
20707: WRITE_UTF16LE(z, c);
20708: }
20709: }else{
20710: assert( desiredEnc==SQLITE_UTF16BE );
20711: /* UTF-8 -> UTF-16 Big-endian */
20712: while( zIn<zTerm ){
20713: /* c = sqlite3Utf8Read(zIn, zTerm, (const u8**)&zIn); */
20714: READ_UTF8(zIn, zTerm, c);
20715: WRITE_UTF16BE(z, c);
20716: }
20717: }
20718: pMem->n = (int)(z - zOut);
20719: *z++ = 0;
20720: }else{
20721: assert( desiredEnc==SQLITE_UTF8 );
20722: if( pMem->enc==SQLITE_UTF16LE ){
20723: /* UTF-16 Little-endian -> UTF-8 */
20724: while( zIn<zTerm ){
20725: READ_UTF16LE(zIn, zIn<zTerm, c);
20726: WRITE_UTF8(z, c);
20727: }
20728: }else{
20729: /* UTF-16 Big-endian -> UTF-8 */
20730: while( zIn<zTerm ){
20731: READ_UTF16BE(zIn, zIn<zTerm, c);
20732: WRITE_UTF8(z, c);
20733: }
20734: }
20735: pMem->n = (int)(z - zOut);
20736: }
20737: *z = 0;
20738: assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
20739:
20740: sqlite3VdbeMemRelease(pMem);
20741: pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem);
20742: pMem->enc = desiredEnc;
20743: pMem->flags |= (MEM_Term|MEM_Dyn);
20744: pMem->z = (char*)zOut;
20745: pMem->zMalloc = pMem->z;
20746:
20747: translate_out:
20748: #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG)
20749: {
20750: char zBuf[100];
20751: sqlite3VdbeMemPrettyPrint(pMem, zBuf);
20752: fprintf(stderr, "OUTPUT: %s\n", zBuf);
20753: }
20754: #endif
20755: return SQLITE_OK;
20756: }
20757:
20758: /*
20759: ** This routine checks for a byte-order mark at the beginning of the
20760: ** UTF-16 string stored in *pMem. If one is present, it is removed and
20761: ** the encoding of the Mem adjusted. This routine does not do any
20762: ** byte-swapping, it just sets Mem.enc appropriately.
20763: **
20764: ** The allocation (static, dynamic etc.) and encoding of the Mem may be
20765: ** changed by this function.
20766: */
20767: SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem){
20768: int rc = SQLITE_OK;
20769: u8 bom = 0;
20770:
20771: assert( pMem->n>=0 );
20772: if( pMem->n>1 ){
20773: u8 b1 = *(u8 *)pMem->z;
20774: u8 b2 = *(((u8 *)pMem->z) + 1);
20775: if( b1==0xFE && b2==0xFF ){
20776: bom = SQLITE_UTF16BE;
20777: }
20778: if( b1==0xFF && b2==0xFE ){
20779: bom = SQLITE_UTF16LE;
20780: }
20781: }
20782:
20783: if( bom ){
20784: rc = sqlite3VdbeMemMakeWriteable(pMem);
20785: if( rc==SQLITE_OK ){
20786: pMem->n -= 2;
20787: memmove(pMem->z, &pMem->z[2], pMem->n);
20788: pMem->z[pMem->n] = '\0';
20789: pMem->z[pMem->n+1] = '\0';
20790: pMem->flags |= MEM_Term;
20791: pMem->enc = bom;
20792: }
20793: }
20794: return rc;
20795: }
20796: #endif /* SQLITE_OMIT_UTF16 */
20797:
20798: /*
20799: ** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
20800: ** return the number of unicode characters in pZ up to (but not including)
20801: ** the first 0x00 byte. If nByte is not less than zero, return the
20802: ** number of unicode characters in the first nByte of pZ (or up to
20803: ** the first 0x00, whichever comes first).
20804: */
20805: SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *zIn, int nByte){
20806: int r = 0;
20807: const u8 *z = (const u8*)zIn;
20808: const u8 *zTerm;
20809: if( nByte>=0 ){
20810: zTerm = &z[nByte];
20811: }else{
20812: zTerm = (const u8*)(-1);
20813: }
20814: assert( z<=zTerm );
20815: while( *z!=0 && z<zTerm ){
20816: SQLITE_SKIP_UTF8(z);
20817: r++;
20818: }
20819: return r;
20820: }
20821:
20822: /* This test function is not currently used by the automated test-suite.
20823: ** Hence it is only available in debug builds.
20824: */
20825: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
20826: /*
20827: ** Translate UTF-8 to UTF-8.
20828: **
20829: ** This has the effect of making sure that the string is well-formed
20830: ** UTF-8. Miscoded characters are removed.
20831: **
20832: ** The translation is done in-place and aborted if the output
20833: ** overruns the input.
20834: */
20835: SQLITE_PRIVATE int sqlite3Utf8To8(unsigned char *zIn){
20836: unsigned char *zOut = zIn;
20837: unsigned char *zStart = zIn;
20838: u32 c;
20839:
20840: while( zIn[0] && zOut<=zIn ){
20841: c = sqlite3Utf8Read(zIn, (const u8**)&zIn);
20842: if( c!=0xfffd ){
20843: WRITE_UTF8(zOut, c);
20844: }
20845: }
20846: *zOut = 0;
20847: return (int)(zOut - zStart);
20848: }
20849: #endif
20850:
20851: #ifndef SQLITE_OMIT_UTF16
20852: /*
20853: ** Convert a UTF-16 string in the native encoding into a UTF-8 string.
20854: ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
20855: ** be freed by the calling function.
20856: **
20857: ** NULL is returned if there is an allocation error.
20858: */
20859: SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
20860: Mem m;
20861: memset(&m, 0, sizeof(m));
20862: m.db = db;
20863: sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
20864: sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);
20865: if( db->mallocFailed ){
20866: sqlite3VdbeMemRelease(&m);
20867: m.z = 0;
20868: }
20869: assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
20870: assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
20871: assert( (m.flags & MEM_Dyn)!=0 || db->mallocFailed );
20872: assert( m.z || db->mallocFailed );
20873: return m.z;
20874: }
20875:
20876: /*
20877: ** Convert a UTF-8 string to the UTF-16 encoding specified by parameter
20878: ** enc. A pointer to the new string is returned, and the value of *pnOut
20879: ** is set to the length of the returned string in bytes. The call should
20880: ** arrange to call sqlite3DbFree() on the returned pointer when it is
20881: ** no longer required.
20882: **
20883: ** If a malloc failure occurs, NULL is returned and the db.mallocFailed
20884: ** flag set.
20885: */
20886: #ifdef SQLITE_ENABLE_STAT3
20887: SQLITE_PRIVATE char *sqlite3Utf8to16(sqlite3 *db, u8 enc, char *z, int n, int *pnOut){
20888: Mem m;
20889: memset(&m, 0, sizeof(m));
20890: m.db = db;
20891: sqlite3VdbeMemSetStr(&m, z, n, SQLITE_UTF8, SQLITE_STATIC);
20892: if( sqlite3VdbeMemTranslate(&m, enc) ){
20893: assert( db->mallocFailed );
20894: return 0;
20895: }
20896: assert( m.z==m.zMalloc );
20897: *pnOut = m.n;
20898: return m.z;
20899: }
20900: #endif
20901:
20902: /*
20903: ** zIn is a UTF-16 encoded unicode string at least nChar characters long.
20904: ** Return the number of bytes in the first nChar unicode characters
20905: ** in pZ. nChar must be non-negative.
20906: */
20907: SQLITE_PRIVATE int sqlite3Utf16ByteLen(const void *zIn, int nChar){
20908: int c;
20909: unsigned char const *z = zIn;
20910: int n = 0;
20911:
20912: if( SQLITE_UTF16NATIVE==SQLITE_UTF16BE ){
20913: while( n<nChar ){
20914: READ_UTF16BE(z, 1, c);
20915: n++;
20916: }
20917: }else{
20918: while( n<nChar ){
20919: READ_UTF16LE(z, 1, c);
20920: n++;
20921: }
20922: }
20923: return (int)(z-(unsigned char const *)zIn);
20924: }
20925:
20926: #if defined(SQLITE_TEST)
20927: /*
20928: ** This routine is called from the TCL test function "translate_selftest".
20929: ** It checks that the primitives for serializing and deserializing
20930: ** characters in each encoding are inverses of each other.
20931: */
20932: SQLITE_PRIVATE void sqlite3UtfSelfTest(void){
20933: unsigned int i, t;
20934: unsigned char zBuf[20];
20935: unsigned char *z;
20936: int n;
20937: unsigned int c;
20938:
20939: for(i=0; i<0x00110000; i++){
20940: z = zBuf;
20941: WRITE_UTF8(z, i);
20942: n = (int)(z-zBuf);
20943: assert( n>0 && n<=4 );
20944: z[0] = 0;
20945: z = zBuf;
20946: c = sqlite3Utf8Read(z, (const u8**)&z);
20947: t = i;
20948: if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD;
20949: if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD;
20950: assert( c==t );
20951: assert( (z-zBuf)==n );
20952: }
20953: for(i=0; i<0x00110000; i++){
20954: if( i>=0xD800 && i<0xE000 ) continue;
20955: z = zBuf;
20956: WRITE_UTF16LE(z, i);
20957: n = (int)(z-zBuf);
20958: assert( n>0 && n<=4 );
20959: z[0] = 0;
20960: z = zBuf;
20961: READ_UTF16LE(z, 1, c);
20962: assert( c==i );
20963: assert( (z-zBuf)==n );
20964: }
20965: for(i=0; i<0x00110000; i++){
20966: if( i>=0xD800 && i<0xE000 ) continue;
20967: z = zBuf;
20968: WRITE_UTF16BE(z, i);
20969: n = (int)(z-zBuf);
20970: assert( n>0 && n<=4 );
20971: z[0] = 0;
20972: z = zBuf;
20973: READ_UTF16BE(z, 1, c);
20974: assert( c==i );
20975: assert( (z-zBuf)==n );
20976: }
20977: }
20978: #endif /* SQLITE_TEST */
20979: #endif /* SQLITE_OMIT_UTF16 */
20980:
20981: /************** End of utf.c *************************************************/
20982: /************** Begin file util.c ********************************************/
20983: /*
20984: ** 2001 September 15
20985: **
20986: ** The author disclaims copyright to this source code. In place of
20987: ** a legal notice, here is a blessing:
20988: **
20989: ** May you do good and not evil.
20990: ** May you find forgiveness for yourself and forgive others.
20991: ** May you share freely, never taking more than you give.
20992: **
20993: *************************************************************************
20994: ** Utility functions used throughout sqlite.
20995: **
20996: ** This file contains functions for allocating memory, comparing
20997: ** strings, and stuff like that.
20998: **
20999: */
21000: /* #include <stdarg.h> */
21001: #ifdef SQLITE_HAVE_ISNAN
21002: # include <math.h>
21003: #endif
21004:
21005: /*
21006: ** Routine needed to support the testcase() macro.
21007: */
21008: #ifdef SQLITE_COVERAGE_TEST
21009: SQLITE_PRIVATE void sqlite3Coverage(int x){
21010: static unsigned dummy = 0;
21011: dummy += (unsigned)x;
21012: }
21013: #endif
21014:
21015: #ifndef SQLITE_OMIT_FLOATING_POINT
21016: /*
21017: ** Return true if the floating point value is Not a Number (NaN).
21018: **
21019: ** Use the math library isnan() function if compiled with SQLITE_HAVE_ISNAN.
21020: ** Otherwise, we have our own implementation that works on most systems.
21021: */
21022: SQLITE_PRIVATE int sqlite3IsNaN(double x){
21023: int rc; /* The value return */
21024: #if !defined(SQLITE_HAVE_ISNAN)
21025: /*
21026: ** Systems that support the isnan() library function should probably
21027: ** make use of it by compiling with -DSQLITE_HAVE_ISNAN. But we have
21028: ** found that many systems do not have a working isnan() function so
21029: ** this implementation is provided as an alternative.
21030: **
21031: ** This NaN test sometimes fails if compiled on GCC with -ffast-math.
21032: ** On the other hand, the use of -ffast-math comes with the following
21033: ** warning:
21034: **
21035: ** This option [-ffast-math] should never be turned on by any
21036: ** -O option since it can result in incorrect output for programs
21037: ** which depend on an exact implementation of IEEE or ISO
21038: ** rules/specifications for math functions.
21039: **
21040: ** Under MSVC, this NaN test may fail if compiled with a floating-
21041: ** point precision mode other than /fp:precise. From the MSDN
21042: ** documentation:
21043: **
21044: ** The compiler [with /fp:precise] will properly handle comparisons
21045: ** involving NaN. For example, x != x evaluates to true if x is NaN
21046: ** ...
21047: */
21048: #ifdef __FAST_MATH__
21049: # error SQLite will not work correctly with the -ffast-math option of GCC.
21050: #endif
21051: volatile double y = x;
21052: volatile double z = y;
21053: rc = (y!=z);
21054: #else /* if defined(SQLITE_HAVE_ISNAN) */
21055: rc = isnan(x);
21056: #endif /* SQLITE_HAVE_ISNAN */
21057: testcase( rc );
21058: return rc;
21059: }
21060: #endif /* SQLITE_OMIT_FLOATING_POINT */
21061:
21062: /*
21063: ** Compute a string length that is limited to what can be stored in
21064: ** lower 30 bits of a 32-bit signed integer.
21065: **
21066: ** The value returned will never be negative. Nor will it ever be greater
21067: ** than the actual length of the string. For very long strings (greater
21068: ** than 1GiB) the value returned might be less than the true string length.
21069: */
21070: SQLITE_PRIVATE int sqlite3Strlen30(const char *z){
21071: const char *z2 = z;
21072: if( z==0 ) return 0;
21073: while( *z2 ){ z2++; }
21074: return 0x3fffffff & (int)(z2 - z);
21075: }
21076:
21077: /*
21078: ** Set the most recent error code and error string for the sqlite
21079: ** handle "db". The error code is set to "err_code".
21080: **
21081: ** If it is not NULL, string zFormat specifies the format of the
21082: ** error string in the style of the printf functions: The following
21083: ** format characters are allowed:
21084: **
21085: ** %s Insert a string
21086: ** %z A string that should be freed after use
21087: ** %d Insert an integer
21088: ** %T Insert a token
21089: ** %S Insert the first element of a SrcList
21090: **
21091: ** zFormat and any string tokens that follow it are assumed to be
21092: ** encoded in UTF-8.
21093: **
21094: ** To clear the most recent error for sqlite handle "db", sqlite3Error
21095: ** should be called with err_code set to SQLITE_OK and zFormat set
21096: ** to NULL.
21097: */
21098: SQLITE_PRIVATE void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
21099: if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
21100: db->errCode = err_code;
21101: if( zFormat ){
21102: char *z;
21103: va_list ap;
21104: va_start(ap, zFormat);
21105: z = sqlite3VMPrintf(db, zFormat, ap);
21106: va_end(ap);
21107: sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
21108: }else{
21109: sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
21110: }
21111: }
21112: }
21113:
21114: /*
21115: ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
21116: ** The following formatting characters are allowed:
21117: **
21118: ** %s Insert a string
21119: ** %z A string that should be freed after use
21120: ** %d Insert an integer
21121: ** %T Insert a token
21122: ** %S Insert the first element of a SrcList
21123: **
21124: ** This function should be used to report any error that occurs whilst
21125: ** compiling an SQL statement (i.e. within sqlite3_prepare()). The
21126: ** last thing the sqlite3_prepare() function does is copy the error
21127: ** stored by this function into the database handle using sqlite3Error().
21128: ** Function sqlite3Error() should be used during statement execution
21129: ** (sqlite3_step() etc.).
21130: */
21131: SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
21132: char *zMsg;
21133: va_list ap;
21134: sqlite3 *db = pParse->db;
21135: va_start(ap, zFormat);
21136: zMsg = sqlite3VMPrintf(db, zFormat, ap);
21137: va_end(ap);
21138: if( db->suppressErr ){
21139: sqlite3DbFree(db, zMsg);
21140: }else{
21141: pParse->nErr++;
21142: sqlite3DbFree(db, pParse->zErrMsg);
21143: pParse->zErrMsg = zMsg;
21144: pParse->rc = SQLITE_ERROR;
21145: }
21146: }
21147:
21148: /*
21149: ** Convert an SQL-style quoted string into a normal string by removing
21150: ** the quote characters. The conversion is done in-place. If the
21151: ** input does not begin with a quote character, then this routine
21152: ** is a no-op.
21153: **
21154: ** The input string must be zero-terminated. A new zero-terminator
21155: ** is added to the dequoted string.
21156: **
21157: ** The return value is -1 if no dequoting occurs or the length of the
21158: ** dequoted string, exclusive of the zero terminator, if dequoting does
21159: ** occur.
21160: **
21161: ** 2002-Feb-14: This routine is extended to remove MS-Access style
21162: ** brackets from around identifers. For example: "[a-b-c]" becomes
21163: ** "a-b-c".
21164: */
21165: SQLITE_PRIVATE int sqlite3Dequote(char *z){
21166: char quote;
21167: int i, j;
21168: if( z==0 ) return -1;
21169: quote = z[0];
21170: switch( quote ){
21171: case '\'': break;
21172: case '"': break;
21173: case '`': break; /* For MySQL compatibility */
21174: case '[': quote = ']'; break; /* For MS SqlServer compatibility */
21175: default: return -1;
21176: }
21177: for(i=1, j=0; ALWAYS(z[i]); i++){
21178: if( z[i]==quote ){
21179: if( z[i+1]==quote ){
21180: z[j++] = quote;
21181: i++;
21182: }else{
21183: break;
21184: }
21185: }else{
21186: z[j++] = z[i];
21187: }
21188: }
21189: z[j] = 0;
21190: return j;
21191: }
21192:
21193: /* Convenient short-hand */
21194: #define UpperToLower sqlite3UpperToLower
21195:
21196: /*
21197: ** Some systems have stricmp(). Others have strcasecmp(). Because
21198: ** there is no consistency, we will define our own.
21199: **
21200: ** IMPLEMENTATION-OF: R-20522-24639 The sqlite3_strnicmp() API allows
21201: ** applications and extensions to compare the contents of two buffers
21202: ** containing UTF-8 strings in a case-independent fashion, using the same
21203: ** definition of case independence that SQLite uses internally when
21204: ** comparing identifiers.
21205: */
21206: SQLITE_PRIVATE int sqlite3StrICmp(const char *zLeft, const char *zRight){
21207: register unsigned char *a, *b;
21208: a = (unsigned char *)zLeft;
21209: b = (unsigned char *)zRight;
21210: while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
21211: return UpperToLower[*a] - UpperToLower[*b];
21212: }
21213: SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
21214: register unsigned char *a, *b;
21215: a = (unsigned char *)zLeft;
21216: b = (unsigned char *)zRight;
21217: while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
21218: return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
21219: }
21220:
21221: /*
21222: ** The string z[] is an text representation of a real number.
21223: ** Convert this string to a double and write it into *pResult.
21224: **
21225: ** The string z[] is length bytes in length (bytes, not characters) and
21226: ** uses the encoding enc. The string is not necessarily zero-terminated.
21227: **
21228: ** Return TRUE if the result is a valid real number (or integer) and FALSE
21229: ** if the string is empty or contains extraneous text. Valid numbers
21230: ** are in one of these formats:
21231: **
21232: ** [+-]digits[E[+-]digits]
21233: ** [+-]digits.[digits][E[+-]digits]
21234: ** [+-].digits[E[+-]digits]
21235: **
21236: ** Leading and trailing whitespace is ignored for the purpose of determining
21237: ** validity.
21238: **
21239: ** If some prefix of the input string is a valid number, this routine
21240: ** returns FALSE but it still converts the prefix and writes the result
21241: ** into *pResult.
21242: */
21243: SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
21244: #ifndef SQLITE_OMIT_FLOATING_POINT
21245: int incr = (enc==SQLITE_UTF8?1:2);
21246: const char *zEnd = z + length;
21247: /* sign * significand * (10 ^ (esign * exponent)) */
21248: int sign = 1; /* sign of significand */
21249: i64 s = 0; /* significand */
21250: int d = 0; /* adjust exponent for shifting decimal point */
21251: int esign = 1; /* sign of exponent */
21252: int e = 0; /* exponent */
21253: int eValid = 1; /* True exponent is either not used or is well-formed */
21254: double result;
21255: int nDigits = 0;
21256:
21257: *pResult = 0.0; /* Default return value, in case of an error */
21258:
21259: if( enc==SQLITE_UTF16BE ) z++;
21260:
21261: /* skip leading spaces */
21262: while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
21263: if( z>=zEnd ) return 0;
21264:
21265: /* get sign of significand */
21266: if( *z=='-' ){
21267: sign = -1;
21268: z+=incr;
21269: }else if( *z=='+' ){
21270: z+=incr;
21271: }
21272:
21273: /* skip leading zeroes */
21274: while( z<zEnd && z[0]=='0' ) z+=incr, nDigits++;
21275:
21276: /* copy max significant digits to significand */
21277: while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
21278: s = s*10 + (*z - '0');
21279: z+=incr, nDigits++;
21280: }
21281:
21282: /* skip non-significant significand digits
21283: ** (increase exponent by d to shift decimal left) */
21284: while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++;
21285: if( z>=zEnd ) goto do_atof_calc;
21286:
21287: /* if decimal point is present */
21288: if( *z=='.' ){
21289: z+=incr;
21290: /* copy digits from after decimal to significand
21291: ** (decrease exponent by d to shift decimal right) */
21292: while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
21293: s = s*10 + (*z - '0');
21294: z+=incr, nDigits++, d--;
21295: }
21296: /* skip non-significant digits */
21297: while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++;
21298: }
21299: if( z>=zEnd ) goto do_atof_calc;
21300:
21301: /* if exponent is present */
21302: if( *z=='e' || *z=='E' ){
21303: z+=incr;
21304: eValid = 0;
21305: if( z>=zEnd ) goto do_atof_calc;
21306: /* get sign of exponent */
21307: if( *z=='-' ){
21308: esign = -1;
21309: z+=incr;
21310: }else if( *z=='+' ){
21311: z+=incr;
21312: }
21313: /* copy digits to exponent */
21314: while( z<zEnd && sqlite3Isdigit(*z) ){
21315: e = e<10000 ? (e*10 + (*z - '0')) : 10000;
21316: z+=incr;
21317: eValid = 1;
21318: }
21319: }
21320:
21321: /* skip trailing spaces */
21322: if( nDigits && eValid ){
21323: while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
21324: }
21325:
21326: do_atof_calc:
21327: /* adjust exponent by d, and update sign */
21328: e = (e*esign) + d;
21329: if( e<0 ) {
21330: esign = -1;
21331: e *= -1;
21332: } else {
21333: esign = 1;
21334: }
21335:
21336: /* if 0 significand */
21337: if( !s ) {
21338: /* In the IEEE 754 standard, zero is signed.
21339: ** Add the sign if we've seen at least one digit */
21340: result = (sign<0 && nDigits) ? -(double)0 : (double)0;
21341: } else {
21342: /* attempt to reduce exponent */
21343: if( esign>0 ){
21344: while( s<(LARGEST_INT64/10) && e>0 ) e--,s*=10;
21345: }else{
21346: while( !(s%10) && e>0 ) e--,s/=10;
21347: }
21348:
21349: /* adjust the sign of significand */
21350: s = sign<0 ? -s : s;
21351:
21352: /* if exponent, scale significand as appropriate
21353: ** and store in result. */
21354: if( e ){
21355: double scale = 1.0;
21356: #ifndef __vax__
21357: /* attempt to handle extremely small/large numbers better */
21358: if( e>307 && e<342 ){
21359: while( e%308 ) { scale *= 1.0e+1; e -= 1; }
21360: if( esign<0 ){
21361: result = s / scale;
21362: result /= SQLITE_HUGE_DBL;
21363: }else{
21364: result = s * scale;
21365: result *= SQLITE_HUGE_DBL;
21366: }
21367: }else if( e>=342 ){
21368: if( esign<0 ){
21369: result = 0.0*s;
21370: }else{
21371: result = 1e308*1e308*s; /* Infinity */
21372: }
21373: }else
21374: #endif
21375: {
21376: /* 1.0e+22 is the largest power of 10 than can be
21377: ** represented exactly. */
21378: while( e%22 ) { scale *= 1.0e+1; e -= 1; }
21379: while( e>0 ) { scale *= 1.0e+22; e -= 22; }
21380: if( esign<0 ){
21381: result = s / scale;
21382: }else{
21383: result = s * scale;
21384: }
21385: }
21386: } else {
21387: result = (double)s;
21388: }
21389: }
21390:
21391: /* store the result */
21392: *pResult = result;
21393:
21394: /* return true if number and no extra non-whitespace chracters after */
21395: return z>=zEnd && nDigits>0 && eValid;
21396: #else
21397: return !sqlite3Atoi64(z, pResult, length, enc);
21398: #endif /* SQLITE_OMIT_FLOATING_POINT */
21399: }
21400:
21401: /*
21402: ** Compare the 19-character string zNum against the text representation
21403: ** value 2^63: 9223372036854775808. Return negative, zero, or positive
21404: ** if zNum is less than, equal to, or greater than the string.
21405: ** Note that zNum must contain exactly 19 characters.
21406: **
21407: ** Unlike memcmp() this routine is guaranteed to return the difference
21408: ** in the values of the last digit if the only difference is in the
21409: ** last digit. So, for example,
21410: **
21411: ** compare2pow63("9223372036854775800", 1)
21412: **
21413: ** will return -8.
21414: */
21415: static int compare2pow63(const char *zNum, int incr){
21416: int c = 0;
21417: int i;
21418: /* 012345678901234567 */
21419: const char *pow63 = "922337203685477580";
21420: for(i=0; c==0 && i<18; i++){
21421: c = (zNum[i*incr]-pow63[i])*10;
21422: }
21423: if( c==0 ){
21424: c = zNum[18*incr] - '8';
21425: testcase( c==(-1) );
21426: testcase( c==0 );
21427: testcase( c==(+1) );
21428: }
21429: return c;
21430: }
21431:
21432:
21433: /*
21434: ** Convert zNum to a 64-bit signed integer.
21435: **
21436: ** If the zNum value is representable as a 64-bit twos-complement
21437: ** integer, then write that value into *pNum and return 0.
21438: **
21439: ** If zNum is exactly 9223372036854665808, return 2. This special
21440: ** case is broken out because while 9223372036854665808 cannot be a
21441: ** signed 64-bit integer, its negative -9223372036854665808 can be.
21442: **
21443: ** If zNum is too big for a 64-bit integer and is not
21444: ** 9223372036854665808 then return 1.
21445: **
21446: ** length is the number of bytes in the string (bytes, not characters).
21447: ** The string is not necessarily zero-terminated. The encoding is
21448: ** given by enc.
21449: */
21450: SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
21451: int incr = (enc==SQLITE_UTF8?1:2);
21452: u64 u = 0;
21453: int neg = 0; /* assume positive */
21454: int i;
21455: int c = 0;
21456: const char *zStart;
21457: const char *zEnd = zNum + length;
21458: if( enc==SQLITE_UTF16BE ) zNum++;
21459: while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
21460: if( zNum<zEnd ){
21461: if( *zNum=='-' ){
21462: neg = 1;
21463: zNum+=incr;
21464: }else if( *zNum=='+' ){
21465: zNum+=incr;
21466: }
21467: }
21468: zStart = zNum;
21469: while( zNum<zEnd && zNum[0]=='0' ){ zNum+=incr; } /* Skip leading zeros. */
21470: for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
21471: u = u*10 + c - '0';
21472: }
21473: if( u>LARGEST_INT64 ){
21474: *pNum = SMALLEST_INT64;
21475: }else if( neg ){
21476: *pNum = -(i64)u;
21477: }else{
21478: *pNum = (i64)u;
21479: }
21480: testcase( i==18 );
21481: testcase( i==19 );
21482: testcase( i==20 );
21483: if( (c!=0 && &zNum[i]<zEnd) || (i==0 && zStart==zNum) || i>19*incr ){
21484: /* zNum is empty or contains non-numeric text or is longer
21485: ** than 19 digits (thus guaranteeing that it is too large) */
21486: return 1;
21487: }else if( i<19*incr ){
21488: /* Less than 19 digits, so we know that it fits in 64 bits */
21489: assert( u<=LARGEST_INT64 );
21490: return 0;
21491: }else{
21492: /* zNum is a 19-digit numbers. Compare it against 9223372036854775808. */
21493: c = compare2pow63(zNum, incr);
21494: if( c<0 ){
21495: /* zNum is less than 9223372036854775808 so it fits */
21496: assert( u<=LARGEST_INT64 );
21497: return 0;
21498: }else if( c>0 ){
21499: /* zNum is greater than 9223372036854775808 so it overflows */
21500: return 1;
21501: }else{
21502: /* zNum is exactly 9223372036854775808. Fits if negative. The
21503: ** special case 2 overflow if positive */
21504: assert( u-1==LARGEST_INT64 );
21505: assert( (*pNum)==SMALLEST_INT64 );
21506: return neg ? 0 : 2;
21507: }
21508: }
21509: }
21510:
21511: /*
21512: ** If zNum represents an integer that will fit in 32-bits, then set
21513: ** *pValue to that integer and return true. Otherwise return false.
21514: **
21515: ** Any non-numeric characters that following zNum are ignored.
21516: ** This is different from sqlite3Atoi64() which requires the
21517: ** input number to be zero-terminated.
21518: */
21519: SQLITE_PRIVATE int sqlite3GetInt32(const char *zNum, int *pValue){
21520: sqlite_int64 v = 0;
21521: int i, c;
21522: int neg = 0;
21523: if( zNum[0]=='-' ){
21524: neg = 1;
21525: zNum++;
21526: }else if( zNum[0]=='+' ){
21527: zNum++;
21528: }
21529: while( zNum[0]=='0' ) zNum++;
21530: for(i=0; i<11 && (c = zNum[i] - '0')>=0 && c<=9; i++){
21531: v = v*10 + c;
21532: }
21533:
21534: /* The longest decimal representation of a 32 bit integer is 10 digits:
21535: **
21536: ** 1234567890
21537: ** 2^31 -> 2147483648
21538: */
21539: testcase( i==10 );
21540: if( i>10 ){
21541: return 0;
21542: }
21543: testcase( v-neg==2147483647 );
21544: if( v-neg>2147483647 ){
21545: return 0;
21546: }
21547: if( neg ){
21548: v = -v;
21549: }
21550: *pValue = (int)v;
21551: return 1;
21552: }
21553:
21554: /*
21555: ** Return a 32-bit integer value extracted from a string. If the
21556: ** string is not an integer, just return 0.
21557: */
21558: SQLITE_PRIVATE int sqlite3Atoi(const char *z){
21559: int x = 0;
21560: if( z ) sqlite3GetInt32(z, &x);
21561: return x;
21562: }
21563:
21564: /*
21565: ** The variable-length integer encoding is as follows:
21566: **
21567: ** KEY:
21568: ** A = 0xxxxxxx 7 bits of data and one flag bit
21569: ** B = 1xxxxxxx 7 bits of data and one flag bit
21570: ** C = xxxxxxxx 8 bits of data
21571: **
21572: ** 7 bits - A
21573: ** 14 bits - BA
21574: ** 21 bits - BBA
21575: ** 28 bits - BBBA
21576: ** 35 bits - BBBBA
21577: ** 42 bits - BBBBBA
21578: ** 49 bits - BBBBBBA
21579: ** 56 bits - BBBBBBBA
21580: ** 64 bits - BBBBBBBBC
21581: */
21582:
21583: /*
21584: ** Write a 64-bit variable-length integer to memory starting at p[0].
21585: ** The length of data write will be between 1 and 9 bytes. The number
21586: ** of bytes written is returned.
21587: **
21588: ** A variable-length integer consists of the lower 7 bits of each byte
21589: ** for all bytes that have the 8th bit set and one byte with the 8th
21590: ** bit clear. Except, if we get to the 9th byte, it stores the full
21591: ** 8 bits and is the last byte.
21592: */
21593: SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){
21594: int i, j, n;
21595: u8 buf[10];
21596: if( v & (((u64)0xff000000)<<32) ){
21597: p[8] = (u8)v;
21598: v >>= 8;
21599: for(i=7; i>=0; i--){
21600: p[i] = (u8)((v & 0x7f) | 0x80);
21601: v >>= 7;
21602: }
21603: return 9;
21604: }
21605: n = 0;
21606: do{
21607: buf[n++] = (u8)((v & 0x7f) | 0x80);
21608: v >>= 7;
21609: }while( v!=0 );
21610: buf[0] &= 0x7f;
21611: assert( n<=9 );
21612: for(i=0, j=n-1; j>=0; j--, i++){
21613: p[i] = buf[j];
21614: }
21615: return n;
21616: }
21617:
21618: /*
21619: ** This routine is a faster version of sqlite3PutVarint() that only
21620: ** works for 32-bit positive integers and which is optimized for
21621: ** the common case of small integers. A MACRO version, putVarint32,
21622: ** is provided which inlines the single-byte case. All code should use
21623: ** the MACRO version as this function assumes the single-byte case has
21624: ** already been handled.
21625: */
21626: SQLITE_PRIVATE int sqlite3PutVarint32(unsigned char *p, u32 v){
21627: #ifndef putVarint32
21628: if( (v & ~0x7f)==0 ){
21629: p[0] = v;
21630: return 1;
21631: }
21632: #endif
21633: if( (v & ~0x3fff)==0 ){
21634: p[0] = (u8)((v>>7) | 0x80);
21635: p[1] = (u8)(v & 0x7f);
21636: return 2;
21637: }
21638: return sqlite3PutVarint(p, v);
21639: }
21640:
21641: /*
21642: ** Bitmasks used by sqlite3GetVarint(). These precomputed constants
21643: ** are defined here rather than simply putting the constant expressions
21644: ** inline in order to work around bugs in the RVT compiler.
21645: **
21646: ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
21647: **
21648: ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
21649: */
21650: #define SLOT_2_0 0x001fc07f
21651: #define SLOT_4_2_0 0xf01fc07f
21652:
21653:
21654: /*
21655: ** Read a 64-bit variable-length integer from memory starting at p[0].
21656: ** Return the number of bytes read. The value is stored in *v.
21657: */
21658: SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
21659: u32 a,b,s;
21660:
21661: a = *p;
21662: /* a: p0 (unmasked) */
21663: if (!(a&0x80))
21664: {
21665: *v = a;
21666: return 1;
21667: }
21668:
21669: p++;
21670: b = *p;
21671: /* b: p1 (unmasked) */
21672: if (!(b&0x80))
21673: {
21674: a &= 0x7f;
21675: a = a<<7;
21676: a |= b;
21677: *v = a;
21678: return 2;
21679: }
21680:
21681: /* Verify that constants are precomputed correctly */
21682: assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
21683: assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
21684:
21685: p++;
21686: a = a<<14;
21687: a |= *p;
21688: /* a: p0<<14 | p2 (unmasked) */
21689: if (!(a&0x80))
21690: {
21691: a &= SLOT_2_0;
21692: b &= 0x7f;
21693: b = b<<7;
21694: a |= b;
21695: *v = a;
21696: return 3;
21697: }
21698:
21699: /* CSE1 from below */
21700: a &= SLOT_2_0;
21701: p++;
21702: b = b<<14;
21703: b |= *p;
21704: /* b: p1<<14 | p3 (unmasked) */
21705: if (!(b&0x80))
21706: {
21707: b &= SLOT_2_0;
21708: /* moved CSE1 up */
21709: /* a &= (0x7f<<14)|(0x7f); */
21710: a = a<<7;
21711: a |= b;
21712: *v = a;
21713: return 4;
21714: }
21715:
21716: /* a: p0<<14 | p2 (masked) */
21717: /* b: p1<<14 | p3 (unmasked) */
21718: /* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
21719: /* moved CSE1 up */
21720: /* a &= (0x7f<<14)|(0x7f); */
21721: b &= SLOT_2_0;
21722: s = a;
21723: /* s: p0<<14 | p2 (masked) */
21724:
21725: p++;
21726: a = a<<14;
21727: a |= *p;
21728: /* a: p0<<28 | p2<<14 | p4 (unmasked) */
21729: if (!(a&0x80))
21730: {
21731: /* we can skip these cause they were (effectively) done above in calc'ing s */
21732: /* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
21733: /* b &= (0x7f<<14)|(0x7f); */
21734: b = b<<7;
21735: a |= b;
21736: s = s>>18;
21737: *v = ((u64)s)<<32 | a;
21738: return 5;
21739: }
21740:
21741: /* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
21742: s = s<<7;
21743: s |= b;
21744: /* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
21745:
21746: p++;
21747: b = b<<14;
21748: b |= *p;
21749: /* b: p1<<28 | p3<<14 | p5 (unmasked) */
21750: if (!(b&0x80))
21751: {
21752: /* we can skip this cause it was (effectively) done above in calc'ing s */
21753: /* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
21754: a &= SLOT_2_0;
21755: a = a<<7;
21756: a |= b;
21757: s = s>>18;
21758: *v = ((u64)s)<<32 | a;
21759: return 6;
21760: }
21761:
21762: p++;
21763: a = a<<14;
21764: a |= *p;
21765: /* a: p2<<28 | p4<<14 | p6 (unmasked) */
21766: if (!(a&0x80))
21767: {
21768: a &= SLOT_4_2_0;
21769: b &= SLOT_2_0;
21770: b = b<<7;
21771: a |= b;
21772: s = s>>11;
21773: *v = ((u64)s)<<32 | a;
21774: return 7;
21775: }
21776:
21777: /* CSE2 from below */
21778: a &= SLOT_2_0;
21779: p++;
21780: b = b<<14;
21781: b |= *p;
21782: /* b: p3<<28 | p5<<14 | p7 (unmasked) */
21783: if (!(b&0x80))
21784: {
21785: b &= SLOT_4_2_0;
21786: /* moved CSE2 up */
21787: /* a &= (0x7f<<14)|(0x7f); */
21788: a = a<<7;
21789: a |= b;
21790: s = s>>4;
21791: *v = ((u64)s)<<32 | a;
21792: return 8;
21793: }
21794:
21795: p++;
21796: a = a<<15;
21797: a |= *p;
21798: /* a: p4<<29 | p6<<15 | p8 (unmasked) */
21799:
21800: /* moved CSE2 up */
21801: /* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
21802: b &= SLOT_2_0;
21803: b = b<<8;
21804: a |= b;
21805:
21806: s = s<<4;
21807: b = p[-4];
21808: b &= 0x7f;
21809: b = b>>3;
21810: s |= b;
21811:
21812: *v = ((u64)s)<<32 | a;
21813:
21814: return 9;
21815: }
21816:
21817: /*
21818: ** Read a 32-bit variable-length integer from memory starting at p[0].
21819: ** Return the number of bytes read. The value is stored in *v.
21820: **
21821: ** If the varint stored in p[0] is larger than can fit in a 32-bit unsigned
21822: ** integer, then set *v to 0xffffffff.
21823: **
21824: ** A MACRO version, getVarint32, is provided which inlines the
21825: ** single-byte case. All code should use the MACRO version as
21826: ** this function assumes the single-byte case has already been handled.
21827: */
21828: SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){
21829: u32 a,b;
21830:
21831: /* The 1-byte case. Overwhelmingly the most common. Handled inline
21832: ** by the getVarin32() macro */
21833: a = *p;
21834: /* a: p0 (unmasked) */
21835: #ifndef getVarint32
21836: if (!(a&0x80))
21837: {
21838: /* Values between 0 and 127 */
21839: *v = a;
21840: return 1;
21841: }
21842: #endif
21843:
21844: /* The 2-byte case */
21845: p++;
21846: b = *p;
21847: /* b: p1 (unmasked) */
21848: if (!(b&0x80))
21849: {
21850: /* Values between 128 and 16383 */
21851: a &= 0x7f;
21852: a = a<<7;
21853: *v = a | b;
21854: return 2;
21855: }
21856:
21857: /* The 3-byte case */
21858: p++;
21859: a = a<<14;
21860: a |= *p;
21861: /* a: p0<<14 | p2 (unmasked) */
21862: if (!(a&0x80))
21863: {
21864: /* Values between 16384 and 2097151 */
21865: a &= (0x7f<<14)|(0x7f);
21866: b &= 0x7f;
21867: b = b<<7;
21868: *v = a | b;
21869: return 3;
21870: }
21871:
21872: /* A 32-bit varint is used to store size information in btrees.
21873: ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
21874: ** A 3-byte varint is sufficient, for example, to record the size
21875: ** of a 1048569-byte BLOB or string.
21876: **
21877: ** We only unroll the first 1-, 2-, and 3- byte cases. The very
21878: ** rare larger cases can be handled by the slower 64-bit varint
21879: ** routine.
21880: */
21881: #if 1
21882: {
21883: u64 v64;
21884: u8 n;
21885:
21886: p -= 2;
21887: n = sqlite3GetVarint(p, &v64);
21888: assert( n>3 && n<=9 );
21889: if( (v64 & SQLITE_MAX_U32)!=v64 ){
21890: *v = 0xffffffff;
21891: }else{
21892: *v = (u32)v64;
21893: }
21894: return n;
21895: }
21896:
21897: #else
21898: /* For following code (kept for historical record only) shows an
21899: ** unrolling for the 3- and 4-byte varint cases. This code is
21900: ** slightly faster, but it is also larger and much harder to test.
21901: */
21902: p++;
21903: b = b<<14;
21904: b |= *p;
21905: /* b: p1<<14 | p3 (unmasked) */
21906: if (!(b&0x80))
21907: {
21908: /* Values between 2097152 and 268435455 */
21909: b &= (0x7f<<14)|(0x7f);
21910: a &= (0x7f<<14)|(0x7f);
21911: a = a<<7;
21912: *v = a | b;
21913: return 4;
21914: }
21915:
21916: p++;
21917: a = a<<14;
21918: a |= *p;
21919: /* a: p0<<28 | p2<<14 | p4 (unmasked) */
21920: if (!(a&0x80))
21921: {
21922: /* Values between 268435456 and 34359738367 */
21923: a &= SLOT_4_2_0;
21924: b &= SLOT_4_2_0;
21925: b = b<<7;
21926: *v = a | b;
21927: return 5;
21928: }
21929:
21930: /* We can only reach this point when reading a corrupt database
21931: ** file. In that case we are not in any hurry. Use the (relatively
21932: ** slow) general-purpose sqlite3GetVarint() routine to extract the
21933: ** value. */
21934: {
21935: u64 v64;
21936: u8 n;
21937:
21938: p -= 4;
21939: n = sqlite3GetVarint(p, &v64);
21940: assert( n>5 && n<=9 );
21941: *v = (u32)v64;
21942: return n;
21943: }
21944: #endif
21945: }
21946:
21947: /*
21948: ** Return the number of bytes that will be needed to store the given
21949: ** 64-bit integer.
21950: */
21951: SQLITE_PRIVATE int sqlite3VarintLen(u64 v){
21952: int i = 0;
21953: do{
21954: i++;
21955: v >>= 7;
21956: }while( v!=0 && ALWAYS(i<9) );
21957: return i;
21958: }
21959:
21960:
21961: /*
21962: ** Read or write a four-byte big-endian integer value.
21963: */
21964: SQLITE_PRIVATE u32 sqlite3Get4byte(const u8 *p){
21965: return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
21966: }
21967: SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){
21968: p[0] = (u8)(v>>24);
21969: p[1] = (u8)(v>>16);
21970: p[2] = (u8)(v>>8);
21971: p[3] = (u8)v;
21972: }
21973:
21974:
21975:
21976: /*
21977: ** Translate a single byte of Hex into an integer.
21978: ** This routine only works if h really is a valid hexadecimal
21979: ** character: 0..9a..fA..F
21980: */
21981: SQLITE_PRIVATE u8 sqlite3HexToInt(int h){
21982: assert( (h>='0' && h<='9') || (h>='a' && h<='f') || (h>='A' && h<='F') );
21983: #ifdef SQLITE_ASCII
21984: h += 9*(1&(h>>6));
21985: #endif
21986: #ifdef SQLITE_EBCDIC
21987: h += 9*(1&~(h>>4));
21988: #endif
21989: return (u8)(h & 0xf);
21990: }
21991:
21992: #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC)
21993: /*
21994: ** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
21995: ** value. Return a pointer to its binary value. Space to hold the
21996: ** binary value has been obtained from malloc and must be freed by
21997: ** the calling routine.
21998: */
21999: SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
22000: char *zBlob;
22001: int i;
22002:
22003: zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);
22004: n--;
22005: if( zBlob ){
22006: for(i=0; i<n; i+=2){
22007: zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
22008: }
22009: zBlob[i/2] = 0;
22010: }
22011: return zBlob;
22012: }
22013: #endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
22014:
22015: /*
22016: ** Log an error that is an API call on a connection pointer that should
22017: ** not have been used. The "type" of connection pointer is given as the
22018: ** argument. The zType is a word like "NULL" or "closed" or "invalid".
22019: */
22020: static void logBadConnection(const char *zType){
22021: sqlite3_log(SQLITE_MISUSE,
22022: "API call with %s database connection pointer",
22023: zType
22024: );
22025: }
22026:
22027: /*
22028: ** Check to make sure we have a valid db pointer. This test is not
22029: ** foolproof but it does provide some measure of protection against
22030: ** misuse of the interface such as passing in db pointers that are
22031: ** NULL or which have been previously closed. If this routine returns
22032: ** 1 it means that the db pointer is valid and 0 if it should not be
22033: ** dereferenced for any reason. The calling function should invoke
22034: ** SQLITE_MISUSE immediately.
22035: **
22036: ** sqlite3SafetyCheckOk() requires that the db pointer be valid for
22037: ** use. sqlite3SafetyCheckSickOrOk() allows a db pointer that failed to
22038: ** open properly and is not fit for general use but which can be
22039: ** used as an argument to sqlite3_errmsg() or sqlite3_close().
22040: */
22041: SQLITE_PRIVATE int sqlite3SafetyCheckOk(sqlite3 *db){
22042: u32 magic;
22043: if( db==0 ){
22044: logBadConnection("NULL");
22045: return 0;
22046: }
22047: magic = db->magic;
22048: if( magic!=SQLITE_MAGIC_OPEN ){
22049: if( sqlite3SafetyCheckSickOrOk(db) ){
22050: testcase( sqlite3GlobalConfig.xLog!=0 );
22051: logBadConnection("unopened");
22052: }
22053: return 0;
22054: }else{
22055: return 1;
22056: }
22057: }
22058: SQLITE_PRIVATE int sqlite3SafetyCheckSickOrOk(sqlite3 *db){
22059: u32 magic;
22060: magic = db->magic;
22061: if( magic!=SQLITE_MAGIC_SICK &&
22062: magic!=SQLITE_MAGIC_OPEN &&
22063: magic!=SQLITE_MAGIC_BUSY ){
22064: testcase( sqlite3GlobalConfig.xLog!=0 );
22065: logBadConnection("invalid");
22066: return 0;
22067: }else{
22068: return 1;
22069: }
22070: }
22071:
22072: /*
22073: ** Attempt to add, substract, or multiply the 64-bit signed value iB against
22074: ** the other 64-bit signed integer at *pA and store the result in *pA.
22075: ** Return 0 on success. Or if the operation would have resulted in an
22076: ** overflow, leave *pA unchanged and return 1.
22077: */
22078: SQLITE_PRIVATE int sqlite3AddInt64(i64 *pA, i64 iB){
22079: i64 iA = *pA;
22080: testcase( iA==0 ); testcase( iA==1 );
22081: testcase( iB==-1 ); testcase( iB==0 );
22082: if( iB>=0 ){
22083: testcase( iA>0 && LARGEST_INT64 - iA == iB );
22084: testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
22085: if( iA>0 && LARGEST_INT64 - iA < iB ) return 1;
22086: *pA += iB;
22087: }else{
22088: testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
22089: testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
22090: if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 ) return 1;
22091: *pA += iB;
22092: }
22093: return 0;
22094: }
22095: SQLITE_PRIVATE int sqlite3SubInt64(i64 *pA, i64 iB){
22096: testcase( iB==SMALLEST_INT64+1 );
22097: if( iB==SMALLEST_INT64 ){
22098: testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
22099: if( (*pA)>=0 ) return 1;
22100: *pA -= iB;
22101: return 0;
22102: }else{
22103: return sqlite3AddInt64(pA, -iB);
22104: }
22105: }
22106: #define TWOPOWER32 (((i64)1)<<32)
22107: #define TWOPOWER31 (((i64)1)<<31)
22108: SQLITE_PRIVATE int sqlite3MulInt64(i64 *pA, i64 iB){
22109: i64 iA = *pA;
22110: i64 iA1, iA0, iB1, iB0, r;
22111:
22112: iA1 = iA/TWOPOWER32;
22113: iA0 = iA % TWOPOWER32;
22114: iB1 = iB/TWOPOWER32;
22115: iB0 = iB % TWOPOWER32;
22116: if( iA1*iB1 != 0 ) return 1;
22117: assert( iA1*iB0==0 || iA0*iB1==0 );
22118: r = iA1*iB0 + iA0*iB1;
22119: testcase( r==(-TWOPOWER31)-1 );
22120: testcase( r==(-TWOPOWER31) );
22121: testcase( r==TWOPOWER31 );
22122: testcase( r==TWOPOWER31-1 );
22123: if( r<(-TWOPOWER31) || r>=TWOPOWER31 ) return 1;
22124: r *= TWOPOWER32;
22125: if( sqlite3AddInt64(&r, iA0*iB0) ) return 1;
22126: *pA = r;
22127: return 0;
22128: }
22129:
22130: /*
22131: ** Compute the absolute value of a 32-bit signed integer, of possible. Or
22132: ** if the integer has a value of -2147483648, return +2147483647
22133: */
22134: SQLITE_PRIVATE int sqlite3AbsInt32(int x){
22135: if( x>=0 ) return x;
22136: if( x==(int)0x80000000 ) return 0x7fffffff;
22137: return -x;
22138: }
22139:
22140: #ifdef SQLITE_ENABLE_8_3_NAMES
22141: /*
22142: ** If SQLITE_ENABLE_8_3_NAMES is set at compile-time and if the database
22143: ** filename in zBaseFilename is a URI with the "8_3_names=1" parameter and
22144: ** if filename in z[] has a suffix (a.k.a. "extension") that is longer than
22145: ** three characters, then shorten the suffix on z[] to be the last three
22146: ** characters of the original suffix.
22147: **
22148: ** If SQLITE_ENABLE_8_3_NAMES is set to 2 at compile-time, then always
22149: ** do the suffix shortening regardless of URI parameter.
22150: **
22151: ** Examples:
22152: **
22153: ** test.db-journal => test.nal
22154: ** test.db-wal => test.wal
22155: ** test.db-shm => test.shm
22156: ** test.db-mj7f3319fa => test.9fa
22157: */
22158: SQLITE_PRIVATE void sqlite3FileSuffix3(const char *zBaseFilename, char *z){
22159: #if SQLITE_ENABLE_8_3_NAMES<2
22160: if( sqlite3_uri_boolean(zBaseFilename, "8_3_names", 0) )
22161: #endif
22162: {
22163: int i, sz;
22164: sz = sqlite3Strlen30(z);
22165: for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
22166: if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
22167: }
22168: }
22169: #endif
22170:
22171: /************** End of util.c ************************************************/
22172: /************** Begin file hash.c ********************************************/
22173: /*
22174: ** 2001 September 22
22175: **
22176: ** The author disclaims copyright to this source code. In place of
22177: ** a legal notice, here is a blessing:
22178: **
22179: ** May you do good and not evil.
22180: ** May you find forgiveness for yourself and forgive others.
22181: ** May you share freely, never taking more than you give.
22182: **
22183: *************************************************************************
22184: ** This is the implementation of generic hash-tables
22185: ** used in SQLite.
22186: */
22187: /* #include <assert.h> */
22188:
22189: /* Turn bulk memory into a hash table object by initializing the
22190: ** fields of the Hash structure.
22191: **
22192: ** "pNew" is a pointer to the hash table that is to be initialized.
22193: */
22194: SQLITE_PRIVATE void sqlite3HashInit(Hash *pNew){
22195: assert( pNew!=0 );
22196: pNew->first = 0;
22197: pNew->count = 0;
22198: pNew->htsize = 0;
22199: pNew->ht = 0;
22200: }
22201:
22202: /* Remove all entries from a hash table. Reclaim all memory.
22203: ** Call this routine to delete a hash table or to reset a hash table
22204: ** to the empty state.
22205: */
22206: SQLITE_PRIVATE void sqlite3HashClear(Hash *pH){
22207: HashElem *elem; /* For looping over all elements of the table */
22208:
22209: assert( pH!=0 );
22210: elem = pH->first;
22211: pH->first = 0;
22212: sqlite3_free(pH->ht);
22213: pH->ht = 0;
22214: pH->htsize = 0;
22215: while( elem ){
22216: HashElem *next_elem = elem->next;
22217: sqlite3_free(elem);
22218: elem = next_elem;
22219: }
22220: pH->count = 0;
22221: }
22222:
22223: /*
22224: ** The hashing function.
22225: */
22226: static unsigned int strHash(const char *z, int nKey){
22227: int h = 0;
22228: assert( nKey>=0 );
22229: while( nKey > 0 ){
22230: h = (h<<3) ^ h ^ sqlite3UpperToLower[(unsigned char)*z++];
22231: nKey--;
22232: }
22233: return h;
22234: }
22235:
22236:
22237: /* Link pNew element into the hash table pH. If pEntry!=0 then also
22238: ** insert pNew into the pEntry hash bucket.
22239: */
22240: static void insertElement(
22241: Hash *pH, /* The complete hash table */
22242: struct _ht *pEntry, /* The entry into which pNew is inserted */
22243: HashElem *pNew /* The element to be inserted */
22244: ){
22245: HashElem *pHead; /* First element already in pEntry */
22246: if( pEntry ){
22247: pHead = pEntry->count ? pEntry->chain : 0;
22248: pEntry->count++;
22249: pEntry->chain = pNew;
22250: }else{
22251: pHead = 0;
22252: }
22253: if( pHead ){
22254: pNew->next = pHead;
22255: pNew->prev = pHead->prev;
22256: if( pHead->prev ){ pHead->prev->next = pNew; }
22257: else { pH->first = pNew; }
22258: pHead->prev = pNew;
22259: }else{
22260: pNew->next = pH->first;
22261: if( pH->first ){ pH->first->prev = pNew; }
22262: pNew->prev = 0;
22263: pH->first = pNew;
22264: }
22265: }
22266:
22267:
22268: /* Resize the hash table so that it cantains "new_size" buckets.
22269: **
22270: ** The hash table might fail to resize if sqlite3_malloc() fails or
22271: ** if the new size is the same as the prior size.
22272: ** Return TRUE if the resize occurs and false if not.
22273: */
22274: static int rehash(Hash *pH, unsigned int new_size){
22275: struct _ht *new_ht; /* The new hash table */
22276: HashElem *elem, *next_elem; /* For looping over existing elements */
22277:
22278: #if SQLITE_MALLOC_SOFT_LIMIT>0
22279: if( new_size*sizeof(struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){
22280: new_size = SQLITE_MALLOC_SOFT_LIMIT/sizeof(struct _ht);
22281: }
22282: if( new_size==pH->htsize ) return 0;
22283: #endif
22284:
22285: /* The inability to allocates space for a larger hash table is
22286: ** a performance hit but it is not a fatal error. So mark the
22287: ** allocation as a benign.
22288: */
22289: sqlite3BeginBenignMalloc();
22290: new_ht = (struct _ht *)sqlite3Malloc( new_size*sizeof(struct _ht) );
22291: sqlite3EndBenignMalloc();
22292:
22293: if( new_ht==0 ) return 0;
22294: sqlite3_free(pH->ht);
22295: pH->ht = new_ht;
22296: pH->htsize = new_size = sqlite3MallocSize(new_ht)/sizeof(struct _ht);
22297: memset(new_ht, 0, new_size*sizeof(struct _ht));
22298: for(elem=pH->first, pH->first=0; elem; elem = next_elem){
22299: unsigned int h = strHash(elem->pKey, elem->nKey) % new_size;
22300: next_elem = elem->next;
22301: insertElement(pH, &new_ht[h], elem);
22302: }
22303: return 1;
22304: }
22305:
22306: /* This function (for internal use only) locates an element in an
22307: ** hash table that matches the given key. The hash for this key has
22308: ** already been computed and is passed as the 4th parameter.
22309: */
22310: static HashElem *findElementGivenHash(
22311: const Hash *pH, /* The pH to be searched */
22312: const char *pKey, /* The key we are searching for */
22313: int nKey, /* Bytes in key (not counting zero terminator) */
22314: unsigned int h /* The hash for this key. */
22315: ){
22316: HashElem *elem; /* Used to loop thru the element list */
22317: int count; /* Number of elements left to test */
22318:
22319: if( pH->ht ){
22320: struct _ht *pEntry = &pH->ht[h];
22321: elem = pEntry->chain;
22322: count = pEntry->count;
22323: }else{
22324: elem = pH->first;
22325: count = pH->count;
22326: }
22327: while( count-- && ALWAYS(elem) ){
22328: if( elem->nKey==nKey && sqlite3StrNICmp(elem->pKey,pKey,nKey)==0 ){
22329: return elem;
22330: }
22331: elem = elem->next;
22332: }
22333: return 0;
22334: }
22335:
22336: /* Remove a single entry from the hash table given a pointer to that
22337: ** element and a hash on the element's key.
22338: */
22339: static void removeElementGivenHash(
22340: Hash *pH, /* The pH containing "elem" */
22341: HashElem* elem, /* The element to be removed from the pH */
22342: unsigned int h /* Hash value for the element */
22343: ){
22344: struct _ht *pEntry;
22345: if( elem->prev ){
22346: elem->prev->next = elem->next;
22347: }else{
22348: pH->first = elem->next;
22349: }
22350: if( elem->next ){
22351: elem->next->prev = elem->prev;
22352: }
22353: if( pH->ht ){
22354: pEntry = &pH->ht[h];
22355: if( pEntry->chain==elem ){
22356: pEntry->chain = elem->next;
22357: }
22358: pEntry->count--;
22359: assert( pEntry->count>=0 );
22360: }
22361: sqlite3_free( elem );
22362: pH->count--;
22363: if( pH->count<=0 ){
22364: assert( pH->first==0 );
22365: assert( pH->count==0 );
22366: sqlite3HashClear(pH);
22367: }
22368: }
22369:
22370: /* Attempt to locate an element of the hash table pH with a key
22371: ** that matches pKey,nKey. Return the data for this element if it is
22372: ** found, or NULL if there is no match.
22373: */
22374: SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey, int nKey){
22375: HashElem *elem; /* The element that matches key */
22376: unsigned int h; /* A hash on key */
22377:
22378: assert( pH!=0 );
22379: assert( pKey!=0 );
22380: assert( nKey>=0 );
22381: if( pH->ht ){
22382: h = strHash(pKey, nKey) % pH->htsize;
22383: }else{
22384: h = 0;
22385: }
22386: elem = findElementGivenHash(pH, pKey, nKey, h);
22387: return elem ? elem->data : 0;
22388: }
22389:
22390: /* Insert an element into the hash table pH. The key is pKey,nKey
22391: ** and the data is "data".
22392: **
22393: ** If no element exists with a matching key, then a new
22394: ** element is created and NULL is returned.
22395: **
22396: ** If another element already exists with the same key, then the
22397: ** new data replaces the old data and the old data is returned.
22398: ** The key is not copied in this instance. If a malloc fails, then
22399: ** the new data is returned and the hash table is unchanged.
22400: **
22401: ** If the "data" parameter to this function is NULL, then the
22402: ** element corresponding to "key" is removed from the hash table.
22403: */
22404: SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, int nKey, void *data){
22405: unsigned int h; /* the hash of the key modulo hash table size */
22406: HashElem *elem; /* Used to loop thru the element list */
22407: HashElem *new_elem; /* New element added to the pH */
22408:
22409: assert( pH!=0 );
22410: assert( pKey!=0 );
22411: assert( nKey>=0 );
22412: if( pH->htsize ){
22413: h = strHash(pKey, nKey) % pH->htsize;
22414: }else{
22415: h = 0;
22416: }
22417: elem = findElementGivenHash(pH,pKey,nKey,h);
22418: if( elem ){
22419: void *old_data = elem->data;
22420: if( data==0 ){
22421: removeElementGivenHash(pH,elem,h);
22422: }else{
22423: elem->data = data;
22424: elem->pKey = pKey;
22425: assert(nKey==elem->nKey);
22426: }
22427: return old_data;
22428: }
22429: if( data==0 ) return 0;
22430: new_elem = (HashElem*)sqlite3Malloc( sizeof(HashElem) );
22431: if( new_elem==0 ) return data;
22432: new_elem->pKey = pKey;
22433: new_elem->nKey = nKey;
22434: new_elem->data = data;
22435: pH->count++;
22436: if( pH->count>=10 && pH->count > 2*pH->htsize ){
22437: if( rehash(pH, pH->count*2) ){
22438: assert( pH->htsize>0 );
22439: h = strHash(pKey, nKey) % pH->htsize;
22440: }
22441: }
22442: if( pH->ht ){
22443: insertElement(pH, &pH->ht[h], new_elem);
22444: }else{
22445: insertElement(pH, 0, new_elem);
22446: }
22447: return 0;
22448: }
22449:
22450: /************** End of hash.c ************************************************/
22451: /************** Begin file opcodes.c *****************************************/
22452: /* Automatically generated. Do not edit */
22453: /* See the mkopcodec.awk script for details. */
22454: #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
22455: SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
22456: static const char *const azName[] = { "?",
22457: /* 1 */ "Goto",
22458: /* 2 */ "Gosub",
22459: /* 3 */ "Return",
22460: /* 4 */ "Yield",
22461: /* 5 */ "HaltIfNull",
22462: /* 6 */ "Halt",
22463: /* 7 */ "Integer",
22464: /* 8 */ "Int64",
22465: /* 9 */ "String",
22466: /* 10 */ "Null",
22467: /* 11 */ "Blob",
22468: /* 12 */ "Variable",
22469: /* 13 */ "Move",
22470: /* 14 */ "Copy",
22471: /* 15 */ "SCopy",
22472: /* 16 */ "ResultRow",
22473: /* 17 */ "CollSeq",
22474: /* 18 */ "Function",
22475: /* 19 */ "Not",
22476: /* 20 */ "AddImm",
22477: /* 21 */ "MustBeInt",
22478: /* 22 */ "RealAffinity",
22479: /* 23 */ "Permutation",
22480: /* 24 */ "Compare",
22481: /* 25 */ "Jump",
22482: /* 26 */ "Once",
22483: /* 27 */ "If",
22484: /* 28 */ "IfNot",
22485: /* 29 */ "Column",
22486: /* 30 */ "Affinity",
22487: /* 31 */ "MakeRecord",
22488: /* 32 */ "Count",
22489: /* 33 */ "Savepoint",
22490: /* 34 */ "AutoCommit",
22491: /* 35 */ "Transaction",
22492: /* 36 */ "ReadCookie",
22493: /* 37 */ "SetCookie",
22494: /* 38 */ "VerifyCookie",
22495: /* 39 */ "OpenRead",
22496: /* 40 */ "OpenWrite",
22497: /* 41 */ "OpenAutoindex",
22498: /* 42 */ "OpenEphemeral",
22499: /* 43 */ "SorterOpen",
22500: /* 44 */ "OpenPseudo",
22501: /* 45 */ "Close",
22502: /* 46 */ "SeekLt",
22503: /* 47 */ "SeekLe",
22504: /* 48 */ "SeekGe",
22505: /* 49 */ "SeekGt",
22506: /* 50 */ "Seek",
22507: /* 51 */ "NotFound",
22508: /* 52 */ "Found",
22509: /* 53 */ "IsUnique",
22510: /* 54 */ "NotExists",
22511: /* 55 */ "Sequence",
22512: /* 56 */ "NewRowid",
22513: /* 57 */ "Insert",
22514: /* 58 */ "InsertInt",
22515: /* 59 */ "Delete",
22516: /* 60 */ "ResetCount",
22517: /* 61 */ "SorterCompare",
22518: /* 62 */ "SorterData",
22519: /* 63 */ "RowKey",
22520: /* 64 */ "RowData",
22521: /* 65 */ "Rowid",
22522: /* 66 */ "NullRow",
22523: /* 67 */ "Last",
22524: /* 68 */ "Or",
22525: /* 69 */ "And",
22526: /* 70 */ "SorterSort",
22527: /* 71 */ "Sort",
22528: /* 72 */ "Rewind",
22529: /* 73 */ "IsNull",
22530: /* 74 */ "NotNull",
22531: /* 75 */ "Ne",
22532: /* 76 */ "Eq",
22533: /* 77 */ "Gt",
22534: /* 78 */ "Le",
22535: /* 79 */ "Lt",
22536: /* 80 */ "Ge",
22537: /* 81 */ "SorterNext",
22538: /* 82 */ "BitAnd",
22539: /* 83 */ "BitOr",
22540: /* 84 */ "ShiftLeft",
22541: /* 85 */ "ShiftRight",
22542: /* 86 */ "Add",
22543: /* 87 */ "Subtract",
22544: /* 88 */ "Multiply",
22545: /* 89 */ "Divide",
22546: /* 90 */ "Remainder",
22547: /* 91 */ "Concat",
22548: /* 92 */ "Prev",
22549: /* 93 */ "BitNot",
22550: /* 94 */ "String8",
22551: /* 95 */ "Next",
22552: /* 96 */ "SorterInsert",
22553: /* 97 */ "IdxInsert",
22554: /* 98 */ "IdxDelete",
22555: /* 99 */ "IdxRowid",
22556: /* 100 */ "IdxLT",
22557: /* 101 */ "IdxGE",
22558: /* 102 */ "Destroy",
22559: /* 103 */ "Clear",
22560: /* 104 */ "CreateIndex",
22561: /* 105 */ "CreateTable",
22562: /* 106 */ "ParseSchema",
22563: /* 107 */ "LoadAnalysis",
22564: /* 108 */ "DropTable",
22565: /* 109 */ "DropIndex",
22566: /* 110 */ "DropTrigger",
22567: /* 111 */ "IntegrityCk",
22568: /* 112 */ "RowSetAdd",
22569: /* 113 */ "RowSetRead",
22570: /* 114 */ "RowSetTest",
22571: /* 115 */ "Program",
22572: /* 116 */ "Param",
22573: /* 117 */ "FkCounter",
22574: /* 118 */ "FkIfZero",
22575: /* 119 */ "MemMax",
22576: /* 120 */ "IfPos",
22577: /* 121 */ "IfNeg",
22578: /* 122 */ "IfZero",
22579: /* 123 */ "AggStep",
22580: /* 124 */ "AggFinal",
22581: /* 125 */ "Checkpoint",
22582: /* 126 */ "JournalMode",
22583: /* 127 */ "Vacuum",
22584: /* 128 */ "IncrVacuum",
22585: /* 129 */ "Expire",
22586: /* 130 */ "Real",
22587: /* 131 */ "TableLock",
22588: /* 132 */ "VBegin",
22589: /* 133 */ "VCreate",
22590: /* 134 */ "VDestroy",
22591: /* 135 */ "VOpen",
22592: /* 136 */ "VFilter",
22593: /* 137 */ "VColumn",
22594: /* 138 */ "VNext",
22595: /* 139 */ "VRename",
22596: /* 140 */ "VUpdate",
22597: /* 141 */ "ToText",
22598: /* 142 */ "ToBlob",
22599: /* 143 */ "ToNumeric",
22600: /* 144 */ "ToInt",
22601: /* 145 */ "ToReal",
22602: /* 146 */ "Pagecount",
22603: /* 147 */ "MaxPgcnt",
22604: /* 148 */ "Trace",
22605: /* 149 */ "Noop",
22606: /* 150 */ "Explain",
22607: };
22608: return azName[i];
22609: }
22610: #endif
22611:
22612: /************** End of opcodes.c *********************************************/
22613: /************** Begin file os_os2.c ******************************************/
22614: /*
22615: ** 2006 Feb 14
22616: **
22617: ** The author disclaims copyright to this source code. In place of
22618: ** a legal notice, here is a blessing:
22619: **
22620: ** May you do good and not evil.
22621: ** May you find forgiveness for yourself and forgive others.
22622: ** May you share freely, never taking more than you give.
22623: **
22624: ******************************************************************************
22625: **
22626: ** This file contains code that is specific to OS/2.
22627: */
22628:
22629:
22630: #if SQLITE_OS_OS2
22631:
22632: /*
22633: ** A Note About Memory Allocation:
22634: **
22635: ** This driver uses malloc()/free() directly rather than going through
22636: ** the SQLite-wrappers sqlite3_malloc()/sqlite3_free(). Those wrappers
22637: ** are designed for use on embedded systems where memory is scarce and
22638: ** malloc failures happen frequently. OS/2 does not typically run on
22639: ** embedded systems, and when it does the developers normally have bigger
22640: ** problems to worry about than running out of memory. So there is not
22641: ** a compelling need to use the wrappers.
22642: **
22643: ** But there is a good reason to not use the wrappers. If we use the
22644: ** wrappers then we will get simulated malloc() failures within this
22645: ** driver. And that causes all kinds of problems for our tests. We
22646: ** could enhance SQLite to deal with simulated malloc failures within
22647: ** the OS driver, but the code to deal with those failure would not
22648: ** be exercised on Linux (which does not need to malloc() in the driver)
22649: ** and so we would have difficulty writing coverage tests for that
22650: ** code. Better to leave the code out, we think.
22651: **
22652: ** The point of this discussion is as follows: When creating a new
22653: ** OS layer for an embedded system, if you use this file as an example,
22654: ** avoid the use of malloc()/free(). Those routines work ok on OS/2
22655: ** desktops but not so well in embedded systems.
22656: */
22657:
22658: /*
22659: ** Macros used to determine whether or not to use threads.
22660: */
22661: #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE
22662: # define SQLITE_OS2_THREADS 1
22663: #endif
22664:
22665: /*
22666: ** Include code that is common to all os_*.c files
22667: */
22668: /************** Include os_common.h in the middle of os_os2.c ****************/
22669: /************** Begin file os_common.h ***************************************/
22670: /*
22671: ** 2004 May 22
22672: **
22673: ** The author disclaims copyright to this source code. In place of
22674: ** a legal notice, here is a blessing:
22675: **
22676: ** May you do good and not evil.
22677: ** May you find forgiveness for yourself and forgive others.
22678: ** May you share freely, never taking more than you give.
22679: **
22680: ******************************************************************************
22681: **
22682: ** This file contains macros and a little bit of code that is common to
22683: ** all of the platform-specific files (os_*.c) and is #included into those
22684: ** files.
22685: **
22686: ** This file should be #included by the os_*.c files only. It is not a
22687: ** general purpose header file.
22688: */
22689: #ifndef _OS_COMMON_H_
22690: #define _OS_COMMON_H_
22691:
22692: /*
22693: ** At least two bugs have slipped in because we changed the MEMORY_DEBUG
22694: ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
22695: ** switch. The following code should catch this problem at compile-time.
22696: */
22697: #ifdef MEMORY_DEBUG
22698: # error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead."
22699: #endif
22700:
22701: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
22702: # ifndef SQLITE_DEBUG_OS_TRACE
22703: # define SQLITE_DEBUG_OS_TRACE 0
22704: # endif
22705: int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE;
22706: # define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X
22707: #else
22708: # define OSTRACE(X)
22709: #endif
22710:
22711: /*
22712: ** Macros for performance tracing. Normally turned off. Only works
22713: ** on i486 hardware.
22714: */
22715: #ifdef SQLITE_PERFORMANCE_TRACE
22716:
22717: /*
22718: ** hwtime.h contains inline assembler code for implementing
22719: ** high-performance timing routines.
22720: */
22721: /************** Include hwtime.h in the middle of os_common.h ****************/
22722: /************** Begin file hwtime.h ******************************************/
22723: /*
22724: ** 2008 May 27
22725: **
22726: ** The author disclaims copyright to this source code. In place of
22727: ** a legal notice, here is a blessing:
22728: **
22729: ** May you do good and not evil.
22730: ** May you find forgiveness for yourself and forgive others.
22731: ** May you share freely, never taking more than you give.
22732: **
22733: ******************************************************************************
22734: **
22735: ** This file contains inline asm code for retrieving "high-performance"
22736: ** counters for x86 class CPUs.
22737: */
22738: #ifndef _HWTIME_H_
22739: #define _HWTIME_H_
22740:
22741: /*
22742: ** The following routine only works on pentium-class (or newer) processors.
22743: ** It uses the RDTSC opcode to read the cycle count value out of the
22744: ** processor and returns that value. This can be used for high-res
22745: ** profiling.
22746: */
22747: #if (defined(__GNUC__) || defined(_MSC_VER)) && \
22748: (defined(i386) || defined(__i386__) || defined(_M_IX86))
22749:
22750: #if defined(__GNUC__)
22751:
22752: __inline__ sqlite_uint64 sqlite3Hwtime(void){
22753: unsigned int lo, hi;
22754: __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
22755: return (sqlite_uint64)hi << 32 | lo;
22756: }
22757:
22758: #elif defined(_MSC_VER)
22759:
22760: __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
22761: __asm {
22762: rdtsc
22763: ret ; return value at EDX:EAX
22764: }
22765: }
22766:
22767: #endif
22768:
22769: #elif (defined(__GNUC__) && defined(__x86_64__))
22770:
22771: __inline__ sqlite_uint64 sqlite3Hwtime(void){
22772: unsigned long val;
22773: __asm__ __volatile__ ("rdtsc" : "=A" (val));
22774: return val;
22775: }
22776:
22777: #elif (defined(__GNUC__) && defined(__ppc__))
22778:
22779: __inline__ sqlite_uint64 sqlite3Hwtime(void){
22780: unsigned long long retval;
22781: unsigned long junk;
22782: __asm__ __volatile__ ("\n\
22783: 1: mftbu %1\n\
22784: mftb %L0\n\
22785: mftbu %0\n\
22786: cmpw %0,%1\n\
22787: bne 1b"
22788: : "=r" (retval), "=r" (junk));
22789: return retval;
22790: }
22791:
22792: #else
22793:
22794: #error Need implementation of sqlite3Hwtime() for your platform.
22795:
22796: /*
22797: ** To compile without implementing sqlite3Hwtime() for your platform,
22798: ** you can remove the above #error and use the following
22799: ** stub function. You will lose timing support for many
22800: ** of the debugging and testing utilities, but it should at
22801: ** least compile and run.
22802: */
22803: SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
22804:
22805: #endif
22806:
22807: #endif /* !defined(_HWTIME_H_) */
22808:
22809: /************** End of hwtime.h **********************************************/
22810: /************** Continuing where we left off in os_common.h ******************/
22811:
22812: static sqlite_uint64 g_start;
22813: static sqlite_uint64 g_elapsed;
22814: #define TIMER_START g_start=sqlite3Hwtime()
22815: #define TIMER_END g_elapsed=sqlite3Hwtime()-g_start
22816: #define TIMER_ELAPSED g_elapsed
22817: #else
22818: #define TIMER_START
22819: #define TIMER_END
22820: #define TIMER_ELAPSED ((sqlite_uint64)0)
22821: #endif
22822:
22823: /*
22824: ** If we compile with the SQLITE_TEST macro set, then the following block
22825: ** of code will give us the ability to simulate a disk I/O error. This
22826: ** is used for testing the I/O recovery logic.
22827: */
22828: #ifdef SQLITE_TEST
22829: SQLITE_API int sqlite3_io_error_hit = 0; /* Total number of I/O Errors */
22830: SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */
22831: SQLITE_API int sqlite3_io_error_pending = 0; /* Count down to first I/O error */
22832: SQLITE_API int sqlite3_io_error_persist = 0; /* True if I/O errors persist */
22833: SQLITE_API int sqlite3_io_error_benign = 0; /* True if errors are benign */
22834: SQLITE_API int sqlite3_diskfull_pending = 0;
22835: SQLITE_API int sqlite3_diskfull = 0;
22836: #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
22837: #define SimulateIOError(CODE) \
22838: if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
22839: || sqlite3_io_error_pending-- == 1 ) \
22840: { local_ioerr(); CODE; }
22841: static void local_ioerr(){
22842: IOTRACE(("IOERR\n"));
22843: sqlite3_io_error_hit++;
22844: if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
22845: }
22846: #define SimulateDiskfullError(CODE) \
22847: if( sqlite3_diskfull_pending ){ \
22848: if( sqlite3_diskfull_pending == 1 ){ \
22849: local_ioerr(); \
22850: sqlite3_diskfull = 1; \
22851: sqlite3_io_error_hit = 1; \
22852: CODE; \
22853: }else{ \
22854: sqlite3_diskfull_pending--; \
22855: } \
22856: }
22857: #else
22858: #define SimulateIOErrorBenign(X)
22859: #define SimulateIOError(A)
22860: #define SimulateDiskfullError(A)
22861: #endif
22862:
22863: /*
22864: ** When testing, keep a count of the number of open files.
22865: */
22866: #ifdef SQLITE_TEST
22867: SQLITE_API int sqlite3_open_file_count = 0;
22868: #define OpenCounter(X) sqlite3_open_file_count+=(X)
22869: #else
22870: #define OpenCounter(X)
22871: #endif
22872:
22873: #endif /* !defined(_OS_COMMON_H_) */
22874:
22875: /************** End of os_common.h *******************************************/
22876: /************** Continuing where we left off in os_os2.c *********************/
22877:
22878: /* Forward references */
22879: typedef struct os2File os2File; /* The file structure */
22880: typedef struct os2ShmNode os2ShmNode; /* A shared descritive memory node */
22881: typedef struct os2ShmLink os2ShmLink; /* A connection to shared-memory */
22882:
22883: /*
22884: ** The os2File structure is subclass of sqlite3_file specific for the OS/2
22885: ** protability layer.
22886: */
22887: struct os2File {
22888: const sqlite3_io_methods *pMethod; /* Always the first entry */
22889: HFILE h; /* Handle for accessing the file */
22890: int flags; /* Flags provided to os2Open() */
22891: int locktype; /* Type of lock currently held on this file */
22892: int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */
22893: char *zFullPathCp; /* Full path name of this file */
22894: os2ShmLink *pShmLink; /* Instance of shared memory on this file */
22895: };
22896:
22897: #define LOCK_TIMEOUT 10L /* the default locking timeout */
22898:
22899: /*
22900: ** Missing from some versions of the OS/2 toolkit -
22901: ** used to allocate from high memory if possible
22902: */
22903: #ifndef OBJ_ANY
22904: # define OBJ_ANY 0x00000400
22905: #endif
22906:
22907: /*****************************************************************************
22908: ** The next group of routines implement the I/O methods specified
22909: ** by the sqlite3_io_methods object.
22910: ******************************************************************************/
22911:
22912: /*
22913: ** Close a file.
22914: */
22915: static int os2Close( sqlite3_file *id ){
22916: APIRET rc;
22917: os2File *pFile = (os2File*)id;
22918:
22919: assert( id!=0 );
22920: OSTRACE(( "CLOSE %d (%s)\n", pFile->h, pFile->zFullPathCp ));
22921:
22922: rc = DosClose( pFile->h );
22923:
22924: if( pFile->flags & SQLITE_OPEN_DELETEONCLOSE )
22925: DosForceDelete( (PSZ)pFile->zFullPathCp );
22926:
22927: free( pFile->zFullPathCp );
22928: pFile->zFullPathCp = NULL;
22929: pFile->locktype = NO_LOCK;
22930: pFile->h = (HFILE)-1;
22931: pFile->flags = 0;
22932:
22933: OpenCounter( -1 );
22934: return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
22935: }
22936:
22937: /*
22938: ** Read data from a file into a buffer. Return SQLITE_OK if all
22939: ** bytes were read successfully and SQLITE_IOERR if anything goes
22940: ** wrong.
22941: */
22942: static int os2Read(
22943: sqlite3_file *id, /* File to read from */
22944: void *pBuf, /* Write content into this buffer */
22945: int amt, /* Number of bytes to read */
22946: sqlite3_int64 offset /* Begin reading at this offset */
22947: ){
22948: ULONG fileLocation = 0L;
22949: ULONG got;
22950: os2File *pFile = (os2File*)id;
22951: assert( id!=0 );
22952: SimulateIOError( return SQLITE_IOERR_READ );
22953: OSTRACE(( "READ %d lock=%d\n", pFile->h, pFile->locktype ));
22954: if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
22955: return SQLITE_IOERR;
22956: }
22957: if( DosRead( pFile->h, pBuf, amt, &got ) != NO_ERROR ){
22958: return SQLITE_IOERR_READ;
22959: }
22960: if( got == (ULONG)amt )
22961: return SQLITE_OK;
22962: else {
22963: /* Unread portions of the input buffer must be zero-filled */
22964: memset(&((char*)pBuf)[got], 0, amt-got);
22965: return SQLITE_IOERR_SHORT_READ;
22966: }
22967: }
22968:
22969: /*
22970: ** Write data from a buffer into a file. Return SQLITE_OK on success
22971: ** or some other error code on failure.
22972: */
22973: static int os2Write(
22974: sqlite3_file *id, /* File to write into */
22975: const void *pBuf, /* The bytes to be written */
22976: int amt, /* Number of bytes to write */
22977: sqlite3_int64 offset /* Offset into the file to begin writing at */
22978: ){
22979: ULONG fileLocation = 0L;
22980: APIRET rc = NO_ERROR;
22981: ULONG wrote;
22982: os2File *pFile = (os2File*)id;
22983: assert( id!=0 );
22984: SimulateIOError( return SQLITE_IOERR_WRITE );
22985: SimulateDiskfullError( return SQLITE_FULL );
22986: OSTRACE(( "WRITE %d lock=%d\n", pFile->h, pFile->locktype ));
22987: if( DosSetFilePtr(pFile->h, offset, FILE_BEGIN, &fileLocation) != NO_ERROR ){
22988: return SQLITE_IOERR;
22989: }
22990: assert( amt>0 );
22991: while( amt > 0 &&
22992: ( rc = DosWrite( pFile->h, (PVOID)pBuf, amt, &wrote ) ) == NO_ERROR &&
22993: wrote > 0
22994: ){
22995: amt -= wrote;
22996: pBuf = &((char*)pBuf)[wrote];
22997: }
22998:
22999: return ( rc != NO_ERROR || amt > (int)wrote ) ? SQLITE_FULL : SQLITE_OK;
23000: }
23001:
23002: /*
23003: ** Truncate an open file to a specified size
23004: */
23005: static int os2Truncate( sqlite3_file *id, i64 nByte ){
23006: APIRET rc;
23007: os2File *pFile = (os2File*)id;
23008: assert( id!=0 );
23009: OSTRACE(( "TRUNCATE %d %lld\n", pFile->h, nByte ));
23010: SimulateIOError( return SQLITE_IOERR_TRUNCATE );
23011:
23012: /* If the user has configured a chunk-size for this file, truncate the
23013: ** file so that it consists of an integer number of chunks (i.e. the
23014: ** actual file size after the operation may be larger than the requested
23015: ** size).
23016: */
23017: if( pFile->szChunk ){
23018: nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
23019: }
23020:
23021: rc = DosSetFileSize( pFile->h, nByte );
23022: return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR_TRUNCATE;
23023: }
23024:
23025: #ifdef SQLITE_TEST
23026: /*
23027: ** Count the number of fullsyncs and normal syncs. This is used to test
23028: ** that syncs and fullsyncs are occuring at the right times.
23029: */
23030: SQLITE_API int sqlite3_sync_count = 0;
23031: SQLITE_API int sqlite3_fullsync_count = 0;
23032: #endif
23033:
23034: /*
23035: ** Make sure all writes to a particular file are committed to disk.
23036: */
23037: static int os2Sync( sqlite3_file *id, int flags ){
23038: os2File *pFile = (os2File*)id;
23039: OSTRACE(( "SYNC %d lock=%d\n", pFile->h, pFile->locktype ));
23040: #ifdef SQLITE_TEST
23041: if( flags & SQLITE_SYNC_FULL){
23042: sqlite3_fullsync_count++;
23043: }
23044: sqlite3_sync_count++;
23045: #endif
23046: /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
23047: ** no-op
23048: */
23049: #ifdef SQLITE_NO_SYNC
23050: UNUSED_PARAMETER(pFile);
23051: return SQLITE_OK;
23052: #else
23053: return DosResetBuffer( pFile->h ) == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
23054: #endif
23055: }
23056:
23057: /*
23058: ** Determine the current size of a file in bytes
23059: */
23060: static int os2FileSize( sqlite3_file *id, sqlite3_int64 *pSize ){
23061: APIRET rc = NO_ERROR;
23062: FILESTATUS3 fsts3FileInfo;
23063: memset(&fsts3FileInfo, 0, sizeof(fsts3FileInfo));
23064: assert( id!=0 );
23065: SimulateIOError( return SQLITE_IOERR_FSTAT );
23066: rc = DosQueryFileInfo( ((os2File*)id)->h, FIL_STANDARD, &fsts3FileInfo, sizeof(FILESTATUS3) );
23067: if( rc == NO_ERROR ){
23068: *pSize = fsts3FileInfo.cbFile;
23069: return SQLITE_OK;
23070: }else{
23071: return SQLITE_IOERR_FSTAT;
23072: }
23073: }
23074:
23075: /*
23076: ** Acquire a reader lock.
23077: */
23078: static int getReadLock( os2File *pFile ){
23079: FILELOCK LockArea,
23080: UnlockArea;
23081: APIRET res;
23082: memset(&LockArea, 0, sizeof(LockArea));
23083: memset(&UnlockArea, 0, sizeof(UnlockArea));
23084: LockArea.lOffset = SHARED_FIRST;
23085: LockArea.lRange = SHARED_SIZE;
23086: UnlockArea.lOffset = 0L;
23087: UnlockArea.lRange = 0L;
23088: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
23089: OSTRACE(( "GETREADLOCK %d res=%d\n", pFile->h, res ));
23090: return res;
23091: }
23092:
23093: /*
23094: ** Undo a readlock
23095: */
23096: static int unlockReadLock( os2File *id ){
23097: FILELOCK LockArea,
23098: UnlockArea;
23099: APIRET res;
23100: memset(&LockArea, 0, sizeof(LockArea));
23101: memset(&UnlockArea, 0, sizeof(UnlockArea));
23102: LockArea.lOffset = 0L;
23103: LockArea.lRange = 0L;
23104: UnlockArea.lOffset = SHARED_FIRST;
23105: UnlockArea.lRange = SHARED_SIZE;
23106: res = DosSetFileLocks( id->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 1L );
23107: OSTRACE(( "UNLOCK-READLOCK file handle=%d res=%d?\n", id->h, res ));
23108: return res;
23109: }
23110:
23111: /*
23112: ** Lock the file with the lock specified by parameter locktype - one
23113: ** of the following:
23114: **
23115: ** (1) SHARED_LOCK
23116: ** (2) RESERVED_LOCK
23117: ** (3) PENDING_LOCK
23118: ** (4) EXCLUSIVE_LOCK
23119: **
23120: ** Sometimes when requesting one lock state, additional lock states
23121: ** are inserted in between. The locking might fail on one of the later
23122: ** transitions leaving the lock state different from what it started but
23123: ** still short of its goal. The following chart shows the allowed
23124: ** transitions and the inserted intermediate states:
23125: **
23126: ** UNLOCKED -> SHARED
23127: ** SHARED -> RESERVED
23128: ** SHARED -> (PENDING) -> EXCLUSIVE
23129: ** RESERVED -> (PENDING) -> EXCLUSIVE
23130: ** PENDING -> EXCLUSIVE
23131: **
23132: ** This routine will only increase a lock. The os2Unlock() routine
23133: ** erases all locks at once and returns us immediately to locking level 0.
23134: ** It is not possible to lower the locking level one step at a time. You
23135: ** must go straight to locking level 0.
23136: */
23137: static int os2Lock( sqlite3_file *id, int locktype ){
23138: int rc = SQLITE_OK; /* Return code from subroutines */
23139: APIRET res = NO_ERROR; /* Result of an OS/2 lock call */
23140: int newLocktype; /* Set pFile->locktype to this value before exiting */
23141: int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
23142: FILELOCK LockArea,
23143: UnlockArea;
23144: os2File *pFile = (os2File*)id;
23145: memset(&LockArea, 0, sizeof(LockArea));
23146: memset(&UnlockArea, 0, sizeof(UnlockArea));
23147: assert( pFile!=0 );
23148: OSTRACE(( "LOCK %d %d was %d\n", pFile->h, locktype, pFile->locktype ));
23149:
23150: /* If there is already a lock of this type or more restrictive on the
23151: ** os2File, do nothing. Don't use the end_lock: exit path, as
23152: ** sqlite3_mutex_enter() hasn't been called yet.
23153: */
23154: if( pFile->locktype>=locktype ){
23155: OSTRACE(( "LOCK %d %d ok (already held)\n", pFile->h, locktype ));
23156: return SQLITE_OK;
23157: }
23158:
23159: /* Make sure the locking sequence is correct
23160: */
23161: assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
23162: assert( locktype!=PENDING_LOCK );
23163: assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
23164:
23165: /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
23166: ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
23167: ** the PENDING_LOCK byte is temporary.
23168: */
23169: newLocktype = pFile->locktype;
23170: if( pFile->locktype==NO_LOCK
23171: || (locktype==EXCLUSIVE_LOCK && pFile->locktype==RESERVED_LOCK)
23172: ){
23173: LockArea.lOffset = PENDING_BYTE;
23174: LockArea.lRange = 1L;
23175: UnlockArea.lOffset = 0L;
23176: UnlockArea.lRange = 0L;
23177:
23178: /* wait longer than LOCK_TIMEOUT here not to have to try multiple times */
23179: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, 100L, 0L );
23180: if( res == NO_ERROR ){
23181: gotPendingLock = 1;
23182: OSTRACE(( "LOCK %d pending lock boolean set. res=%d\n", pFile->h, res ));
23183: }
23184: }
23185:
23186: /* Acquire a shared lock
23187: */
23188: if( locktype==SHARED_LOCK && res == NO_ERROR ){
23189: assert( pFile->locktype==NO_LOCK );
23190: res = getReadLock(pFile);
23191: if( res == NO_ERROR ){
23192: newLocktype = SHARED_LOCK;
23193: }
23194: OSTRACE(( "LOCK %d acquire shared lock. res=%d\n", pFile->h, res ));
23195: }
23196:
23197: /* Acquire a RESERVED lock
23198: */
23199: if( locktype==RESERVED_LOCK && res == NO_ERROR ){
23200: assert( pFile->locktype==SHARED_LOCK );
23201: LockArea.lOffset = RESERVED_BYTE;
23202: LockArea.lRange = 1L;
23203: UnlockArea.lOffset = 0L;
23204: UnlockArea.lRange = 0L;
23205: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23206: if( res == NO_ERROR ){
23207: newLocktype = RESERVED_LOCK;
23208: }
23209: OSTRACE(( "LOCK %d acquire reserved lock. res=%d\n", pFile->h, res ));
23210: }
23211:
23212: /* Acquire a PENDING lock
23213: */
23214: if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
23215: newLocktype = PENDING_LOCK;
23216: gotPendingLock = 0;
23217: OSTRACE(( "LOCK %d acquire pending lock. pending lock boolean unset.\n",
23218: pFile->h ));
23219: }
23220:
23221: /* Acquire an EXCLUSIVE lock
23222: */
23223: if( locktype==EXCLUSIVE_LOCK && res == NO_ERROR ){
23224: assert( pFile->locktype>=SHARED_LOCK );
23225: res = unlockReadLock(pFile);
23226: OSTRACE(( "unreadlock = %d\n", res ));
23227: LockArea.lOffset = SHARED_FIRST;
23228: LockArea.lRange = SHARED_SIZE;
23229: UnlockArea.lOffset = 0L;
23230: UnlockArea.lRange = 0L;
23231: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23232: if( res == NO_ERROR ){
23233: newLocktype = EXCLUSIVE_LOCK;
23234: }else{
23235: OSTRACE(( "OS/2 error-code = %d\n", res ));
23236: getReadLock(pFile);
23237: }
23238: OSTRACE(( "LOCK %d acquire exclusive lock. res=%d\n", pFile->h, res ));
23239: }
23240:
23241: /* If we are holding a PENDING lock that ought to be released, then
23242: ** release it now.
23243: */
23244: if( gotPendingLock && locktype==SHARED_LOCK ){
23245: int r;
23246: LockArea.lOffset = 0L;
23247: LockArea.lRange = 0L;
23248: UnlockArea.lOffset = PENDING_BYTE;
23249: UnlockArea.lRange = 1L;
23250: r = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23251: OSTRACE(( "LOCK %d unlocking pending/is shared. r=%d\n", pFile->h, r ));
23252: }
23253:
23254: /* Update the state of the lock has held in the file descriptor then
23255: ** return the appropriate result code.
23256: */
23257: if( res == NO_ERROR ){
23258: rc = SQLITE_OK;
23259: }else{
23260: OSTRACE(( "LOCK FAILED %d trying for %d but got %d\n", pFile->h,
23261: locktype, newLocktype ));
23262: rc = SQLITE_BUSY;
23263: }
23264: pFile->locktype = newLocktype;
23265: OSTRACE(( "LOCK %d now %d\n", pFile->h, pFile->locktype ));
23266: return rc;
23267: }
23268:
23269: /*
23270: ** This routine checks if there is a RESERVED lock held on the specified
23271: ** file by this or any other process. If such a lock is held, return
23272: ** non-zero, otherwise zero.
23273: */
23274: static int os2CheckReservedLock( sqlite3_file *id, int *pOut ){
23275: int r = 0;
23276: os2File *pFile = (os2File*)id;
23277: assert( pFile!=0 );
23278: if( pFile->locktype>=RESERVED_LOCK ){
23279: r = 1;
23280: OSTRACE(( "TEST WR-LOCK %d %d (local)\n", pFile->h, r ));
23281: }else{
23282: FILELOCK LockArea,
23283: UnlockArea;
23284: APIRET rc = NO_ERROR;
23285: memset(&LockArea, 0, sizeof(LockArea));
23286: memset(&UnlockArea, 0, sizeof(UnlockArea));
23287: LockArea.lOffset = RESERVED_BYTE;
23288: LockArea.lRange = 1L;
23289: UnlockArea.lOffset = 0L;
23290: UnlockArea.lRange = 0L;
23291: rc = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23292: OSTRACE(( "TEST WR-LOCK %d lock reserved byte rc=%d\n", pFile->h, rc ));
23293: if( rc == NO_ERROR ){
23294: APIRET rcu = NO_ERROR; /* return code for unlocking */
23295: LockArea.lOffset = 0L;
23296: LockArea.lRange = 0L;
23297: UnlockArea.lOffset = RESERVED_BYTE;
23298: UnlockArea.lRange = 1L;
23299: rcu = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23300: OSTRACE(( "TEST WR-LOCK %d unlock reserved byte r=%d\n", pFile->h, rcu ));
23301: }
23302: r = !(rc == NO_ERROR);
23303: OSTRACE(( "TEST WR-LOCK %d %d (remote)\n", pFile->h, r ));
23304: }
23305: *pOut = r;
23306: return SQLITE_OK;
23307: }
23308:
23309: /*
23310: ** Lower the locking level on file descriptor id to locktype. locktype
23311: ** must be either NO_LOCK or SHARED_LOCK.
23312: **
23313: ** If the locking level of the file descriptor is already at or below
23314: ** the requested locking level, this routine is a no-op.
23315: **
23316: ** It is not possible for this routine to fail if the second argument
23317: ** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
23318: ** might return SQLITE_IOERR;
23319: */
23320: static int os2Unlock( sqlite3_file *id, int locktype ){
23321: int type;
23322: os2File *pFile = (os2File*)id;
23323: APIRET rc = SQLITE_OK;
23324: APIRET res = NO_ERROR;
23325: FILELOCK LockArea,
23326: UnlockArea;
23327: memset(&LockArea, 0, sizeof(LockArea));
23328: memset(&UnlockArea, 0, sizeof(UnlockArea));
23329: assert( pFile!=0 );
23330: assert( locktype<=SHARED_LOCK );
23331: OSTRACE(( "UNLOCK %d to %d was %d\n", pFile->h, locktype, pFile->locktype ));
23332: type = pFile->locktype;
23333: if( type>=EXCLUSIVE_LOCK ){
23334: LockArea.lOffset = 0L;
23335: LockArea.lRange = 0L;
23336: UnlockArea.lOffset = SHARED_FIRST;
23337: UnlockArea.lRange = SHARED_SIZE;
23338: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23339: OSTRACE(( "UNLOCK %d exclusive lock res=%d\n", pFile->h, res ));
23340: if( locktype==SHARED_LOCK && getReadLock(pFile) != NO_ERROR ){
23341: /* This should never happen. We should always be able to
23342: ** reacquire the read lock */
23343: OSTRACE(( "UNLOCK %d to %d getReadLock() failed\n", pFile->h, locktype ));
23344: rc = SQLITE_IOERR_UNLOCK;
23345: }
23346: }
23347: if( type>=RESERVED_LOCK ){
23348: LockArea.lOffset = 0L;
23349: LockArea.lRange = 0L;
23350: UnlockArea.lOffset = RESERVED_BYTE;
23351: UnlockArea.lRange = 1L;
23352: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23353: OSTRACE(( "UNLOCK %d reserved res=%d\n", pFile->h, res ));
23354: }
23355: if( locktype==NO_LOCK && type>=SHARED_LOCK ){
23356: res = unlockReadLock(pFile);
23357: OSTRACE(( "UNLOCK %d is %d want %d res=%d\n",
23358: pFile->h, type, locktype, res ));
23359: }
23360: if( type>=PENDING_LOCK ){
23361: LockArea.lOffset = 0L;
23362: LockArea.lRange = 0L;
23363: UnlockArea.lOffset = PENDING_BYTE;
23364: UnlockArea.lRange = 1L;
23365: res = DosSetFileLocks( pFile->h, &UnlockArea, &LockArea, LOCK_TIMEOUT, 0L );
23366: OSTRACE(( "UNLOCK %d pending res=%d\n", pFile->h, res ));
23367: }
23368: pFile->locktype = locktype;
23369: OSTRACE(( "UNLOCK %d now %d\n", pFile->h, pFile->locktype ));
23370: return rc;
23371: }
23372:
23373: /*
23374: ** Control and query of the open file handle.
23375: */
23376: static int os2FileControl(sqlite3_file *id, int op, void *pArg){
23377: switch( op ){
23378: case SQLITE_FCNTL_LOCKSTATE: {
23379: *(int*)pArg = ((os2File*)id)->locktype;
23380: OSTRACE(( "FCNTL_LOCKSTATE %d lock=%d\n",
23381: ((os2File*)id)->h, ((os2File*)id)->locktype ));
23382: return SQLITE_OK;
23383: }
23384: case SQLITE_FCNTL_CHUNK_SIZE: {
23385: ((os2File*)id)->szChunk = *(int*)pArg;
23386: return SQLITE_OK;
23387: }
23388: case SQLITE_FCNTL_SIZE_HINT: {
23389: sqlite3_int64 sz = *(sqlite3_int64*)pArg;
23390: SimulateIOErrorBenign(1);
23391: os2Truncate(id, sz);
23392: SimulateIOErrorBenign(0);
23393: return SQLITE_OK;
23394: }
23395: case SQLITE_FCNTL_SYNC_OMITTED: {
23396: return SQLITE_OK;
23397: }
23398: }
23399: return SQLITE_NOTFOUND;
23400: }
23401:
23402: /*
23403: ** Return the sector size in bytes of the underlying block device for
23404: ** the specified file. This is almost always 512 bytes, but may be
23405: ** larger for some devices.
23406: **
23407: ** SQLite code assumes this function cannot fail. It also assumes that
23408: ** if two files are created in the same file-system directory (i.e.
23409: ** a database and its journal file) that the sector size will be the
23410: ** same for both.
23411: */
23412: static int os2SectorSize(sqlite3_file *id){
23413: UNUSED_PARAMETER(id);
23414: return SQLITE_DEFAULT_SECTOR_SIZE;
23415: }
23416:
23417: /*
23418: ** Return a vector of device characteristics.
23419: */
23420: static int os2DeviceCharacteristics(sqlite3_file *id){
23421: UNUSED_PARAMETER(id);
23422: return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN;
23423: }
23424:
23425:
23426: /*
23427: ** Character set conversion objects used by conversion routines.
23428: */
23429: static UconvObject ucUtf8 = NULL; /* convert between UTF-8 and UCS-2 */
23430: static UconvObject uclCp = NULL; /* convert between local codepage and UCS-2 */
23431:
23432: /*
23433: ** Helper function to initialize the conversion objects from and to UTF-8.
23434: */
23435: static void initUconvObjects( void ){
23436: if( UniCreateUconvObject( UTF_8, &ucUtf8 ) != ULS_SUCCESS )
23437: ucUtf8 = NULL;
23438: if ( UniCreateUconvObject( (UniChar *)L"@path=yes", &uclCp ) != ULS_SUCCESS )
23439: uclCp = NULL;
23440: }
23441:
23442: /*
23443: ** Helper function to free the conversion objects from and to UTF-8.
23444: */
23445: static void freeUconvObjects( void ){
23446: if ( ucUtf8 )
23447: UniFreeUconvObject( ucUtf8 );
23448: if ( uclCp )
23449: UniFreeUconvObject( uclCp );
23450: ucUtf8 = NULL;
23451: uclCp = NULL;
23452: }
23453:
23454: /*
23455: ** Helper function to convert UTF-8 filenames to local OS/2 codepage.
23456: ** The two-step process: first convert the incoming UTF-8 string
23457: ** into UCS-2 and then from UCS-2 to the current codepage.
23458: ** The returned char pointer has to be freed.
23459: */
23460: static char *convertUtf8PathToCp( const char *in ){
23461: UniChar tempPath[CCHMAXPATH];
23462: char *out = (char *)calloc( CCHMAXPATH, 1 );
23463:
23464: if( !out )
23465: return NULL;
23466:
23467: if( !ucUtf8 || !uclCp )
23468: initUconvObjects();
23469:
23470: /* determine string for the conversion of UTF-8 which is CP1208 */
23471: if( UniStrToUcs( ucUtf8, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
23472: return out; /* if conversion fails, return the empty string */
23473:
23474: /* conversion for current codepage which can be used for paths */
23475: UniStrFromUcs( uclCp, out, tempPath, CCHMAXPATH );
23476:
23477: return out;
23478: }
23479:
23480: /*
23481: ** Helper function to convert filenames from local codepage to UTF-8.
23482: ** The two-step process: first convert the incoming codepage-specific
23483: ** string into UCS-2 and then from UCS-2 to the codepage of UTF-8.
23484: ** The returned char pointer has to be freed.
23485: **
23486: ** This function is non-static to be able to use this in shell.c and
23487: ** similar applications that take command line arguments.
23488: */
23489: char *convertCpPathToUtf8( const char *in ){
23490: UniChar tempPath[CCHMAXPATH];
23491: char *out = (char *)calloc( CCHMAXPATH, 1 );
23492:
23493: if( !out )
23494: return NULL;
23495:
23496: if( !ucUtf8 || !uclCp )
23497: initUconvObjects();
23498:
23499: /* conversion for current codepage which can be used for paths */
23500: if( UniStrToUcs( uclCp, tempPath, (char *)in, CCHMAXPATH ) != ULS_SUCCESS )
23501: return out; /* if conversion fails, return the empty string */
23502:
23503: /* determine string for the conversion of UTF-8 which is CP1208 */
23504: UniStrFromUcs( ucUtf8, out, tempPath, CCHMAXPATH );
23505:
23506: return out;
23507: }
23508:
23509:
23510: #ifndef SQLITE_OMIT_WAL
23511:
23512: /*
23513: ** Use main database file for interprocess locking. If un-defined
23514: ** a separate file is created for this purpose. The file will be
23515: ** used only to set file locks. There will be no data written to it.
23516: */
23517: #define SQLITE_OS2_NO_WAL_LOCK_FILE
23518:
23519: #if 0
23520: static void _ERR_TRACE( const char *fmt, ... ) {
23521: va_list ap;
23522: va_start(ap, fmt);
23523: vfprintf(stderr, fmt, ap);
23524: fflush(stderr);
23525: }
23526: #define ERR_TRACE(rc, msg) \
23527: if( (rc) != SQLITE_OK ) _ERR_TRACE msg;
23528: #else
23529: #define ERR_TRACE(rc, msg)
23530: #endif
23531:
23532: /*
23533: ** Helper functions to obtain and relinquish the global mutex. The
23534: ** global mutex is used to protect os2ShmNodeList.
23535: **
23536: ** Function os2ShmMutexHeld() is used to assert() that the global mutex
23537: ** is held when required. This function is only used as part of assert()
23538: ** statements. e.g.
23539: **
23540: ** os2ShmEnterMutex()
23541: ** assert( os2ShmMutexHeld() );
23542: ** os2ShmLeaveMutex()
23543: */
23544: static void os2ShmEnterMutex(void){
23545: sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
23546: }
23547: static void os2ShmLeaveMutex(void){
23548: sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
23549: }
23550: #ifdef SQLITE_DEBUG
23551: static int os2ShmMutexHeld(void) {
23552: return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
23553: }
23554: int GetCurrentProcessId(void) {
23555: PPIB pib;
23556: DosGetInfoBlocks(NULL, &pib);
23557: return (int)pib->pib_ulpid;
23558: }
23559: #endif
23560:
23561: /*
23562: ** Object used to represent a the shared memory area for a single log file.
23563: ** When multiple threads all reference the same log-summary, each thread has
23564: ** its own os2File object, but they all point to a single instance of this
23565: ** object. In other words, each log-summary is opened only once per process.
23566: **
23567: ** os2ShmMutexHeld() must be true when creating or destroying
23568: ** this object or while reading or writing the following fields:
23569: **
23570: ** nRef
23571: ** pNext
23572: **
23573: ** The following fields are read-only after the object is created:
23574: **
23575: ** szRegion
23576: ** hLockFile
23577: ** shmBaseName
23578: **
23579: ** Either os2ShmNode.mutex must be held or os2ShmNode.nRef==0 and
23580: ** os2ShmMutexHeld() is true when reading or writing any other field
23581: ** in this structure.
23582: **
23583: */
23584: struct os2ShmNode {
23585: sqlite3_mutex *mutex; /* Mutex to access this object */
23586: os2ShmNode *pNext; /* Next in list of all os2ShmNode objects */
23587:
23588: int szRegion; /* Size of shared-memory regions */
23589:
23590: int nRegion; /* Size of array apRegion */
23591: void **apRegion; /* Array of pointers to shared-memory regions */
23592:
23593: int nRef; /* Number of os2ShmLink objects pointing to this */
23594: os2ShmLink *pFirst; /* First os2ShmLink object pointing to this */
23595:
23596: HFILE hLockFile; /* File used for inter-process memory locking */
23597: char shmBaseName[1]; /* Name of the memory object !!! must last !!! */
23598: };
23599:
23600:
23601: /*
23602: ** Structure used internally by this VFS to record the state of an
23603: ** open shared memory connection.
23604: **
23605: ** The following fields are initialized when this object is created and
23606: ** are read-only thereafter:
23607: **
23608: ** os2Shm.pShmNode
23609: ** os2Shm.id
23610: **
23611: ** All other fields are read/write. The os2Shm.pShmNode->mutex must be held
23612: ** while accessing any read/write fields.
23613: */
23614: struct os2ShmLink {
23615: os2ShmNode *pShmNode; /* The underlying os2ShmNode object */
23616: os2ShmLink *pNext; /* Next os2Shm with the same os2ShmNode */
23617: u32 sharedMask; /* Mask of shared locks held */
23618: u32 exclMask; /* Mask of exclusive locks held */
23619: #ifdef SQLITE_DEBUG
23620: u8 id; /* Id of this connection with its os2ShmNode */
23621: #endif
23622: };
23623:
23624:
23625: /*
23626: ** A global list of all os2ShmNode objects.
23627: **
23628: ** The os2ShmMutexHeld() must be true while reading or writing this list.
23629: */
23630: static os2ShmNode *os2ShmNodeList = NULL;
23631:
23632: /*
23633: ** Constants used for locking
23634: */
23635: #ifdef SQLITE_OS2_NO_WAL_LOCK_FILE
23636: #define OS2_SHM_BASE (PENDING_BYTE + 0x10000) /* first lock byte */
23637: #else
23638: #define OS2_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */
23639: #endif
23640:
23641: #define OS2_SHM_DMS (OS2_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */
23642:
23643: /*
23644: ** Apply advisory locks for all n bytes beginning at ofst.
23645: */
23646: #define _SHM_UNLCK 1 /* no lock */
23647: #define _SHM_RDLCK 2 /* shared lock, no wait */
23648: #define _SHM_WRLCK 3 /* exlusive lock, no wait */
23649: #define _SHM_WRLCK_WAIT 4 /* exclusive lock, wait */
23650: static int os2ShmSystemLock(
23651: os2ShmNode *pNode, /* Apply locks to this open shared-memory segment */
23652: int lockType, /* _SHM_UNLCK, _SHM_RDLCK, _SHM_WRLCK or _SHM_WRLCK_WAIT */
23653: int ofst, /* Offset to first byte to be locked/unlocked */
23654: int nByte /* Number of bytes to lock or unlock */
23655: ){
23656: APIRET rc;
23657: FILELOCK area;
23658: ULONG mode, timeout;
23659:
23660: /* Access to the os2ShmNode object is serialized by the caller */
23661: assert( sqlite3_mutex_held(pNode->mutex) || pNode->nRef==0 );
23662:
23663: mode = 1; /* shared lock */
23664: timeout = 0; /* no wait */
23665: area.lOffset = ofst;
23666: area.lRange = nByte;
23667:
23668: switch( lockType ) {
23669: case _SHM_WRLCK_WAIT:
23670: timeout = (ULONG)-1; /* wait forever */
23671: case _SHM_WRLCK:
23672: mode = 0; /* exclusive lock */
23673: case _SHM_RDLCK:
23674: rc = DosSetFileLocks(pNode->hLockFile,
23675: NULL, &area, timeout, mode);
23676: break;
23677: /* case _SHM_UNLCK: */
23678: default:
23679: rc = DosSetFileLocks(pNode->hLockFile,
23680: &area, NULL, 0, 0);
23681: break;
23682: }
23683:
23684: OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
23685: pNode->hLockFile,
23686: rc==SQLITE_OK ? "ok" : "failed",
23687: lockType==_SHM_UNLCK ? "Unlock" : "Lock",
23688: rc));
23689:
23690: ERR_TRACE(rc, ("os2ShmSystemLock: %d %s\n", rc, pNode->shmBaseName))
23691:
23692: return ( rc == 0 ) ? SQLITE_OK : SQLITE_BUSY;
23693: }
23694:
23695: /*
23696: ** Find an os2ShmNode in global list or allocate a new one, if not found.
23697: **
23698: ** This is not a VFS shared-memory method; it is a utility function called
23699: ** by VFS shared-memory methods.
23700: */
23701: static int os2OpenSharedMemory( os2File *fd, int szRegion ) {
23702: os2ShmLink *pLink;
23703: os2ShmNode *pNode;
23704: int cbShmName, rc = SQLITE_OK;
23705: char shmName[CCHMAXPATH + 30];
23706: #ifndef SQLITE_OS2_NO_WAL_LOCK_FILE
23707: ULONG action;
23708: #endif
23709:
23710: /* We need some additional space at the end to append the region number */
23711: cbShmName = sprintf(shmName, "\\SHAREMEM\\%s", fd->zFullPathCp );
23712: if( cbShmName >= CCHMAXPATH-8 )
23713: return SQLITE_IOERR_SHMOPEN;
23714:
23715: /* Replace colon in file name to form a valid shared memory name */
23716: shmName[10+1] = '!';
23717:
23718: /* Allocate link object (we free it later in case of failure) */
23719: pLink = sqlite3_malloc( sizeof(*pLink) );
23720: if( !pLink )
23721: return SQLITE_NOMEM;
23722:
23723: /* Access node list */
23724: os2ShmEnterMutex();
23725:
23726: /* Find node by it's shared memory base name */
23727: for( pNode = os2ShmNodeList;
23728: pNode && stricmp(shmName, pNode->shmBaseName) != 0;
23729: pNode = pNode->pNext ) ;
23730:
23731: /* Not found: allocate a new node */
23732: if( !pNode ) {
23733: pNode = sqlite3_malloc( sizeof(*pNode) + cbShmName );
23734: if( pNode ) {
23735: memset(pNode, 0, sizeof(*pNode) );
23736: pNode->szRegion = szRegion;
23737: pNode->hLockFile = (HFILE)-1;
23738: strcpy(pNode->shmBaseName, shmName);
23739:
23740: #ifdef SQLITE_OS2_NO_WAL_LOCK_FILE
23741: if( DosDupHandle(fd->h, &pNode->hLockFile) != 0 ) {
23742: #else
23743: sprintf(shmName, "%s-lck", fd->zFullPathCp);
23744: if( DosOpen((PSZ)shmName, &pNode->hLockFile, &action, 0, FILE_NORMAL,
23745: OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
23746: OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYNONE |
23747: OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_FAIL_ON_ERROR,
23748: NULL) != 0 ) {
23749: #endif
23750: sqlite3_free(pNode);
23751: rc = SQLITE_IOERR;
23752: } else {
23753: pNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
23754: if( !pNode->mutex ) {
23755: sqlite3_free(pNode);
23756: rc = SQLITE_NOMEM;
23757: }
23758: }
23759: } else {
23760: rc = SQLITE_NOMEM;
23761: }
23762:
23763: if( rc == SQLITE_OK ) {
23764: pNode->pNext = os2ShmNodeList;
23765: os2ShmNodeList = pNode;
23766: } else {
23767: pNode = NULL;
23768: }
23769: } else if( pNode->szRegion != szRegion ) {
23770: rc = SQLITE_IOERR_SHMSIZE;
23771: pNode = NULL;
23772: }
23773:
23774: if( pNode ) {
23775: sqlite3_mutex_enter(pNode->mutex);
23776:
23777: memset(pLink, 0, sizeof(*pLink));
23778:
23779: pLink->pShmNode = pNode;
23780: pLink->pNext = pNode->pFirst;
23781: pNode->pFirst = pLink;
23782: pNode->nRef++;
23783:
23784: fd->pShmLink = pLink;
23785:
23786: sqlite3_mutex_leave(pNode->mutex);
23787:
23788: } else {
23789: /* Error occured. Free our link object. */
23790: sqlite3_free(pLink);
23791: }
23792:
23793: os2ShmLeaveMutex();
23794:
23795: ERR_TRACE(rc, ("os2OpenSharedMemory: %d %s\n", rc, fd->zFullPathCp))
23796:
23797: return rc;
23798: }
23799:
23800: /*
23801: ** Purge the os2ShmNodeList list of all entries with nRef==0.
23802: **
23803: ** This is not a VFS shared-memory method; it is a utility function called
23804: ** by VFS shared-memory methods.
23805: */
23806: static void os2PurgeShmNodes( int deleteFlag ) {
23807: os2ShmNode *pNode;
23808: os2ShmNode **ppNode;
23809:
23810: os2ShmEnterMutex();
23811:
23812: ppNode = &os2ShmNodeList;
23813:
23814: while( *ppNode ) {
23815: pNode = *ppNode;
23816:
23817: if( pNode->nRef == 0 ) {
23818: *ppNode = pNode->pNext;
23819:
23820: if( pNode->apRegion ) {
23821: /* Prevent other processes from resizing the shared memory */
23822: os2ShmSystemLock(pNode, _SHM_WRLCK_WAIT, OS2_SHM_DMS, 1);
23823:
23824: while( pNode->nRegion-- ) {
23825: #ifdef SQLITE_DEBUG
23826: int rc =
23827: #endif
23828: DosFreeMem(pNode->apRegion[pNode->nRegion]);
23829:
23830: OSTRACE(("SHM-PURGE pid-%d unmap region=%d %s\n",
23831: (int)GetCurrentProcessId(), pNode->nRegion,
23832: rc == 0 ? "ok" : "failed"));
23833: }
23834:
23835: /* Allow other processes to resize the shared memory */
23836: os2ShmSystemLock(pNode, _SHM_UNLCK, OS2_SHM_DMS, 1);
23837:
23838: sqlite3_free(pNode->apRegion);
23839: }
23840:
23841: DosClose(pNode->hLockFile);
23842:
23843: #ifndef SQLITE_OS2_NO_WAL_LOCK_FILE
23844: if( deleteFlag ) {
23845: char fileName[CCHMAXPATH];
23846: /* Skip "\\SHAREMEM\\" */
23847: sprintf(fileName, "%s-lck", pNode->shmBaseName + 10);
23848: /* restore colon */
23849: fileName[1] = ':';
23850:
23851: DosForceDelete(fileName);
23852: }
23853: #endif
23854:
23855: sqlite3_mutex_free(pNode->mutex);
23856:
23857: sqlite3_free(pNode);
23858:
23859: } else {
23860: ppNode = &pNode->pNext;
23861: }
23862: }
23863:
23864: os2ShmLeaveMutex();
23865: }
23866:
23867: /*
23868: ** This function is called to obtain a pointer to region iRegion of the
23869: ** shared-memory associated with the database file id. Shared-memory regions
23870: ** are numbered starting from zero. Each shared-memory region is szRegion
23871: ** bytes in size.
23872: **
23873: ** If an error occurs, an error code is returned and *pp is set to NULL.
23874: **
23875: ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
23876: ** region has not been allocated (by any client, including one running in a
23877: ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
23878: ** bExtend is non-zero and the requested shared-memory region has not yet
23879: ** been allocated, it is allocated by this function.
23880: **
23881: ** If the shared-memory region has already been allocated or is allocated by
23882: ** this call as described above, then it is mapped into this processes
23883: ** address space (if it is not already), *pp is set to point to the mapped
23884: ** memory and SQLITE_OK returned.
23885: */
23886: static int os2ShmMap(
23887: sqlite3_file *id, /* Handle open on database file */
23888: int iRegion, /* Region to retrieve */
23889: int szRegion, /* Size of regions */
23890: int bExtend, /* True to extend block if necessary */
23891: void volatile **pp /* OUT: Mapped memory */
23892: ){
23893: PVOID pvTemp;
23894: void **apRegion;
23895: os2ShmNode *pNode;
23896: int n, rc = SQLITE_OK;
23897: char shmName[CCHMAXPATH];
23898: os2File *pFile = (os2File*)id;
23899:
23900: *pp = NULL;
23901:
23902: if( !pFile->pShmLink )
23903: rc = os2OpenSharedMemory( pFile, szRegion );
23904:
23905: if( rc == SQLITE_OK ) {
23906: pNode = pFile->pShmLink->pShmNode ;
23907:
23908: sqlite3_mutex_enter(pNode->mutex);
23909:
23910: assert( szRegion==pNode->szRegion );
23911:
23912: /* Unmapped region ? */
23913: if( iRegion >= pNode->nRegion ) {
23914: /* Prevent other processes from resizing the shared memory */
23915: os2ShmSystemLock(pNode, _SHM_WRLCK_WAIT, OS2_SHM_DMS, 1);
23916:
23917: apRegion = sqlite3_realloc(
23918: pNode->apRegion, (iRegion + 1) * sizeof(apRegion[0]));
23919:
23920: if( apRegion ) {
23921: pNode->apRegion = apRegion;
23922:
23923: while( pNode->nRegion <= iRegion ) {
23924: sprintf(shmName, "%s-%u",
23925: pNode->shmBaseName, pNode->nRegion);
23926:
23927: if( DosGetNamedSharedMem(&pvTemp, (PSZ)shmName,
23928: PAG_READ | PAG_WRITE) != NO_ERROR ) {
23929: if( !bExtend )
23930: break;
23931:
23932: if( DosAllocSharedMem(&pvTemp, (PSZ)shmName, szRegion,
23933: PAG_READ | PAG_WRITE | PAG_COMMIT | OBJ_ANY) != NO_ERROR &&
23934: DosAllocSharedMem(&pvTemp, (PSZ)shmName, szRegion,
23935: PAG_READ | PAG_WRITE | PAG_COMMIT) != NO_ERROR ) {
23936: rc = SQLITE_NOMEM;
23937: break;
23938: }
23939: }
23940:
23941: apRegion[pNode->nRegion++] = pvTemp;
23942: }
23943:
23944: /* zero out remaining entries */
23945: for( n = pNode->nRegion; n <= iRegion; n++ )
23946: pNode->apRegion[n] = NULL;
23947:
23948: /* Return this region (maybe zero) */
23949: *pp = pNode->apRegion[iRegion];
23950: } else {
23951: rc = SQLITE_NOMEM;
23952: }
23953:
23954: /* Allow other processes to resize the shared memory */
23955: os2ShmSystemLock(pNode, _SHM_UNLCK, OS2_SHM_DMS, 1);
23956:
23957: } else {
23958: /* Region has been mapped previously */
23959: *pp = pNode->apRegion[iRegion];
23960: }
23961:
23962: sqlite3_mutex_leave(pNode->mutex);
23963: }
23964:
23965: ERR_TRACE(rc, ("os2ShmMap: %s iRgn = %d, szRgn = %d, bExt = %d : %d\n",
23966: pFile->zFullPathCp, iRegion, szRegion, bExtend, rc))
23967:
23968: return rc;
23969: }
23970:
23971: /*
23972: ** Close a connection to shared-memory. Delete the underlying
23973: ** storage if deleteFlag is true.
23974: **
23975: ** If there is no shared memory associated with the connection then this
23976: ** routine is a harmless no-op.
23977: */
23978: static int os2ShmUnmap(
23979: sqlite3_file *id, /* The underlying database file */
23980: int deleteFlag /* Delete shared-memory if true */
23981: ){
23982: os2File *pFile = (os2File*)id;
23983: os2ShmLink *pLink = pFile->pShmLink;
23984:
23985: if( pLink ) {
23986: int nRef = -1;
23987: os2ShmLink **ppLink;
23988: os2ShmNode *pNode = pLink->pShmNode;
23989:
23990: sqlite3_mutex_enter(pNode->mutex);
23991:
23992: for( ppLink = &pNode->pFirst;
23993: *ppLink && *ppLink != pLink;
23994: ppLink = &(*ppLink)->pNext ) ;
23995:
23996: assert(*ppLink);
23997:
23998: if( *ppLink ) {
23999: *ppLink = pLink->pNext;
24000: nRef = --pNode->nRef;
24001: } else {
24002: ERR_TRACE(1, ("os2ShmUnmap: link not found ! %s\n",
24003: pNode->shmBaseName))
24004: }
24005:
24006: pFile->pShmLink = NULL;
24007: sqlite3_free(pLink);
24008:
24009: sqlite3_mutex_leave(pNode->mutex);
24010:
24011: if( nRef == 0 )
24012: os2PurgeShmNodes( deleteFlag );
24013: }
24014:
24015: return SQLITE_OK;
24016: }
24017:
24018: /*
24019: ** Change the lock state for a shared-memory segment.
24020: **
24021: ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
24022: ** different here than in posix. In xShmLock(), one can go from unlocked
24023: ** to shared and back or from unlocked to exclusive and back. But one may
24024: ** not go from shared to exclusive or from exclusive to shared.
24025: */
24026: static int os2ShmLock(
24027: sqlite3_file *id, /* Database file holding the shared memory */
24028: int ofst, /* First lock to acquire or release */
24029: int n, /* Number of locks to acquire or release */
24030: int flags /* What to do with the lock */
24031: ){
24032: u32 mask; /* Mask of locks to take or release */
24033: int rc = SQLITE_OK; /* Result code */
24034: os2File *pFile = (os2File*)id;
24035: os2ShmLink *p = pFile->pShmLink; /* The shared memory being locked */
24036: os2ShmLink *pX; /* For looping over all siblings */
24037: os2ShmNode *pShmNode = p->pShmNode; /* Our node */
24038:
24039: assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
24040: assert( n>=1 );
24041: assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
24042: || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
24043: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
24044: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
24045: assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
24046:
24047: mask = (u32)((1U<<(ofst+n)) - (1U<<ofst));
24048: assert( n>1 || mask==(1<<ofst) );
24049:
24050:
24051: sqlite3_mutex_enter(pShmNode->mutex);
24052:
24053: if( flags & SQLITE_SHM_UNLOCK ){
24054: u32 allMask = 0; /* Mask of locks held by siblings */
24055:
24056: /* See if any siblings hold this same lock */
24057: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
24058: if( pX==p ) continue;
24059: assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
24060: allMask |= pX->sharedMask;
24061: }
24062:
24063: /* Unlock the system-level locks */
24064: if( (mask & allMask)==0 ){
24065: rc = os2ShmSystemLock(pShmNode, _SHM_UNLCK, ofst+OS2_SHM_BASE, n);
24066: }else{
24067: rc = SQLITE_OK;
24068: }
24069:
24070: /* Undo the local locks */
24071: if( rc==SQLITE_OK ){
24072: p->exclMask &= ~mask;
24073: p->sharedMask &= ~mask;
24074: }
24075: }else if( flags & SQLITE_SHM_SHARED ){
24076: u32 allShared = 0; /* Union of locks held by connections other than "p" */
24077:
24078: /* Find out which shared locks are already held by sibling connections.
24079: ** If any sibling already holds an exclusive lock, go ahead and return
24080: ** SQLITE_BUSY.
24081: */
24082: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
24083: if( (pX->exclMask & mask)!=0 ){
24084: rc = SQLITE_BUSY;
24085: break;
24086: }
24087: allShared |= pX->sharedMask;
24088: }
24089:
24090: /* Get shared locks at the system level, if necessary */
24091: if( rc==SQLITE_OK ){
24092: if( (allShared & mask)==0 ){
24093: rc = os2ShmSystemLock(pShmNode, _SHM_RDLCK, ofst+OS2_SHM_BASE, n);
24094: }else{
24095: rc = SQLITE_OK;
24096: }
24097: }
24098:
24099: /* Get the local shared locks */
24100: if( rc==SQLITE_OK ){
24101: p->sharedMask |= mask;
24102: }
24103: }else{
24104: /* Make sure no sibling connections hold locks that will block this
24105: ** lock. If any do, return SQLITE_BUSY right away.
24106: */
24107: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
24108: if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
24109: rc = SQLITE_BUSY;
24110: break;
24111: }
24112: }
24113:
24114: /* Get the exclusive locks at the system level. Then if successful
24115: ** also mark the local connection as being locked.
24116: */
24117: if( rc==SQLITE_OK ){
24118: rc = os2ShmSystemLock(pShmNode, _SHM_WRLCK, ofst+OS2_SHM_BASE, n);
24119: if( rc==SQLITE_OK ){
24120: assert( (p->sharedMask & mask)==0 );
24121: p->exclMask |= mask;
24122: }
24123: }
24124: }
24125:
24126: sqlite3_mutex_leave(pShmNode->mutex);
24127:
24128: OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
24129: p->id, (int)GetCurrentProcessId(), p->sharedMask, p->exclMask,
24130: rc ? "failed" : "ok"));
24131:
24132: ERR_TRACE(rc, ("os2ShmLock: ofst = %d, n = %d, flags = 0x%x -> %d \n",
24133: ofst, n, flags, rc))
24134:
24135: return rc;
24136: }
24137:
24138: /*
24139: ** Implement a memory barrier or memory fence on shared memory.
24140: **
24141: ** All loads and stores begun before the barrier must complete before
24142: ** any load or store begun after the barrier.
24143: */
24144: static void os2ShmBarrier(
24145: sqlite3_file *id /* Database file holding the shared memory */
24146: ){
24147: UNUSED_PARAMETER(id);
24148: os2ShmEnterMutex();
24149: os2ShmLeaveMutex();
24150: }
24151:
24152: #else
24153: # define os2ShmMap 0
24154: # define os2ShmLock 0
24155: # define os2ShmBarrier 0
24156: # define os2ShmUnmap 0
24157: #endif /* #ifndef SQLITE_OMIT_WAL */
24158:
24159:
24160: /*
24161: ** This vector defines all the methods that can operate on an
24162: ** sqlite3_file for os2.
24163: */
24164: static const sqlite3_io_methods os2IoMethod = {
24165: 2, /* iVersion */
24166: os2Close, /* xClose */
24167: os2Read, /* xRead */
24168: os2Write, /* xWrite */
24169: os2Truncate, /* xTruncate */
24170: os2Sync, /* xSync */
24171: os2FileSize, /* xFileSize */
24172: os2Lock, /* xLock */
24173: os2Unlock, /* xUnlock */
24174: os2CheckReservedLock, /* xCheckReservedLock */
24175: os2FileControl, /* xFileControl */
24176: os2SectorSize, /* xSectorSize */
24177: os2DeviceCharacteristics, /* xDeviceCharacteristics */
24178: os2ShmMap, /* xShmMap */
24179: os2ShmLock, /* xShmLock */
24180: os2ShmBarrier, /* xShmBarrier */
24181: os2ShmUnmap /* xShmUnmap */
24182: };
24183:
24184:
24185: /***************************************************************************
24186: ** Here ends the I/O methods that form the sqlite3_io_methods object.
24187: **
24188: ** The next block of code implements the VFS methods.
24189: ****************************************************************************/
24190:
24191: /*
24192: ** Create a temporary file name in zBuf. zBuf must be big enough to
24193: ** hold at pVfs->mxPathname characters.
24194: */
24195: static int getTempname(int nBuf, char *zBuf ){
24196: static const char zChars[] =
24197: "abcdefghijklmnopqrstuvwxyz"
24198: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
24199: "0123456789";
24200: int i, j;
24201: PSZ zTempPathCp;
24202: char zTempPath[CCHMAXPATH];
24203: ULONG ulDriveNum, ulDriveMap;
24204:
24205: /* It's odd to simulate an io-error here, but really this is just
24206: ** using the io-error infrastructure to test that SQLite handles this
24207: ** function failing.
24208: */
24209: SimulateIOError( return SQLITE_IOERR );
24210:
24211: if( sqlite3_temp_directory ) {
24212: sqlite3_snprintf(CCHMAXPATH-30, zTempPath, "%s", sqlite3_temp_directory);
24213: } else if( DosScanEnv( (PSZ)"TEMP", &zTempPathCp ) == NO_ERROR ||
24214: DosScanEnv( (PSZ)"TMP", &zTempPathCp ) == NO_ERROR ||
24215: DosScanEnv( (PSZ)"TMPDIR", &zTempPathCp ) == NO_ERROR ) {
24216: char *zTempPathUTF = convertCpPathToUtf8( (char *)zTempPathCp );
24217: sqlite3_snprintf(CCHMAXPATH-30, zTempPath, "%s", zTempPathUTF);
24218: free( zTempPathUTF );
24219: } else if( DosQueryCurrentDisk( &ulDriveNum, &ulDriveMap ) == NO_ERROR ) {
24220: zTempPath[0] = (char)('A' + ulDriveNum - 1);
24221: zTempPath[1] = ':';
24222: zTempPath[2] = '\0';
24223: } else {
24224: zTempPath[0] = '\0';
24225: }
24226:
24227: /* Strip off a trailing slashes or backslashes, otherwise we would get *
24228: * multiple (back)slashes which causes DosOpen() to fail. *
24229: * Trailing spaces are not allowed, either. */
24230: j = sqlite3Strlen30(zTempPath);
24231: while( j > 0 && ( zTempPath[j-1] == '\\' || zTempPath[j-1] == '/' ||
24232: zTempPath[j-1] == ' ' ) ){
24233: j--;
24234: }
24235: zTempPath[j] = '\0';
24236:
24237: /* We use 20 bytes to randomize the name */
24238: sqlite3_snprintf(nBuf-22, zBuf,
24239: "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
24240: j = sqlite3Strlen30(zBuf);
24241: sqlite3_randomness( 20, &zBuf[j] );
24242: for( i = 0; i < 20; i++, j++ ){
24243: zBuf[j] = zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
24244: }
24245: zBuf[j] = 0;
24246:
24247: OSTRACE(( "TEMP FILENAME: %s\n", zBuf ));
24248: return SQLITE_OK;
24249: }
24250:
24251:
24252: /*
24253: ** Turn a relative pathname into a full pathname. Write the full
24254: ** pathname into zFull[]. zFull[] will be at least pVfs->mxPathname
24255: ** bytes in size.
24256: */
24257: static int os2FullPathname(
24258: sqlite3_vfs *pVfs, /* Pointer to vfs object */
24259: const char *zRelative, /* Possibly relative input path */
24260: int nFull, /* Size of output buffer in bytes */
24261: char *zFull /* Output buffer */
24262: ){
24263: char *zRelativeCp = convertUtf8PathToCp( zRelative );
24264: char zFullCp[CCHMAXPATH] = "\0";
24265: char *zFullUTF;
24266: APIRET rc = DosQueryPathInfo( (PSZ)zRelativeCp, FIL_QUERYFULLNAME,
24267: zFullCp, CCHMAXPATH );
24268: free( zRelativeCp );
24269: zFullUTF = convertCpPathToUtf8( zFullCp );
24270: sqlite3_snprintf( nFull, zFull, zFullUTF );
24271: free( zFullUTF );
24272: return rc == NO_ERROR ? SQLITE_OK : SQLITE_IOERR;
24273: }
24274:
24275:
24276: /*
24277: ** Open a file.
24278: */
24279: static int os2Open(
24280: sqlite3_vfs *pVfs, /* Not used */
24281: const char *zName, /* Name of the file (UTF-8) */
24282: sqlite3_file *id, /* Write the SQLite file handle here */
24283: int flags, /* Open mode flags */
24284: int *pOutFlags /* Status return flags */
24285: ){
24286: HFILE h;
24287: ULONG ulOpenFlags = 0;
24288: ULONG ulOpenMode = 0;
24289: ULONG ulAction = 0;
24290: ULONG rc;
24291: os2File *pFile = (os2File*)id;
24292: const char *zUtf8Name = zName;
24293: char *zNameCp;
24294: char zTmpname[CCHMAXPATH];
24295:
24296: int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
24297: int isCreate = (flags & SQLITE_OPEN_CREATE);
24298: int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
24299: #ifndef NDEBUG
24300: int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
24301: int isReadonly = (flags & SQLITE_OPEN_READONLY);
24302: int eType = (flags & 0xFFFFFF00);
24303: int isOpenJournal = (isCreate && (
24304: eType==SQLITE_OPEN_MASTER_JOURNAL
24305: || eType==SQLITE_OPEN_MAIN_JOURNAL
24306: || eType==SQLITE_OPEN_WAL
24307: ));
24308: #endif
24309:
24310: UNUSED_PARAMETER(pVfs);
24311: assert( id!=0 );
24312:
24313: /* Check the following statements are true:
24314: **
24315: ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
24316: ** (b) if CREATE is set, then READWRITE must also be set, and
24317: ** (c) if EXCLUSIVE is set, then CREATE must also be set.
24318: ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
24319: */
24320: assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
24321: assert(isCreate==0 || isReadWrite);
24322: assert(isExclusive==0 || isCreate);
24323: assert(isDelete==0 || isCreate);
24324:
24325: /* The main DB, main journal, WAL file and master journal are never
24326: ** automatically deleted. Nor are they ever temporary files. */
24327: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
24328: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
24329: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
24330: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
24331:
24332: /* Assert that the upper layer has set one of the "file-type" flags. */
24333: assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
24334: || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
24335: || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
24336: || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
24337: );
24338:
24339: memset( pFile, 0, sizeof(*pFile) );
24340: pFile->h = (HFILE)-1;
24341:
24342: /* If the second argument to this function is NULL, generate a
24343: ** temporary file name to use
24344: */
24345: if( !zUtf8Name ){
24346: assert(isDelete && !isOpenJournal);
24347: rc = getTempname(CCHMAXPATH, zTmpname);
24348: if( rc!=SQLITE_OK ){
24349: return rc;
24350: }
24351: zUtf8Name = zTmpname;
24352: }
24353:
24354: if( isReadWrite ){
24355: ulOpenMode |= OPEN_ACCESS_READWRITE;
24356: }else{
24357: ulOpenMode |= OPEN_ACCESS_READONLY;
24358: }
24359:
24360: /* Open in random access mode for possibly better speed. Allow full
24361: ** sharing because file locks will provide exclusive access when needed.
24362: ** The handle should not be inherited by child processes and we don't
24363: ** want popups from the critical error handler.
24364: */
24365: ulOpenMode |= OPEN_FLAGS_RANDOM | OPEN_SHARE_DENYNONE |
24366: OPEN_FLAGS_NOINHERIT | OPEN_FLAGS_FAIL_ON_ERROR;
24367:
24368: /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is
24369: ** created. SQLite doesn't use it to indicate "exclusive access"
24370: ** as it is usually understood.
24371: */
24372: if( isExclusive ){
24373: /* Creates a new file, only if it does not already exist. */
24374: /* If the file exists, it fails. */
24375: ulOpenFlags |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_FAIL_IF_EXISTS;
24376: }else if( isCreate ){
24377: /* Open existing file, or create if it doesn't exist */
24378: ulOpenFlags |= OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
24379: }else{
24380: /* Opens a file, only if it exists. */
24381: ulOpenFlags |= OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS;
24382: }
24383:
24384: zNameCp = convertUtf8PathToCp( zUtf8Name );
24385: rc = DosOpen( (PSZ)zNameCp,
24386: &h,
24387: &ulAction,
24388: 0L,
24389: FILE_NORMAL,
24390: ulOpenFlags,
24391: ulOpenMode,
24392: (PEAOP2)NULL );
24393: free( zNameCp );
24394:
24395: if( rc != NO_ERROR ){
24396: OSTRACE(( "OPEN Invalid handle rc=%d: zName=%s, ulAction=%#lx, ulFlags=%#lx, ulMode=%#lx\n",
24397: rc, zUtf8Name, ulAction, ulOpenFlags, ulOpenMode ));
24398:
24399: if( isReadWrite ){
24400: return os2Open( pVfs, zName, id,
24401: ((flags|SQLITE_OPEN_READONLY)&~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)),
24402: pOutFlags );
24403: }else{
24404: return SQLITE_CANTOPEN;
24405: }
24406: }
24407:
24408: if( pOutFlags ){
24409: *pOutFlags = isReadWrite ? SQLITE_OPEN_READWRITE : SQLITE_OPEN_READONLY;
24410: }
24411:
24412: os2FullPathname( pVfs, zUtf8Name, sizeof( zTmpname ), zTmpname );
24413: pFile->zFullPathCp = convertUtf8PathToCp( zTmpname );
24414: pFile->pMethod = &os2IoMethod;
24415: pFile->flags = flags;
24416: pFile->h = h;
24417:
24418: OpenCounter(+1);
24419: OSTRACE(( "OPEN %d pOutFlags=%d\n", pFile->h, pOutFlags ));
24420: return SQLITE_OK;
24421: }
24422:
24423: /*
24424: ** Delete the named file.
24425: */
24426: static int os2Delete(
24427: sqlite3_vfs *pVfs, /* Not used on os2 */
24428: const char *zFilename, /* Name of file to delete */
24429: int syncDir /* Not used on os2 */
24430: ){
24431: APIRET rc;
24432: char *zFilenameCp;
24433: SimulateIOError( return SQLITE_IOERR_DELETE );
24434: zFilenameCp = convertUtf8PathToCp( zFilename );
24435: rc = DosDelete( (PSZ)zFilenameCp );
24436: free( zFilenameCp );
24437: OSTRACE(( "DELETE \"%s\"\n", zFilename ));
24438: return (rc == NO_ERROR ||
24439: rc == ERROR_FILE_NOT_FOUND ||
24440: rc == ERROR_PATH_NOT_FOUND ) ? SQLITE_OK : SQLITE_IOERR_DELETE;
24441: }
24442:
24443: /*
24444: ** Check the existance and status of a file.
24445: */
24446: static int os2Access(
24447: sqlite3_vfs *pVfs, /* Not used on os2 */
24448: const char *zFilename, /* Name of file to check */
24449: int flags, /* Type of test to make on this file */
24450: int *pOut /* Write results here */
24451: ){
24452: APIRET rc;
24453: FILESTATUS3 fsts3ConfigInfo;
24454: char *zFilenameCp;
24455:
24456: UNUSED_PARAMETER(pVfs);
24457: SimulateIOError( return SQLITE_IOERR_ACCESS; );
24458:
24459: zFilenameCp = convertUtf8PathToCp( zFilename );
24460: rc = DosQueryPathInfo( (PSZ)zFilenameCp, FIL_STANDARD,
24461: &fsts3ConfigInfo, sizeof(FILESTATUS3) );
24462: free( zFilenameCp );
24463: OSTRACE(( "ACCESS fsts3ConfigInfo.attrFile=%d flags=%d rc=%d\n",
24464: fsts3ConfigInfo.attrFile, flags, rc ));
24465:
24466: switch( flags ){
24467: case SQLITE_ACCESS_EXISTS:
24468: /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file
24469: ** as if it does not exist.
24470: */
24471: if( fsts3ConfigInfo.cbFile == 0 )
24472: rc = ERROR_FILE_NOT_FOUND;
24473: break;
24474: case SQLITE_ACCESS_READ:
24475: break;
24476: case SQLITE_ACCESS_READWRITE:
24477: if( fsts3ConfigInfo.attrFile & FILE_READONLY )
24478: rc = ERROR_ACCESS_DENIED;
24479: break;
24480: default:
24481: rc = ERROR_FILE_NOT_FOUND;
24482: assert( !"Invalid flags argument" );
24483: }
24484:
24485: *pOut = (rc == NO_ERROR);
24486: OSTRACE(( "ACCESS %s flags %d: rc=%d\n", zFilename, flags, *pOut ));
24487:
24488: return SQLITE_OK;
24489: }
24490:
24491:
24492: #ifndef SQLITE_OMIT_LOAD_EXTENSION
24493: /*
24494: ** Interfaces for opening a shared library, finding entry points
24495: ** within the shared library, and closing the shared library.
24496: */
24497: /*
24498: ** Interfaces for opening a shared library, finding entry points
24499: ** within the shared library, and closing the shared library.
24500: */
24501: static void *os2DlOpen(sqlite3_vfs *pVfs, const char *zFilename){
24502: HMODULE hmod;
24503: APIRET rc;
24504: char *zFilenameCp = convertUtf8PathToCp(zFilename);
24505: rc = DosLoadModule(NULL, 0, (PSZ)zFilenameCp, &hmod);
24506: free(zFilenameCp);
24507: return rc != NO_ERROR ? 0 : (void*)hmod;
24508: }
24509: /*
24510: ** A no-op since the error code is returned on the DosLoadModule call.
24511: ** os2Dlopen returns zero if DosLoadModule is not successful.
24512: */
24513: static void os2DlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
24514: /* no-op */
24515: }
24516: static void (*os2DlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
24517: PFN pfn;
24518: APIRET rc;
24519: rc = DosQueryProcAddr((HMODULE)pHandle, 0L, (PSZ)zSymbol, &pfn);
24520: if( rc != NO_ERROR ){
24521: /* if the symbol itself was not found, search again for the same
24522: * symbol with an extra underscore, that might be needed depending
24523: * on the calling convention */
24524: char _zSymbol[256] = "_";
24525: strncat(_zSymbol, zSymbol, 254);
24526: rc = DosQueryProcAddr((HMODULE)pHandle, 0L, (PSZ)_zSymbol, &pfn);
24527: }
24528: return rc != NO_ERROR ? 0 : (void(*)(void))pfn;
24529: }
24530: static void os2DlClose(sqlite3_vfs *pVfs, void *pHandle){
24531: DosFreeModule((HMODULE)pHandle);
24532: }
24533: #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
24534: #define os2DlOpen 0
24535: #define os2DlError 0
24536: #define os2DlSym 0
24537: #define os2DlClose 0
24538: #endif
24539:
24540:
24541: /*
24542: ** Write up to nBuf bytes of randomness into zBuf.
24543: */
24544: static int os2Randomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf ){
24545: int n = 0;
24546: #if defined(SQLITE_TEST)
24547: n = nBuf;
24548: memset(zBuf, 0, nBuf);
24549: #else
24550: int i;
24551: PPIB ppib;
24552: PTIB ptib;
24553: DATETIME dt;
24554: static unsigned c = 0;
24555: /* Ordered by variation probability */
24556: static ULONG svIdx[6] = { QSV_MS_COUNT, QSV_TIME_LOW,
24557: QSV_MAXPRMEM, QSV_MAXSHMEM,
24558: QSV_TOTAVAILMEM, QSV_TOTRESMEM };
24559:
24560: /* 8 bytes; timezone and weekday don't increase the randomness much */
24561: if( (int)sizeof(dt)-3 <= nBuf - n ){
24562: c += 0x0100;
24563: DosGetDateTime(&dt);
24564: dt.year = (USHORT)((dt.year - 1900) | c);
24565: memcpy(&zBuf[n], &dt, sizeof(dt)-3);
24566: n += sizeof(dt)-3;
24567: }
24568:
24569: /* 4 bytes; PIDs and TIDs are 16 bit internally, so combine them */
24570: if( (int)sizeof(ULONG) <= nBuf - n ){
24571: DosGetInfoBlocks(&ptib, &ppib);
24572: *(PULONG)&zBuf[n] = MAKELONG(ppib->pib_ulpid,
24573: ptib->tib_ptib2->tib2_ultid);
24574: n += sizeof(ULONG);
24575: }
24576:
24577: /* Up to 6 * 4 bytes; variables depend on the system state */
24578: for( i = 0; i < 6 && (int)sizeof(ULONG) <= nBuf - n; i++ ){
24579: DosQuerySysInfo(svIdx[i], svIdx[i],
24580: (PULONG)&zBuf[n], sizeof(ULONG));
24581: n += sizeof(ULONG);
24582: }
24583: #endif
24584:
24585: return n;
24586: }
24587:
24588: /*
24589: ** Sleep for a little while. Return the amount of time slept.
24590: ** The argument is the number of microseconds we want to sleep.
24591: ** The return value is the number of microseconds of sleep actually
24592: ** requested from the underlying operating system, a number which
24593: ** might be greater than or equal to the argument, but not less
24594: ** than the argument.
24595: */
24596: static int os2Sleep( sqlite3_vfs *pVfs, int microsec ){
24597: DosSleep( (microsec/1000) );
24598: return microsec;
24599: }
24600:
24601: /*
24602: ** The following variable, if set to a non-zero value, becomes the result
24603: ** returned from sqlite3OsCurrentTime(). This is used for testing.
24604: */
24605: #ifdef SQLITE_TEST
24606: SQLITE_API int sqlite3_current_time = 0;
24607: #endif
24608:
24609: /*
24610: ** Find the current time (in Universal Coordinated Time). Write into *piNow
24611: ** the current time and date as a Julian Day number times 86_400_000. In
24612: ** other words, write into *piNow the number of milliseconds since the Julian
24613: ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
24614: ** proleptic Gregorian calendar.
24615: **
24616: ** On success, return 0. Return 1 if the time and date cannot be found.
24617: */
24618: static int os2CurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){
24619: #ifdef SQLITE_TEST
24620: static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
24621: #endif
24622: int year, month, datepart, timepart;
24623:
24624: DATETIME dt;
24625: DosGetDateTime( &dt );
24626:
24627: year = dt.year;
24628: month = dt.month;
24629:
24630: /* Calculations from http://www.astro.keele.ac.uk/~rno/Astronomy/hjd.html
24631: ** http://www.astro.keele.ac.uk/~rno/Astronomy/hjd-0.1.c
24632: ** Calculate the Julian days
24633: */
24634: datepart = (int)dt.day - 32076 +
24635: 1461*(year + 4800 + (month - 14)/12)/4 +
24636: 367*(month - 2 - (month - 14)/12*12)/12 -
24637: 3*((year + 4900 + (month - 14)/12)/100)/4;
24638:
24639: /* Time in milliseconds, hours to noon added */
24640: timepart = 12*3600*1000 + dt.hundredths*10 + dt.seconds*1000 +
24641: ((int)dt.minutes + dt.timezone)*60*1000 + dt.hours*3600*1000;
24642:
24643: *piNow = (sqlite3_int64)datepart*86400*1000 + timepart;
24644:
24645: #ifdef SQLITE_TEST
24646: if( sqlite3_current_time ){
24647: *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
24648: }
24649: #endif
24650:
24651: UNUSED_PARAMETER(pVfs);
24652: return 0;
24653: }
24654:
24655: /*
24656: ** Find the current time (in Universal Coordinated Time). Write the
24657: ** current time and date as a Julian Day number into *prNow and
24658: ** return 0. Return 1 if the time and date cannot be found.
24659: */
24660: static int os2CurrentTime( sqlite3_vfs *pVfs, double *prNow ){
24661: int rc;
24662: sqlite3_int64 i;
24663: rc = os2CurrentTimeInt64(pVfs, &i);
24664: if( !rc ){
24665: *prNow = i/86400000.0;
24666: }
24667: return rc;
24668: }
24669:
24670: /*
24671: ** The idea is that this function works like a combination of
24672: ** GetLastError() and FormatMessage() on windows (or errno and
24673: ** strerror_r() on unix). After an error is returned by an OS
24674: ** function, SQLite calls this function with zBuf pointing to
24675: ** a buffer of nBuf bytes. The OS layer should populate the
24676: ** buffer with a nul-terminated UTF-8 encoded error message
24677: ** describing the last IO error to have occurred within the calling
24678: ** thread.
24679: **
24680: ** If the error message is too large for the supplied buffer,
24681: ** it should be truncated. The return value of xGetLastError
24682: ** is zero if the error message fits in the buffer, or non-zero
24683: ** otherwise (if the message was truncated). If non-zero is returned,
24684: ** then it is not necessary to include the nul-terminator character
24685: ** in the output buffer.
24686: **
24687: ** Not supplying an error message will have no adverse effect
24688: ** on SQLite. It is fine to have an implementation that never
24689: ** returns an error message:
24690: **
24691: ** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
24692: ** assert(zBuf[0]=='\0');
24693: ** return 0;
24694: ** }
24695: **
24696: ** However if an error message is supplied, it will be incorporated
24697: ** by sqlite into the error message available to the user using
24698: ** sqlite3_errmsg(), possibly making IO errors easier to debug.
24699: */
24700: static int os2GetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
24701: assert(zBuf[0]=='\0');
24702: return 0;
24703: }
24704:
24705: /*
24706: ** Initialize and deinitialize the operating system interface.
24707: */
24708: SQLITE_API int sqlite3_os_init(void){
24709: static sqlite3_vfs os2Vfs = {
24710: 3, /* iVersion */
24711: sizeof(os2File), /* szOsFile */
24712: CCHMAXPATH, /* mxPathname */
24713: 0, /* pNext */
24714: "os2", /* zName */
24715: 0, /* pAppData */
24716:
24717: os2Open, /* xOpen */
24718: os2Delete, /* xDelete */
24719: os2Access, /* xAccess */
24720: os2FullPathname, /* xFullPathname */
24721: os2DlOpen, /* xDlOpen */
24722: os2DlError, /* xDlError */
24723: os2DlSym, /* xDlSym */
24724: os2DlClose, /* xDlClose */
24725: os2Randomness, /* xRandomness */
24726: os2Sleep, /* xSleep */
24727: os2CurrentTime, /* xCurrentTime */
24728: os2GetLastError, /* xGetLastError */
24729: os2CurrentTimeInt64, /* xCurrentTimeInt64 */
24730: 0, /* xSetSystemCall */
24731: 0, /* xGetSystemCall */
24732: 0 /* xNextSystemCall */
24733: };
24734: sqlite3_vfs_register(&os2Vfs, 1);
24735: initUconvObjects();
24736: /* sqlite3OSTrace = 1; */
24737: return SQLITE_OK;
24738: }
24739: SQLITE_API int sqlite3_os_end(void){
24740: freeUconvObjects();
24741: return SQLITE_OK;
24742: }
24743:
24744: #endif /* SQLITE_OS_OS2 */
24745:
24746: /************** End of os_os2.c **********************************************/
24747: /************** Begin file os_unix.c *****************************************/
24748: /*
24749: ** 2004 May 22
24750: **
24751: ** The author disclaims copyright to this source code. In place of
24752: ** a legal notice, here is a blessing:
24753: **
24754: ** May you do good and not evil.
24755: ** May you find forgiveness for yourself and forgive others.
24756: ** May you share freely, never taking more than you give.
24757: **
24758: ******************************************************************************
24759: **
24760: ** This file contains the VFS implementation for unix-like operating systems
24761: ** include Linux, MacOSX, *BSD, QNX, VxWorks, AIX, HPUX, and others.
24762: **
24763: ** There are actually several different VFS implementations in this file.
24764: ** The differences are in the way that file locking is done. The default
24765: ** implementation uses Posix Advisory Locks. Alternative implementations
24766: ** use flock(), dot-files, various proprietary locking schemas, or simply
24767: ** skip locking all together.
24768: **
24769: ** This source file is organized into divisions where the logic for various
24770: ** subfunctions is contained within the appropriate division. PLEASE
24771: ** KEEP THE STRUCTURE OF THIS FILE INTACT. New code should be placed
24772: ** in the correct division and should be clearly labeled.
24773: **
24774: ** The layout of divisions is as follows:
24775: **
24776: ** * General-purpose declarations and utility functions.
24777: ** * Unique file ID logic used by VxWorks.
24778: ** * Various locking primitive implementations (all except proxy locking):
24779: ** + for Posix Advisory Locks
24780: ** + for no-op locks
24781: ** + for dot-file locks
24782: ** + for flock() locking
24783: ** + for named semaphore locks (VxWorks only)
24784: ** + for AFP filesystem locks (MacOSX only)
24785: ** * sqlite3_file methods not associated with locking.
24786: ** * Definitions of sqlite3_io_methods objects for all locking
24787: ** methods plus "finder" functions for each locking method.
24788: ** * sqlite3_vfs method implementations.
24789: ** * Locking primitives for the proxy uber-locking-method. (MacOSX only)
24790: ** * Definitions of sqlite3_vfs objects for all locking methods
24791: ** plus implementations of sqlite3_os_init() and sqlite3_os_end().
24792: */
24793: #if SQLITE_OS_UNIX /* This file is used on unix only */
24794:
24795: /*
24796: ** There are various methods for file locking used for concurrency
24797: ** control:
24798: **
24799: ** 1. POSIX locking (the default),
24800: ** 2. No locking,
24801: ** 3. Dot-file locking,
24802: ** 4. flock() locking,
24803: ** 5. AFP locking (OSX only),
24804: ** 6. Named POSIX semaphores (VXWorks only),
24805: ** 7. proxy locking. (OSX only)
24806: **
24807: ** Styles 4, 5, and 7 are only available of SQLITE_ENABLE_LOCKING_STYLE
24808: ** is defined to 1. The SQLITE_ENABLE_LOCKING_STYLE also enables automatic
24809: ** selection of the appropriate locking style based on the filesystem
24810: ** where the database is located.
24811: */
24812: #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
24813: # if defined(__APPLE__)
24814: # define SQLITE_ENABLE_LOCKING_STYLE 1
24815: # else
24816: # define SQLITE_ENABLE_LOCKING_STYLE 0
24817: # endif
24818: #endif
24819:
24820: /*
24821: ** Define the OS_VXWORKS pre-processor macro to 1 if building on
24822: ** vxworks, or 0 otherwise.
24823: */
24824: #ifndef OS_VXWORKS
24825: # if defined(__RTP__) || defined(_WRS_KERNEL)
24826: # define OS_VXWORKS 1
24827: # else
24828: # define OS_VXWORKS 0
24829: # endif
24830: #endif
24831:
24832: /*
24833: ** These #defines should enable >2GB file support on Posix if the
24834: ** underlying operating system supports it. If the OS lacks
24835: ** large file support, these should be no-ops.
24836: **
24837: ** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch
24838: ** on the compiler command line. This is necessary if you are compiling
24839: ** on a recent machine (ex: RedHat 7.2) but you want your code to work
24840: ** on an older machine (ex: RedHat 6.0). If you compile on RedHat 7.2
24841: ** without this option, LFS is enable. But LFS does not exist in the kernel
24842: ** in RedHat 6.0, so the code won't work. Hence, for maximum binary
24843: ** portability you should omit LFS.
24844: **
24845: ** The previous paragraph was written in 2005. (This paragraph is written
24846: ** on 2008-11-28.) These days, all Linux kernels support large files, so
24847: ** you should probably leave LFS enabled. But some embedded platforms might
24848: ** lack LFS in which case the SQLITE_DISABLE_LFS macro might still be useful.
24849: */
24850: #ifndef SQLITE_DISABLE_LFS
24851: # define _LARGE_FILE 1
24852: # ifndef _FILE_OFFSET_BITS
24853: # define _FILE_OFFSET_BITS 64
24854: # endif
24855: # define _LARGEFILE_SOURCE 1
24856: #endif
24857:
24858: /*
24859: ** standard include files.
24860: */
24861: #include <sys/types.h>
24862: #include <sys/stat.h>
24863: #include <fcntl.h>
24864: #include <unistd.h>
24865: /* #include <time.h> */
24866: #include <sys/time.h>
24867: #include <errno.h>
24868: #ifndef SQLITE_OMIT_WAL
24869: #include <sys/mman.h>
24870: #endif
24871:
24872:
24873: #if SQLITE_ENABLE_LOCKING_STYLE
24874: # include <sys/ioctl.h>
24875: # if OS_VXWORKS
24876: # include <semaphore.h>
24877: # include <limits.h>
24878: # else
24879: # include <sys/file.h>
24880: # include <sys/param.h>
24881: # endif
24882: #endif /* SQLITE_ENABLE_LOCKING_STYLE */
24883:
24884: #if defined(__APPLE__) || (SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS)
24885: # include <sys/mount.h>
24886: #endif
24887:
24888: #ifdef HAVE_UTIME
24889: # include <utime.h>
24890: #endif
24891:
24892: /*
24893: ** Allowed values of unixFile.fsFlags
24894: */
24895: #define SQLITE_FSFLAGS_IS_MSDOS 0x1
24896:
24897: /*
24898: ** If we are to be thread-safe, include the pthreads header and define
24899: ** the SQLITE_UNIX_THREADS macro.
24900: */
24901: #if SQLITE_THREADSAFE
24902: /* # include <pthread.h> */
24903: # define SQLITE_UNIX_THREADS 1
24904: #endif
24905:
24906: /*
24907: ** Default permissions when creating a new file
24908: */
24909: #ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
24910: # define SQLITE_DEFAULT_FILE_PERMISSIONS 0644
24911: #endif
24912:
24913: /*
24914: ** Default permissions when creating auto proxy dir
24915: */
24916: #ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
24917: # define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755
24918: #endif
24919:
24920: /*
24921: ** Maximum supported path-length.
24922: */
24923: #define MAX_PATHNAME 512
24924:
24925: /*
24926: ** Only set the lastErrno if the error code is a real error and not
24927: ** a normal expected return code of SQLITE_BUSY or SQLITE_OK
24928: */
24929: #define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY))
24930:
24931: /* Forward references */
24932: typedef struct unixShm unixShm; /* Connection shared memory */
24933: typedef struct unixShmNode unixShmNode; /* Shared memory instance */
24934: typedef struct unixInodeInfo unixInodeInfo; /* An i-node */
24935: typedef struct UnixUnusedFd UnixUnusedFd; /* An unused file descriptor */
24936:
24937: /*
24938: ** Sometimes, after a file handle is closed by SQLite, the file descriptor
24939: ** cannot be closed immediately. In these cases, instances of the following
24940: ** structure are used to store the file descriptor while waiting for an
24941: ** opportunity to either close or reuse it.
24942: */
24943: struct UnixUnusedFd {
24944: int fd; /* File descriptor to close */
24945: int flags; /* Flags this file descriptor was opened with */
24946: UnixUnusedFd *pNext; /* Next unused file descriptor on same file */
24947: };
24948:
24949: /*
24950: ** The unixFile structure is subclass of sqlite3_file specific to the unix
24951: ** VFS implementations.
24952: */
24953: typedef struct unixFile unixFile;
24954: struct unixFile {
24955: sqlite3_io_methods const *pMethod; /* Always the first entry */
24956: sqlite3_vfs *pVfs; /* The VFS that created this unixFile */
24957: unixInodeInfo *pInode; /* Info about locks on this inode */
24958: int h; /* The file descriptor */
24959: unsigned char eFileLock; /* The type of lock held on this fd */
24960: unsigned char ctrlFlags; /* Behavioral bits. UNIXFILE_* flags */
24961: int lastErrno; /* The unix errno from last I/O error */
24962: void *lockingContext; /* Locking style specific state */
24963: UnixUnusedFd *pUnused; /* Pre-allocated UnixUnusedFd */
24964: const char *zPath; /* Name of the file */
24965: unixShm *pShm; /* Shared memory segment information */
24966: int szChunk; /* Configured by FCNTL_CHUNK_SIZE */
24967: #if SQLITE_ENABLE_LOCKING_STYLE
24968: int openFlags; /* The flags specified at open() */
24969: #endif
24970: #if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__)
24971: unsigned fsFlags; /* cached details from statfs() */
24972: #endif
24973: #if OS_VXWORKS
24974: struct vxworksFileId *pId; /* Unique file ID */
24975: #endif
24976: #ifndef NDEBUG
24977: /* The next group of variables are used to track whether or not the
24978: ** transaction counter in bytes 24-27 of database files are updated
24979: ** whenever any part of the database changes. An assertion fault will
24980: ** occur if a file is updated without also updating the transaction
24981: ** counter. This test is made to avoid new problems similar to the
24982: ** one described by ticket #3584.
24983: */
24984: unsigned char transCntrChng; /* True if the transaction counter changed */
24985: unsigned char dbUpdate; /* True if any part of database file changed */
24986: unsigned char inNormalWrite; /* True if in a normal write operation */
24987: #endif
24988: #ifdef SQLITE_TEST
24989: /* In test mode, increase the size of this structure a bit so that
24990: ** it is larger than the struct CrashFile defined in test6.c.
24991: */
24992: char aPadding[32];
24993: #endif
24994: };
24995:
24996: /*
24997: ** Allowed values for the unixFile.ctrlFlags bitmask:
24998: */
24999: #define UNIXFILE_EXCL 0x01 /* Connections from one process only */
25000: #define UNIXFILE_RDONLY 0x02 /* Connection is read only */
25001: #define UNIXFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
25002: #ifndef SQLITE_DISABLE_DIRSYNC
25003: # define UNIXFILE_DIRSYNC 0x08 /* Directory sync needed */
25004: #else
25005: # define UNIXFILE_DIRSYNC 0x00
25006: #endif
25007: #define UNIXFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */
25008: #define UNIXFILE_DELETE 0x20 /* Delete on close */
25009: #define UNIXFILE_URI 0x40 /* Filename might have query parameters */
25010: #define UNIXFILE_NOLOCK 0x80 /* Do no file locking */
25011:
25012: /*
25013: ** Include code that is common to all os_*.c files
25014: */
25015: /************** Include os_common.h in the middle of os_unix.c ***************/
25016: /************** Begin file os_common.h ***************************************/
25017: /*
25018: ** 2004 May 22
25019: **
25020: ** The author disclaims copyright to this source code. In place of
25021: ** a legal notice, here is a blessing:
25022: **
25023: ** May you do good and not evil.
25024: ** May you find forgiveness for yourself and forgive others.
25025: ** May you share freely, never taking more than you give.
25026: **
25027: ******************************************************************************
25028: **
25029: ** This file contains macros and a little bit of code that is common to
25030: ** all of the platform-specific files (os_*.c) and is #included into those
25031: ** files.
25032: **
25033: ** This file should be #included by the os_*.c files only. It is not a
25034: ** general purpose header file.
25035: */
25036: #ifndef _OS_COMMON_H_
25037: #define _OS_COMMON_H_
25038:
25039: /*
25040: ** At least two bugs have slipped in because we changed the MEMORY_DEBUG
25041: ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
25042: ** switch. The following code should catch this problem at compile-time.
25043: */
25044: #ifdef MEMORY_DEBUG
25045: # error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead."
25046: #endif
25047:
25048: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
25049: # ifndef SQLITE_DEBUG_OS_TRACE
25050: # define SQLITE_DEBUG_OS_TRACE 0
25051: # endif
25052: int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE;
25053: # define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X
25054: #else
25055: # define OSTRACE(X)
25056: #endif
25057:
25058: /*
25059: ** Macros for performance tracing. Normally turned off. Only works
25060: ** on i486 hardware.
25061: */
25062: #ifdef SQLITE_PERFORMANCE_TRACE
25063:
25064: /*
25065: ** hwtime.h contains inline assembler code for implementing
25066: ** high-performance timing routines.
25067: */
25068: /************** Include hwtime.h in the middle of os_common.h ****************/
25069: /************** Begin file hwtime.h ******************************************/
25070: /*
25071: ** 2008 May 27
25072: **
25073: ** The author disclaims copyright to this source code. In place of
25074: ** a legal notice, here is a blessing:
25075: **
25076: ** May you do good and not evil.
25077: ** May you find forgiveness for yourself and forgive others.
25078: ** May you share freely, never taking more than you give.
25079: **
25080: ******************************************************************************
25081: **
25082: ** This file contains inline asm code for retrieving "high-performance"
25083: ** counters for x86 class CPUs.
25084: */
25085: #ifndef _HWTIME_H_
25086: #define _HWTIME_H_
25087:
25088: /*
25089: ** The following routine only works on pentium-class (or newer) processors.
25090: ** It uses the RDTSC opcode to read the cycle count value out of the
25091: ** processor and returns that value. This can be used for high-res
25092: ** profiling.
25093: */
25094: #if (defined(__GNUC__) || defined(_MSC_VER)) && \
25095: (defined(i386) || defined(__i386__) || defined(_M_IX86))
25096:
25097: #if defined(__GNUC__)
25098:
25099: __inline__ sqlite_uint64 sqlite3Hwtime(void){
25100: unsigned int lo, hi;
25101: __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
25102: return (sqlite_uint64)hi << 32 | lo;
25103: }
25104:
25105: #elif defined(_MSC_VER)
25106:
25107: __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
25108: __asm {
25109: rdtsc
25110: ret ; return value at EDX:EAX
25111: }
25112: }
25113:
25114: #endif
25115:
25116: #elif (defined(__GNUC__) && defined(__x86_64__))
25117:
25118: __inline__ sqlite_uint64 sqlite3Hwtime(void){
25119: unsigned long val;
25120: __asm__ __volatile__ ("rdtsc" : "=A" (val));
25121: return val;
25122: }
25123:
25124: #elif (defined(__GNUC__) && defined(__ppc__))
25125:
25126: __inline__ sqlite_uint64 sqlite3Hwtime(void){
25127: unsigned long long retval;
25128: unsigned long junk;
25129: __asm__ __volatile__ ("\n\
25130: 1: mftbu %1\n\
25131: mftb %L0\n\
25132: mftbu %0\n\
25133: cmpw %0,%1\n\
25134: bne 1b"
25135: : "=r" (retval), "=r" (junk));
25136: return retval;
25137: }
25138:
25139: #else
25140:
25141: #error Need implementation of sqlite3Hwtime() for your platform.
25142:
25143: /*
25144: ** To compile without implementing sqlite3Hwtime() for your platform,
25145: ** you can remove the above #error and use the following
25146: ** stub function. You will lose timing support for many
25147: ** of the debugging and testing utilities, but it should at
25148: ** least compile and run.
25149: */
25150: SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
25151:
25152: #endif
25153:
25154: #endif /* !defined(_HWTIME_H_) */
25155:
25156: /************** End of hwtime.h **********************************************/
25157: /************** Continuing where we left off in os_common.h ******************/
25158:
25159: static sqlite_uint64 g_start;
25160: static sqlite_uint64 g_elapsed;
25161: #define TIMER_START g_start=sqlite3Hwtime()
25162: #define TIMER_END g_elapsed=sqlite3Hwtime()-g_start
25163: #define TIMER_ELAPSED g_elapsed
25164: #else
25165: #define TIMER_START
25166: #define TIMER_END
25167: #define TIMER_ELAPSED ((sqlite_uint64)0)
25168: #endif
25169:
25170: /*
25171: ** If we compile with the SQLITE_TEST macro set, then the following block
25172: ** of code will give us the ability to simulate a disk I/O error. This
25173: ** is used for testing the I/O recovery logic.
25174: */
25175: #ifdef SQLITE_TEST
25176: SQLITE_API int sqlite3_io_error_hit = 0; /* Total number of I/O Errors */
25177: SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */
25178: SQLITE_API int sqlite3_io_error_pending = 0; /* Count down to first I/O error */
25179: SQLITE_API int sqlite3_io_error_persist = 0; /* True if I/O errors persist */
25180: SQLITE_API int sqlite3_io_error_benign = 0; /* True if errors are benign */
25181: SQLITE_API int sqlite3_diskfull_pending = 0;
25182: SQLITE_API int sqlite3_diskfull = 0;
25183: #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
25184: #define SimulateIOError(CODE) \
25185: if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
25186: || sqlite3_io_error_pending-- == 1 ) \
25187: { local_ioerr(); CODE; }
25188: static void local_ioerr(){
25189: IOTRACE(("IOERR\n"));
25190: sqlite3_io_error_hit++;
25191: if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
25192: }
25193: #define SimulateDiskfullError(CODE) \
25194: if( sqlite3_diskfull_pending ){ \
25195: if( sqlite3_diskfull_pending == 1 ){ \
25196: local_ioerr(); \
25197: sqlite3_diskfull = 1; \
25198: sqlite3_io_error_hit = 1; \
25199: CODE; \
25200: }else{ \
25201: sqlite3_diskfull_pending--; \
25202: } \
25203: }
25204: #else
25205: #define SimulateIOErrorBenign(X)
25206: #define SimulateIOError(A)
25207: #define SimulateDiskfullError(A)
25208: #endif
25209:
25210: /*
25211: ** When testing, keep a count of the number of open files.
25212: */
25213: #ifdef SQLITE_TEST
25214: SQLITE_API int sqlite3_open_file_count = 0;
25215: #define OpenCounter(X) sqlite3_open_file_count+=(X)
25216: #else
25217: #define OpenCounter(X)
25218: #endif
25219:
25220: #endif /* !defined(_OS_COMMON_H_) */
25221:
25222: /************** End of os_common.h *******************************************/
25223: /************** Continuing where we left off in os_unix.c ********************/
25224:
25225: /*
25226: ** Define various macros that are missing from some systems.
25227: */
25228: #ifndef O_LARGEFILE
25229: # define O_LARGEFILE 0
25230: #endif
25231: #ifdef SQLITE_DISABLE_LFS
25232: # undef O_LARGEFILE
25233: # define O_LARGEFILE 0
25234: #endif
25235: #ifndef O_NOFOLLOW
25236: # define O_NOFOLLOW 0
25237: #endif
25238: #ifndef O_BINARY
25239: # define O_BINARY 0
25240: #endif
25241:
25242: /*
25243: ** The threadid macro resolves to the thread-id or to 0. Used for
25244: ** testing and debugging only.
25245: */
25246: #if SQLITE_THREADSAFE
25247: #define threadid pthread_self()
25248: #else
25249: #define threadid 0
25250: #endif
25251:
25252: /*
25253: ** Different Unix systems declare open() in different ways. Same use
25254: ** open(const char*,int,mode_t). Others use open(const char*,int,...).
25255: ** The difference is important when using a pointer to the function.
25256: **
25257: ** The safest way to deal with the problem is to always use this wrapper
25258: ** which always has the same well-defined interface.
25259: */
25260: static int posixOpen(const char *zFile, int flags, int mode){
25261: return open(zFile, flags, mode);
25262: }
25263:
25264: /* Forward reference */
25265: static int openDirectory(const char*, int*);
25266:
25267: /*
25268: ** Many system calls are accessed through pointer-to-functions so that
25269: ** they may be overridden at runtime to facilitate fault injection during
25270: ** testing and sandboxing. The following array holds the names and pointers
25271: ** to all overrideable system calls.
25272: */
25273: static struct unix_syscall {
25274: const char *zName; /* Name of the sytem call */
25275: sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
25276: sqlite3_syscall_ptr pDefault; /* Default value */
25277: } aSyscall[] = {
25278: { "open", (sqlite3_syscall_ptr)posixOpen, 0 },
25279: #define osOpen ((int(*)(const char*,int,int))aSyscall[0].pCurrent)
25280:
25281: { "close", (sqlite3_syscall_ptr)close, 0 },
25282: #define osClose ((int(*)(int))aSyscall[1].pCurrent)
25283:
25284: { "access", (sqlite3_syscall_ptr)access, 0 },
25285: #define osAccess ((int(*)(const char*,int))aSyscall[2].pCurrent)
25286:
25287: { "getcwd", (sqlite3_syscall_ptr)getcwd, 0 },
25288: #define osGetcwd ((char*(*)(char*,size_t))aSyscall[3].pCurrent)
25289:
25290: { "stat", (sqlite3_syscall_ptr)stat, 0 },
25291: #define osStat ((int(*)(const char*,struct stat*))aSyscall[4].pCurrent)
25292:
25293: /*
25294: ** The DJGPP compiler environment looks mostly like Unix, but it
25295: ** lacks the fcntl() system call. So redefine fcntl() to be something
25296: ** that always succeeds. This means that locking does not occur under
25297: ** DJGPP. But it is DOS - what did you expect?
25298: */
25299: #ifdef __DJGPP__
25300: { "fstat", 0, 0 },
25301: #define osFstat(a,b,c) 0
25302: #else
25303: { "fstat", (sqlite3_syscall_ptr)fstat, 0 },
25304: #define osFstat ((int(*)(int,struct stat*))aSyscall[5].pCurrent)
25305: #endif
25306:
25307: { "ftruncate", (sqlite3_syscall_ptr)ftruncate, 0 },
25308: #define osFtruncate ((int(*)(int,off_t))aSyscall[6].pCurrent)
25309:
25310: { "fcntl", (sqlite3_syscall_ptr)fcntl, 0 },
25311: #define osFcntl ((int(*)(int,int,...))aSyscall[7].pCurrent)
25312:
25313: { "read", (sqlite3_syscall_ptr)read, 0 },
25314: #define osRead ((ssize_t(*)(int,void*,size_t))aSyscall[8].pCurrent)
25315:
25316: #if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
25317: { "pread", (sqlite3_syscall_ptr)pread, 0 },
25318: #else
25319: { "pread", (sqlite3_syscall_ptr)0, 0 },
25320: #endif
25321: #define osPread ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[9].pCurrent)
25322:
25323: #if defined(USE_PREAD64)
25324: { "pread64", (sqlite3_syscall_ptr)pread64, 0 },
25325: #else
25326: { "pread64", (sqlite3_syscall_ptr)0, 0 },
25327: #endif
25328: #define osPread64 ((ssize_t(*)(int,void*,size_t,off_t))aSyscall[10].pCurrent)
25329:
25330: { "write", (sqlite3_syscall_ptr)write, 0 },
25331: #define osWrite ((ssize_t(*)(int,const void*,size_t))aSyscall[11].pCurrent)
25332:
25333: #if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
25334: { "pwrite", (sqlite3_syscall_ptr)pwrite, 0 },
25335: #else
25336: { "pwrite", (sqlite3_syscall_ptr)0, 0 },
25337: #endif
25338: #define osPwrite ((ssize_t(*)(int,const void*,size_t,off_t))\
25339: aSyscall[12].pCurrent)
25340:
25341: #if defined(USE_PREAD64)
25342: { "pwrite64", (sqlite3_syscall_ptr)pwrite64, 0 },
25343: #else
25344: { "pwrite64", (sqlite3_syscall_ptr)0, 0 },
25345: #endif
25346: #define osPwrite64 ((ssize_t(*)(int,const void*,size_t,off_t))\
25347: aSyscall[13].pCurrent)
25348:
25349: #if SQLITE_ENABLE_LOCKING_STYLE
25350: { "fchmod", (sqlite3_syscall_ptr)fchmod, 0 },
25351: #else
25352: { "fchmod", (sqlite3_syscall_ptr)0, 0 },
25353: #endif
25354: #define osFchmod ((int(*)(int,mode_t))aSyscall[14].pCurrent)
25355:
25356: #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
25357: { "fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 },
25358: #else
25359: { "fallocate", (sqlite3_syscall_ptr)0, 0 },
25360: #endif
25361: #define osFallocate ((int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
25362:
25363: { "unlink", (sqlite3_syscall_ptr)unlink, 0 },
25364: #define osUnlink ((int(*)(const char*))aSyscall[16].pCurrent)
25365:
25366: { "openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 },
25367: #define osOpenDirectory ((int(*)(const char*,int*))aSyscall[17].pCurrent)
25368:
25369: { "mkdir", (sqlite3_syscall_ptr)mkdir, 0 },
25370: #define osMkdir ((int(*)(const char*,mode_t))aSyscall[18].pCurrent)
25371:
25372: { "rmdir", (sqlite3_syscall_ptr)rmdir, 0 },
25373: #define osRmdir ((int(*)(const char*))aSyscall[19].pCurrent)
25374:
25375: }; /* End of the overrideable system calls */
25376:
25377: /*
25378: ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
25379: ** "unix" VFSes. Return SQLITE_OK opon successfully updating the
25380: ** system call pointer, or SQLITE_NOTFOUND if there is no configurable
25381: ** system call named zName.
25382: */
25383: static int unixSetSystemCall(
25384: sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */
25385: const char *zName, /* Name of system call to override */
25386: sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
25387: ){
25388: unsigned int i;
25389: int rc = SQLITE_NOTFOUND;
25390:
25391: UNUSED_PARAMETER(pNotUsed);
25392: if( zName==0 ){
25393: /* If no zName is given, restore all system calls to their default
25394: ** settings and return NULL
25395: */
25396: rc = SQLITE_OK;
25397: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
25398: if( aSyscall[i].pDefault ){
25399: aSyscall[i].pCurrent = aSyscall[i].pDefault;
25400: }
25401: }
25402: }else{
25403: /* If zName is specified, operate on only the one system call
25404: ** specified.
25405: */
25406: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
25407: if( strcmp(zName, aSyscall[i].zName)==0 ){
25408: if( aSyscall[i].pDefault==0 ){
25409: aSyscall[i].pDefault = aSyscall[i].pCurrent;
25410: }
25411: rc = SQLITE_OK;
25412: if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
25413: aSyscall[i].pCurrent = pNewFunc;
25414: break;
25415: }
25416: }
25417: }
25418: return rc;
25419: }
25420:
25421: /*
25422: ** Return the value of a system call. Return NULL if zName is not a
25423: ** recognized system call name. NULL is also returned if the system call
25424: ** is currently undefined.
25425: */
25426: static sqlite3_syscall_ptr unixGetSystemCall(
25427: sqlite3_vfs *pNotUsed,
25428: const char *zName
25429: ){
25430: unsigned int i;
25431:
25432: UNUSED_PARAMETER(pNotUsed);
25433: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
25434: if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
25435: }
25436: return 0;
25437: }
25438:
25439: /*
25440: ** Return the name of the first system call after zName. If zName==NULL
25441: ** then return the name of the first system call. Return NULL if zName
25442: ** is the last system call or if zName is not the name of a valid
25443: ** system call.
25444: */
25445: static const char *unixNextSystemCall(sqlite3_vfs *p, const char *zName){
25446: int i = -1;
25447:
25448: UNUSED_PARAMETER(p);
25449: if( zName ){
25450: for(i=0; i<ArraySize(aSyscall)-1; i++){
25451: if( strcmp(zName, aSyscall[i].zName)==0 ) break;
25452: }
25453: }
25454: for(i++; i<ArraySize(aSyscall); i++){
25455: if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
25456: }
25457: return 0;
25458: }
25459:
25460: /*
25461: ** Retry open() calls that fail due to EINTR
25462: */
25463: static int robust_open(const char *z, int f, int m){
25464: int rc;
25465: do{ rc = osOpen(z,f,m); }while( rc<0 && errno==EINTR );
25466: return rc;
25467: }
25468:
25469: /*
25470: ** Helper functions to obtain and relinquish the global mutex. The
25471: ** global mutex is used to protect the unixInodeInfo and
25472: ** vxworksFileId objects used by this file, all of which may be
25473: ** shared by multiple threads.
25474: **
25475: ** Function unixMutexHeld() is used to assert() that the global mutex
25476: ** is held when required. This function is only used as part of assert()
25477: ** statements. e.g.
25478: **
25479: ** unixEnterMutex()
25480: ** assert( unixMutexHeld() );
25481: ** unixEnterLeave()
25482: */
25483: static void unixEnterMutex(void){
25484: sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
25485: }
25486: static void unixLeaveMutex(void){
25487: sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
25488: }
25489: #ifdef SQLITE_DEBUG
25490: static int unixMutexHeld(void) {
25491: return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
25492: }
25493: #endif
25494:
25495:
25496: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
25497: /*
25498: ** Helper function for printing out trace information from debugging
25499: ** binaries. This returns the string represetation of the supplied
25500: ** integer lock-type.
25501: */
25502: static const char *azFileLock(int eFileLock){
25503: switch( eFileLock ){
25504: case NO_LOCK: return "NONE";
25505: case SHARED_LOCK: return "SHARED";
25506: case RESERVED_LOCK: return "RESERVED";
25507: case PENDING_LOCK: return "PENDING";
25508: case EXCLUSIVE_LOCK: return "EXCLUSIVE";
25509: }
25510: return "ERROR";
25511: }
25512: #endif
25513:
25514: #ifdef SQLITE_LOCK_TRACE
25515: /*
25516: ** Print out information about all locking operations.
25517: **
25518: ** This routine is used for troubleshooting locks on multithreaded
25519: ** platforms. Enable by compiling with the -DSQLITE_LOCK_TRACE
25520: ** command-line option on the compiler. This code is normally
25521: ** turned off.
25522: */
25523: static int lockTrace(int fd, int op, struct flock *p){
25524: char *zOpName, *zType;
25525: int s;
25526: int savedErrno;
25527: if( op==F_GETLK ){
25528: zOpName = "GETLK";
25529: }else if( op==F_SETLK ){
25530: zOpName = "SETLK";
25531: }else{
25532: s = osFcntl(fd, op, p);
25533: sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);
25534: return s;
25535: }
25536: if( p->l_type==F_RDLCK ){
25537: zType = "RDLCK";
25538: }else if( p->l_type==F_WRLCK ){
25539: zType = "WRLCK";
25540: }else if( p->l_type==F_UNLCK ){
25541: zType = "UNLCK";
25542: }else{
25543: assert( 0 );
25544: }
25545: assert( p->l_whence==SEEK_SET );
25546: s = osFcntl(fd, op, p);
25547: savedErrno = errno;
25548: sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n",
25549: threadid, fd, zOpName, zType, (int)p->l_start, (int)p->l_len,
25550: (int)p->l_pid, s);
25551: if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
25552: struct flock l2;
25553: l2 = *p;
25554: osFcntl(fd, F_GETLK, &l2);
25555: if( l2.l_type==F_RDLCK ){
25556: zType = "RDLCK";
25557: }else if( l2.l_type==F_WRLCK ){
25558: zType = "WRLCK";
25559: }else if( l2.l_type==F_UNLCK ){
25560: zType = "UNLCK";
25561: }else{
25562: assert( 0 );
25563: }
25564: sqlite3DebugPrintf("fcntl-failure-reason: %s %d %d %d\n",
25565: zType, (int)l2.l_start, (int)l2.l_len, (int)l2.l_pid);
25566: }
25567: errno = savedErrno;
25568: return s;
25569: }
25570: #undef osFcntl
25571: #define osFcntl lockTrace
25572: #endif /* SQLITE_LOCK_TRACE */
25573:
25574: /*
25575: ** Retry ftruncate() calls that fail due to EINTR
25576: */
25577: static int robust_ftruncate(int h, sqlite3_int64 sz){
25578: int rc;
25579: do{ rc = osFtruncate(h,sz); }while( rc<0 && errno==EINTR );
25580: return rc;
25581: }
25582:
25583: /*
25584: ** This routine translates a standard POSIX errno code into something
25585: ** useful to the clients of the sqlite3 functions. Specifically, it is
25586: ** intended to translate a variety of "try again" errors into SQLITE_BUSY
25587: ** and a variety of "please close the file descriptor NOW" errors into
25588: ** SQLITE_IOERR
25589: **
25590: ** Errors during initialization of locks, or file system support for locks,
25591: ** should handle ENOLCK, ENOTSUP, EOPNOTSUPP separately.
25592: */
25593: static int sqliteErrorFromPosixError(int posixError, int sqliteIOErr) {
25594: switch (posixError) {
25595: #if 0
25596: /* At one point this code was not commented out. In theory, this branch
25597: ** should never be hit, as this function should only be called after
25598: ** a locking-related function (i.e. fcntl()) has returned non-zero with
25599: ** the value of errno as the first argument. Since a system call has failed,
25600: ** errno should be non-zero.
25601: **
25602: ** Despite this, if errno really is zero, we still don't want to return
25603: ** SQLITE_OK. The system call failed, and *some* SQLite error should be
25604: ** propagated back to the caller. Commenting this branch out means errno==0
25605: ** will be handled by the "default:" case below.
25606: */
25607: case 0:
25608: return SQLITE_OK;
25609: #endif
25610:
25611: case EAGAIN:
25612: case ETIMEDOUT:
25613: case EBUSY:
25614: case EINTR:
25615: case ENOLCK:
25616: /* random NFS retry error, unless during file system support
25617: * introspection, in which it actually means what it says */
25618: return SQLITE_BUSY;
25619:
25620: case EACCES:
25621: /* EACCES is like EAGAIN during locking operations, but not any other time*/
25622: if( (sqliteIOErr == SQLITE_IOERR_LOCK) ||
25623: (sqliteIOErr == SQLITE_IOERR_UNLOCK) ||
25624: (sqliteIOErr == SQLITE_IOERR_RDLOCK) ||
25625: (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) ){
25626: return SQLITE_BUSY;
25627: }
25628: /* else fall through */
25629: case EPERM:
25630: return SQLITE_PERM;
25631:
25632: /* EDEADLK is only possible if a call to fcntl(F_SETLKW) is made. And
25633: ** this module never makes such a call. And the code in SQLite itself
25634: ** asserts that SQLITE_IOERR_BLOCKED is never returned. For these reasons
25635: ** this case is also commented out. If the system does set errno to EDEADLK,
25636: ** the default SQLITE_IOERR_XXX code will be returned. */
25637: #if 0
25638: case EDEADLK:
25639: return SQLITE_IOERR_BLOCKED;
25640: #endif
25641:
25642: #if EOPNOTSUPP!=ENOTSUP
25643: case EOPNOTSUPP:
25644: /* something went terribly awry, unless during file system support
25645: * introspection, in which it actually means what it says */
25646: #endif
25647: #ifdef ENOTSUP
25648: case ENOTSUP:
25649: /* invalid fd, unless during file system support introspection, in which
25650: * it actually means what it says */
25651: #endif
25652: case EIO:
25653: case EBADF:
25654: case EINVAL:
25655: case ENOTCONN:
25656: case ENODEV:
25657: case ENXIO:
25658: case ENOENT:
25659: #ifdef ESTALE /* ESTALE is not defined on Interix systems */
25660: case ESTALE:
25661: #endif
25662: case ENOSYS:
25663: /* these should force the client to close the file and reconnect */
25664:
25665: default:
25666: return sqliteIOErr;
25667: }
25668: }
25669:
25670:
25671:
25672: /******************************************************************************
25673: ****************** Begin Unique File ID Utility Used By VxWorks ***************
25674: **
25675: ** On most versions of unix, we can get a unique ID for a file by concatenating
25676: ** the device number and the inode number. But this does not work on VxWorks.
25677: ** On VxWorks, a unique file id must be based on the canonical filename.
25678: **
25679: ** A pointer to an instance of the following structure can be used as a
25680: ** unique file ID in VxWorks. Each instance of this structure contains
25681: ** a copy of the canonical filename. There is also a reference count.
25682: ** The structure is reclaimed when the number of pointers to it drops to
25683: ** zero.
25684: **
25685: ** There are never very many files open at one time and lookups are not
25686: ** a performance-critical path, so it is sufficient to put these
25687: ** structures on a linked list.
25688: */
25689: struct vxworksFileId {
25690: struct vxworksFileId *pNext; /* Next in a list of them all */
25691: int nRef; /* Number of references to this one */
25692: int nName; /* Length of the zCanonicalName[] string */
25693: char *zCanonicalName; /* Canonical filename */
25694: };
25695:
25696: #if OS_VXWORKS
25697: /*
25698: ** All unique filenames are held on a linked list headed by this
25699: ** variable:
25700: */
25701: static struct vxworksFileId *vxworksFileList = 0;
25702:
25703: /*
25704: ** Simplify a filename into its canonical form
25705: ** by making the following changes:
25706: **
25707: ** * removing any trailing and duplicate /
25708: ** * convert /./ into just /
25709: ** * convert /A/../ where A is any simple name into just /
25710: **
25711: ** Changes are made in-place. Return the new name length.
25712: **
25713: ** The original filename is in z[0..n-1]. Return the number of
25714: ** characters in the simplified name.
25715: */
25716: static int vxworksSimplifyName(char *z, int n){
25717: int i, j;
25718: while( n>1 && z[n-1]=='/' ){ n--; }
25719: for(i=j=0; i<n; i++){
25720: if( z[i]=='/' ){
25721: if( z[i+1]=='/' ) continue;
25722: if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
25723: i += 1;
25724: continue;
25725: }
25726: if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
25727: while( j>0 && z[j-1]!='/' ){ j--; }
25728: if( j>0 ){ j--; }
25729: i += 2;
25730: continue;
25731: }
25732: }
25733: z[j++] = z[i];
25734: }
25735: z[j] = 0;
25736: return j;
25737: }
25738:
25739: /*
25740: ** Find a unique file ID for the given absolute pathname. Return
25741: ** a pointer to the vxworksFileId object. This pointer is the unique
25742: ** file ID.
25743: **
25744: ** The nRef field of the vxworksFileId object is incremented before
25745: ** the object is returned. A new vxworksFileId object is created
25746: ** and added to the global list if necessary.
25747: **
25748: ** If a memory allocation error occurs, return NULL.
25749: */
25750: static struct vxworksFileId *vxworksFindFileId(const char *zAbsoluteName){
25751: struct vxworksFileId *pNew; /* search key and new file ID */
25752: struct vxworksFileId *pCandidate; /* For looping over existing file IDs */
25753: int n; /* Length of zAbsoluteName string */
25754:
25755: assert( zAbsoluteName[0]=='/' );
25756: n = (int)strlen(zAbsoluteName);
25757: pNew = sqlite3_malloc( sizeof(*pNew) + (n+1) );
25758: if( pNew==0 ) return 0;
25759: pNew->zCanonicalName = (char*)&pNew[1];
25760: memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
25761: n = vxworksSimplifyName(pNew->zCanonicalName, n);
25762:
25763: /* Search for an existing entry that matching the canonical name.
25764: ** If found, increment the reference count and return a pointer to
25765: ** the existing file ID.
25766: */
25767: unixEnterMutex();
25768: for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
25769: if( pCandidate->nName==n
25770: && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
25771: ){
25772: sqlite3_free(pNew);
25773: pCandidate->nRef++;
25774: unixLeaveMutex();
25775: return pCandidate;
25776: }
25777: }
25778:
25779: /* No match was found. We will make a new file ID */
25780: pNew->nRef = 1;
25781: pNew->nName = n;
25782: pNew->pNext = vxworksFileList;
25783: vxworksFileList = pNew;
25784: unixLeaveMutex();
25785: return pNew;
25786: }
25787:
25788: /*
25789: ** Decrement the reference count on a vxworksFileId object. Free
25790: ** the object when the reference count reaches zero.
25791: */
25792: static void vxworksReleaseFileId(struct vxworksFileId *pId){
25793: unixEnterMutex();
25794: assert( pId->nRef>0 );
25795: pId->nRef--;
25796: if( pId->nRef==0 ){
25797: struct vxworksFileId **pp;
25798: for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
25799: assert( *pp==pId );
25800: *pp = pId->pNext;
25801: sqlite3_free(pId);
25802: }
25803: unixLeaveMutex();
25804: }
25805: #endif /* OS_VXWORKS */
25806: /*************** End of Unique File ID Utility Used By VxWorks ****************
25807: ******************************************************************************/
25808:
25809:
25810: /******************************************************************************
25811: *************************** Posix Advisory Locking ****************************
25812: **
25813: ** POSIX advisory locks are broken by design. ANSI STD 1003.1 (1996)
25814: ** section 6.5.2.2 lines 483 through 490 specify that when a process
25815: ** sets or clears a lock, that operation overrides any prior locks set
25816: ** by the same process. It does not explicitly say so, but this implies
25817: ** that it overrides locks set by the same process using a different
25818: ** file descriptor. Consider this test case:
25819: **
25820: ** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644);
25821: ** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644);
25822: **
25823: ** Suppose ./file1 and ./file2 are really the same file (because
25824: ** one is a hard or symbolic link to the other) then if you set
25825: ** an exclusive lock on fd1, then try to get an exclusive lock
25826: ** on fd2, it works. I would have expected the second lock to
25827: ** fail since there was already a lock on the file due to fd1.
25828: ** But not so. Since both locks came from the same process, the
25829: ** second overrides the first, even though they were on different
25830: ** file descriptors opened on different file names.
25831: **
25832: ** This means that we cannot use POSIX locks to synchronize file access
25833: ** among competing threads of the same process. POSIX locks will work fine
25834: ** to synchronize access for threads in separate processes, but not
25835: ** threads within the same process.
25836: **
25837: ** To work around the problem, SQLite has to manage file locks internally
25838: ** on its own. Whenever a new database is opened, we have to find the
25839: ** specific inode of the database file (the inode is determined by the
25840: ** st_dev and st_ino fields of the stat structure that fstat() fills in)
25841: ** and check for locks already existing on that inode. When locks are
25842: ** created or removed, we have to look at our own internal record of the
25843: ** locks to see if another thread has previously set a lock on that same
25844: ** inode.
25845: **
25846: ** (Aside: The use of inode numbers as unique IDs does not work on VxWorks.
25847: ** For VxWorks, we have to use the alternative unique ID system based on
25848: ** canonical filename and implemented in the previous division.)
25849: **
25850: ** The sqlite3_file structure for POSIX is no longer just an integer file
25851: ** descriptor. It is now a structure that holds the integer file
25852: ** descriptor and a pointer to a structure that describes the internal
25853: ** locks on the corresponding inode. There is one locking structure
25854: ** per inode, so if the same inode is opened twice, both unixFile structures
25855: ** point to the same locking structure. The locking structure keeps
25856: ** a reference count (so we will know when to delete it) and a "cnt"
25857: ** field that tells us its internal lock status. cnt==0 means the
25858: ** file is unlocked. cnt==-1 means the file has an exclusive lock.
25859: ** cnt>0 means there are cnt shared locks on the file.
25860: **
25861: ** Any attempt to lock or unlock a file first checks the locking
25862: ** structure. The fcntl() system call is only invoked to set a
25863: ** POSIX lock if the internal lock structure transitions between
25864: ** a locked and an unlocked state.
25865: **
25866: ** But wait: there are yet more problems with POSIX advisory locks.
25867: **
25868: ** If you close a file descriptor that points to a file that has locks,
25869: ** all locks on that file that are owned by the current process are
25870: ** released. To work around this problem, each unixInodeInfo object
25871: ** maintains a count of the number of pending locks on tha inode.
25872: ** When an attempt is made to close an unixFile, if there are
25873: ** other unixFile open on the same inode that are holding locks, the call
25874: ** to close() the file descriptor is deferred until all of the locks clear.
25875: ** The unixInodeInfo structure keeps a list of file descriptors that need to
25876: ** be closed and that list is walked (and cleared) when the last lock
25877: ** clears.
25878: **
25879: ** Yet another problem: LinuxThreads do not play well with posix locks.
25880: **
25881: ** Many older versions of linux use the LinuxThreads library which is
25882: ** not posix compliant. Under LinuxThreads, a lock created by thread
25883: ** A cannot be modified or overridden by a different thread B.
25884: ** Only thread A can modify the lock. Locking behavior is correct
25885: ** if the appliation uses the newer Native Posix Thread Library (NPTL)
25886: ** on linux - with NPTL a lock created by thread A can override locks
25887: ** in thread B. But there is no way to know at compile-time which
25888: ** threading library is being used. So there is no way to know at
25889: ** compile-time whether or not thread A can override locks on thread B.
25890: ** One has to do a run-time check to discover the behavior of the
25891: ** current process.
25892: **
25893: ** SQLite used to support LinuxThreads. But support for LinuxThreads
25894: ** was dropped beginning with version 3.7.0. SQLite will still work with
25895: ** LinuxThreads provided that (1) there is no more than one connection
25896: ** per database file in the same process and (2) database connections
25897: ** do not move across threads.
25898: */
25899:
25900: /*
25901: ** An instance of the following structure serves as the key used
25902: ** to locate a particular unixInodeInfo object.
25903: */
25904: struct unixFileId {
25905: dev_t dev; /* Device number */
25906: #if OS_VXWORKS
25907: struct vxworksFileId *pId; /* Unique file ID for vxworks. */
25908: #else
25909: ino_t ino; /* Inode number */
25910: #endif
25911: };
25912:
25913: /*
25914: ** An instance of the following structure is allocated for each open
25915: ** inode. Or, on LinuxThreads, there is one of these structures for
25916: ** each inode opened by each thread.
25917: **
25918: ** A single inode can have multiple file descriptors, so each unixFile
25919: ** structure contains a pointer to an instance of this object and this
25920: ** object keeps a count of the number of unixFile pointing to it.
25921: */
25922: struct unixInodeInfo {
25923: struct unixFileId fileId; /* The lookup key */
25924: int nShared; /* Number of SHARED locks held */
25925: unsigned char eFileLock; /* One of SHARED_LOCK, RESERVED_LOCK etc. */
25926: unsigned char bProcessLock; /* An exclusive process lock is held */
25927: int nRef; /* Number of pointers to this structure */
25928: unixShmNode *pShmNode; /* Shared memory associated with this inode */
25929: int nLock; /* Number of outstanding file locks */
25930: UnixUnusedFd *pUnused; /* Unused file descriptors to close */
25931: unixInodeInfo *pNext; /* List of all unixInodeInfo objects */
25932: unixInodeInfo *pPrev; /* .... doubly linked */
25933: #if SQLITE_ENABLE_LOCKING_STYLE
25934: unsigned long long sharedByte; /* for AFP simulated shared lock */
25935: #endif
25936: #if OS_VXWORKS
25937: sem_t *pSem; /* Named POSIX semaphore */
25938: char aSemName[MAX_PATHNAME+2]; /* Name of that semaphore */
25939: #endif
25940: };
25941:
25942: /*
25943: ** A lists of all unixInodeInfo objects.
25944: */
25945: static unixInodeInfo *inodeList = 0;
25946:
25947: /*
25948: **
25949: ** This function - unixLogError_x(), is only ever called via the macro
25950: ** unixLogError().
25951: **
25952: ** It is invoked after an error occurs in an OS function and errno has been
25953: ** set. It logs a message using sqlite3_log() containing the current value of
25954: ** errno and, if possible, the human-readable equivalent from strerror() or
25955: ** strerror_r().
25956: **
25957: ** The first argument passed to the macro should be the error code that
25958: ** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN).
25959: ** The two subsequent arguments should be the name of the OS function that
25960: ** failed (e.g. "unlink", "open") and the the associated file-system path,
25961: ** if any.
25962: */
25963: #define unixLogError(a,b,c) unixLogErrorAtLine(a,b,c,__LINE__)
25964: static int unixLogErrorAtLine(
25965: int errcode, /* SQLite error code */
25966: const char *zFunc, /* Name of OS function that failed */
25967: const char *zPath, /* File path associated with error */
25968: int iLine /* Source line number where error occurred */
25969: ){
25970: char *zErr; /* Message from strerror() or equivalent */
25971: int iErrno = errno; /* Saved syscall error number */
25972:
25973: /* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
25974: ** the strerror() function to obtain the human-readable error message
25975: ** equivalent to errno. Otherwise, use strerror_r().
25976: */
25977: #if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R)
25978: char aErr[80];
25979: memset(aErr, 0, sizeof(aErr));
25980: zErr = aErr;
25981:
25982: /* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined,
25983: ** assume that the system provides the the GNU version of strerror_r() that
25984: ** returns a pointer to a buffer containing the error message. That pointer
25985: ** may point to aErr[], or it may point to some static storage somewhere.
25986: ** Otherwise, assume that the system provides the POSIX version of
25987: ** strerror_r(), which always writes an error message into aErr[].
25988: **
25989: ** If the code incorrectly assumes that it is the POSIX version that is
25990: ** available, the error message will often be an empty string. Not a
25991: ** huge problem. Incorrectly concluding that the GNU version is available
25992: ** could lead to a segfault though.
25993: */
25994: #if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)
25995: zErr =
25996: # endif
25997: strerror_r(iErrno, aErr, sizeof(aErr)-1);
25998:
25999: #elif SQLITE_THREADSAFE
26000: /* This is a threadsafe build, but strerror_r() is not available. */
26001: zErr = "";
26002: #else
26003: /* Non-threadsafe build, use strerror(). */
26004: zErr = strerror(iErrno);
26005: #endif
26006:
26007: assert( errcode!=SQLITE_OK );
26008: if( zPath==0 ) zPath = "";
26009: sqlite3_log(errcode,
26010: "os_unix.c:%d: (%d) %s(%s) - %s",
26011: iLine, iErrno, zFunc, zPath, zErr
26012: );
26013:
26014: return errcode;
26015: }
26016:
26017: /*
26018: ** Close a file descriptor.
26019: **
26020: ** We assume that close() almost always works, since it is only in a
26021: ** very sick application or on a very sick platform that it might fail.
26022: ** If it does fail, simply leak the file descriptor, but do log the
26023: ** error.
26024: **
26025: ** Note that it is not safe to retry close() after EINTR since the
26026: ** file descriptor might have already been reused by another thread.
26027: ** So we don't even try to recover from an EINTR. Just log the error
26028: ** and move on.
26029: */
26030: static void robust_close(unixFile *pFile, int h, int lineno){
26031: if( osClose(h) ){
26032: unixLogErrorAtLine(SQLITE_IOERR_CLOSE, "close",
26033: pFile ? pFile->zPath : 0, lineno);
26034: }
26035: }
26036:
26037: /*
26038: ** Close all file descriptors accumuated in the unixInodeInfo->pUnused list.
26039: */
26040: static void closePendingFds(unixFile *pFile){
26041: unixInodeInfo *pInode = pFile->pInode;
26042: UnixUnusedFd *p;
26043: UnixUnusedFd *pNext;
26044: for(p=pInode->pUnused; p; p=pNext){
26045: pNext = p->pNext;
26046: robust_close(pFile, p->fd, __LINE__);
26047: sqlite3_free(p);
26048: }
26049: pInode->pUnused = 0;
26050: }
26051:
26052: /*
26053: ** Release a unixInodeInfo structure previously allocated by findInodeInfo().
26054: **
26055: ** The mutex entered using the unixEnterMutex() function must be held
26056: ** when this function is called.
26057: */
26058: static void releaseInodeInfo(unixFile *pFile){
26059: unixInodeInfo *pInode = pFile->pInode;
26060: assert( unixMutexHeld() );
26061: if( ALWAYS(pInode) ){
26062: pInode->nRef--;
26063: if( pInode->nRef==0 ){
26064: assert( pInode->pShmNode==0 );
26065: closePendingFds(pFile);
26066: if( pInode->pPrev ){
26067: assert( pInode->pPrev->pNext==pInode );
26068: pInode->pPrev->pNext = pInode->pNext;
26069: }else{
26070: assert( inodeList==pInode );
26071: inodeList = pInode->pNext;
26072: }
26073: if( pInode->pNext ){
26074: assert( pInode->pNext->pPrev==pInode );
26075: pInode->pNext->pPrev = pInode->pPrev;
26076: }
26077: sqlite3_free(pInode);
26078: }
26079: }
26080: }
26081:
26082: /*
26083: ** Given a file descriptor, locate the unixInodeInfo object that
26084: ** describes that file descriptor. Create a new one if necessary. The
26085: ** return value might be uninitialized if an error occurs.
26086: **
26087: ** The mutex entered using the unixEnterMutex() function must be held
26088: ** when this function is called.
26089: **
26090: ** Return an appropriate error code.
26091: */
26092: static int findInodeInfo(
26093: unixFile *pFile, /* Unix file with file desc used in the key */
26094: unixInodeInfo **ppInode /* Return the unixInodeInfo object here */
26095: ){
26096: int rc; /* System call return code */
26097: int fd; /* The file descriptor for pFile */
26098: struct unixFileId fileId; /* Lookup key for the unixInodeInfo */
26099: struct stat statbuf; /* Low-level file information */
26100: unixInodeInfo *pInode = 0; /* Candidate unixInodeInfo object */
26101:
26102: assert( unixMutexHeld() );
26103:
26104: /* Get low-level information about the file that we can used to
26105: ** create a unique name for the file.
26106: */
26107: fd = pFile->h;
26108: rc = osFstat(fd, &statbuf);
26109: if( rc!=0 ){
26110: pFile->lastErrno = errno;
26111: #ifdef EOVERFLOW
26112: if( pFile->lastErrno==EOVERFLOW ) return SQLITE_NOLFS;
26113: #endif
26114: return SQLITE_IOERR;
26115: }
26116:
26117: #ifdef __APPLE__
26118: /* On OS X on an msdos filesystem, the inode number is reported
26119: ** incorrectly for zero-size files. See ticket #3260. To work
26120: ** around this problem (we consider it a bug in OS X, not SQLite)
26121: ** we always increase the file size to 1 by writing a single byte
26122: ** prior to accessing the inode number. The one byte written is
26123: ** an ASCII 'S' character which also happens to be the first byte
26124: ** in the header of every SQLite database. In this way, if there
26125: ** is a race condition such that another thread has already populated
26126: ** the first page of the database, no damage is done.
26127: */
26128: if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
26129: do{ rc = osWrite(fd, "S", 1); }while( rc<0 && errno==EINTR );
26130: if( rc!=1 ){
26131: pFile->lastErrno = errno;
26132: return SQLITE_IOERR;
26133: }
26134: rc = osFstat(fd, &statbuf);
26135: if( rc!=0 ){
26136: pFile->lastErrno = errno;
26137: return SQLITE_IOERR;
26138: }
26139: }
26140: #endif
26141:
26142: memset(&fileId, 0, sizeof(fileId));
26143: fileId.dev = statbuf.st_dev;
26144: #if OS_VXWORKS
26145: fileId.pId = pFile->pId;
26146: #else
26147: fileId.ino = statbuf.st_ino;
26148: #endif
26149: pInode = inodeList;
26150: while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){
26151: pInode = pInode->pNext;
26152: }
26153: if( pInode==0 ){
26154: pInode = sqlite3_malloc( sizeof(*pInode) );
26155: if( pInode==0 ){
26156: return SQLITE_NOMEM;
26157: }
26158: memset(pInode, 0, sizeof(*pInode));
26159: memcpy(&pInode->fileId, &fileId, sizeof(fileId));
26160: pInode->nRef = 1;
26161: pInode->pNext = inodeList;
26162: pInode->pPrev = 0;
26163: if( inodeList ) inodeList->pPrev = pInode;
26164: inodeList = pInode;
26165: }else{
26166: pInode->nRef++;
26167: }
26168: *ppInode = pInode;
26169: return SQLITE_OK;
26170: }
26171:
26172:
26173: /*
26174: ** This routine checks if there is a RESERVED lock held on the specified
26175: ** file by this or any other process. If such a lock is held, set *pResOut
26176: ** to a non-zero value otherwise *pResOut is set to zero. The return value
26177: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26178: */
26179: static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
26180: int rc = SQLITE_OK;
26181: int reserved = 0;
26182: unixFile *pFile = (unixFile*)id;
26183:
26184: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
26185:
26186: assert( pFile );
26187: unixEnterMutex(); /* Because pFile->pInode is shared across threads */
26188:
26189: /* Check if a thread in this process holds such a lock */
26190: if( pFile->pInode->eFileLock>SHARED_LOCK ){
26191: reserved = 1;
26192: }
26193:
26194: /* Otherwise see if some other process holds it.
26195: */
26196: #ifndef __DJGPP__
26197: if( !reserved && !pFile->pInode->bProcessLock ){
26198: struct flock lock;
26199: lock.l_whence = SEEK_SET;
26200: lock.l_start = RESERVED_BYTE;
26201: lock.l_len = 1;
26202: lock.l_type = F_WRLCK;
26203: if( osFcntl(pFile->h, F_GETLK, &lock) ){
26204: rc = SQLITE_IOERR_CHECKRESERVEDLOCK;
26205: pFile->lastErrno = errno;
26206: } else if( lock.l_type!=F_UNLCK ){
26207: reserved = 1;
26208: }
26209: }
26210: #endif
26211:
26212: unixLeaveMutex();
26213: OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
26214:
26215: *pResOut = reserved;
26216: return rc;
26217: }
26218:
26219: /*
26220: ** Attempt to set a system-lock on the file pFile. The lock is
26221: ** described by pLock.
26222: **
26223: ** If the pFile was opened read/write from unix-excl, then the only lock
26224: ** ever obtained is an exclusive lock, and it is obtained exactly once
26225: ** the first time any lock is attempted. All subsequent system locking
26226: ** operations become no-ops. Locking operations still happen internally,
26227: ** in order to coordinate access between separate database connections
26228: ** within this process, but all of that is handled in memory and the
26229: ** operating system does not participate.
26230: **
26231: ** This function is a pass-through to fcntl(F_SETLK) if pFile is using
26232: ** any VFS other than "unix-excl" or if pFile is opened on "unix-excl"
26233: ** and is read-only.
26234: **
26235: ** Zero is returned if the call completes successfully, or -1 if a call
26236: ** to fcntl() fails. In this case, errno is set appropriately (by fcntl()).
26237: */
26238: static int unixFileLock(unixFile *pFile, struct flock *pLock){
26239: int rc;
26240: unixInodeInfo *pInode = pFile->pInode;
26241: assert( unixMutexHeld() );
26242: assert( pInode!=0 );
26243: if( ((pFile->ctrlFlags & UNIXFILE_EXCL)!=0 || pInode->bProcessLock)
26244: && ((pFile->ctrlFlags & UNIXFILE_RDONLY)==0)
26245: ){
26246: if( pInode->bProcessLock==0 ){
26247: struct flock lock;
26248: assert( pInode->nLock==0 );
26249: lock.l_whence = SEEK_SET;
26250: lock.l_start = SHARED_FIRST;
26251: lock.l_len = SHARED_SIZE;
26252: lock.l_type = F_WRLCK;
26253: rc = osFcntl(pFile->h, F_SETLK, &lock);
26254: if( rc<0 ) return rc;
26255: pInode->bProcessLock = 1;
26256: pInode->nLock++;
26257: }else{
26258: rc = 0;
26259: }
26260: }else{
26261: rc = osFcntl(pFile->h, F_SETLK, pLock);
26262: }
26263: return rc;
26264: }
26265:
26266: /*
26267: ** Lock the file with the lock specified by parameter eFileLock - one
26268: ** of the following:
26269: **
26270: ** (1) SHARED_LOCK
26271: ** (2) RESERVED_LOCK
26272: ** (3) PENDING_LOCK
26273: ** (4) EXCLUSIVE_LOCK
26274: **
26275: ** Sometimes when requesting one lock state, additional lock states
26276: ** are inserted in between. The locking might fail on one of the later
26277: ** transitions leaving the lock state different from what it started but
26278: ** still short of its goal. The following chart shows the allowed
26279: ** transitions and the inserted intermediate states:
26280: **
26281: ** UNLOCKED -> SHARED
26282: ** SHARED -> RESERVED
26283: ** SHARED -> (PENDING) -> EXCLUSIVE
26284: ** RESERVED -> (PENDING) -> EXCLUSIVE
26285: ** PENDING -> EXCLUSIVE
26286: **
26287: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
26288: ** routine to lower a locking level.
26289: */
26290: static int unixLock(sqlite3_file *id, int eFileLock){
26291: /* The following describes the implementation of the various locks and
26292: ** lock transitions in terms of the POSIX advisory shared and exclusive
26293: ** lock primitives (called read-locks and write-locks below, to avoid
26294: ** confusion with SQLite lock names). The algorithms are complicated
26295: ** slightly in order to be compatible with windows systems simultaneously
26296: ** accessing the same database file, in case that is ever required.
26297: **
26298: ** Symbols defined in os.h indentify the 'pending byte' and the 'reserved
26299: ** byte', each single bytes at well known offsets, and the 'shared byte
26300: ** range', a range of 510 bytes at a well known offset.
26301: **
26302: ** To obtain a SHARED lock, a read-lock is obtained on the 'pending
26303: ** byte'. If this is successful, a random byte from the 'shared byte
26304: ** range' is read-locked and the lock on the 'pending byte' released.
26305: **
26306: ** A process may only obtain a RESERVED lock after it has a SHARED lock.
26307: ** A RESERVED lock is implemented by grabbing a write-lock on the
26308: ** 'reserved byte'.
26309: **
26310: ** A process may only obtain a PENDING lock after it has obtained a
26311: ** SHARED lock. A PENDING lock is implemented by obtaining a write-lock
26312: ** on the 'pending byte'. This ensures that no new SHARED locks can be
26313: ** obtained, but existing SHARED locks are allowed to persist. A process
26314: ** does not have to obtain a RESERVED lock on the way to a PENDING lock.
26315: ** This property is used by the algorithm for rolling back a journal file
26316: ** after a crash.
26317: **
26318: ** An EXCLUSIVE lock, obtained after a PENDING lock is held, is
26319: ** implemented by obtaining a write-lock on the entire 'shared byte
26320: ** range'. Since all other locks require a read-lock on one of the bytes
26321: ** within this range, this ensures that no other locks are held on the
26322: ** database.
26323: **
26324: ** The reason a single byte cannot be used instead of the 'shared byte
26325: ** range' is that some versions of windows do not support read-locks. By
26326: ** locking a random byte from a range, concurrent SHARED locks may exist
26327: ** even if the locking primitive used is always a write-lock.
26328: */
26329: int rc = SQLITE_OK;
26330: unixFile *pFile = (unixFile*)id;
26331: unixInodeInfo *pInode;
26332: struct flock lock;
26333: int tErrno = 0;
26334:
26335: assert( pFile );
26336: OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
26337: azFileLock(eFileLock), azFileLock(pFile->eFileLock),
26338: azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared , getpid()));
26339:
26340: /* If there is already a lock of this type or more restrictive on the
26341: ** unixFile, do nothing. Don't use the end_lock: exit path, as
26342: ** unixEnterMutex() hasn't been called yet.
26343: */
26344: if( pFile->eFileLock>=eFileLock ){
26345: OSTRACE(("LOCK %d %s ok (already held) (unix)\n", pFile->h,
26346: azFileLock(eFileLock)));
26347: return SQLITE_OK;
26348: }
26349:
26350: /* Make sure the locking sequence is correct.
26351: ** (1) We never move from unlocked to anything higher than shared lock.
26352: ** (2) SQLite never explicitly requests a pendig lock.
26353: ** (3) A shared lock is always held when a reserve lock is requested.
26354: */
26355: assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
26356: assert( eFileLock!=PENDING_LOCK );
26357: assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
26358:
26359: /* This mutex is needed because pFile->pInode is shared across threads
26360: */
26361: unixEnterMutex();
26362: pInode = pFile->pInode;
26363:
26364: /* If some thread using this PID has a lock via a different unixFile*
26365: ** handle that precludes the requested lock, return BUSY.
26366: */
26367: if( (pFile->eFileLock!=pInode->eFileLock &&
26368: (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
26369: ){
26370: rc = SQLITE_BUSY;
26371: goto end_lock;
26372: }
26373:
26374: /* If a SHARED lock is requested, and some thread using this PID already
26375: ** has a SHARED or RESERVED lock, then increment reference counts and
26376: ** return SQLITE_OK.
26377: */
26378: if( eFileLock==SHARED_LOCK &&
26379: (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
26380: assert( eFileLock==SHARED_LOCK );
26381: assert( pFile->eFileLock==0 );
26382: assert( pInode->nShared>0 );
26383: pFile->eFileLock = SHARED_LOCK;
26384: pInode->nShared++;
26385: pInode->nLock++;
26386: goto end_lock;
26387: }
26388:
26389:
26390: /* A PENDING lock is needed before acquiring a SHARED lock and before
26391: ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
26392: ** be released.
26393: */
26394: lock.l_len = 1L;
26395: lock.l_whence = SEEK_SET;
26396: if( eFileLock==SHARED_LOCK
26397: || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
26398: ){
26399: lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
26400: lock.l_start = PENDING_BYTE;
26401: if( unixFileLock(pFile, &lock) ){
26402: tErrno = errno;
26403: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
26404: if( rc!=SQLITE_BUSY ){
26405: pFile->lastErrno = tErrno;
26406: }
26407: goto end_lock;
26408: }
26409: }
26410:
26411:
26412: /* If control gets to this point, then actually go ahead and make
26413: ** operating system calls for the specified lock.
26414: */
26415: if( eFileLock==SHARED_LOCK ){
26416: assert( pInode->nShared==0 );
26417: assert( pInode->eFileLock==0 );
26418: assert( rc==SQLITE_OK );
26419:
26420: /* Now get the read-lock */
26421: lock.l_start = SHARED_FIRST;
26422: lock.l_len = SHARED_SIZE;
26423: if( unixFileLock(pFile, &lock) ){
26424: tErrno = errno;
26425: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
26426: }
26427:
26428: /* Drop the temporary PENDING lock */
26429: lock.l_start = PENDING_BYTE;
26430: lock.l_len = 1L;
26431: lock.l_type = F_UNLCK;
26432: if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
26433: /* This could happen with a network mount */
26434: tErrno = errno;
26435: rc = SQLITE_IOERR_UNLOCK;
26436: }
26437:
26438: if( rc ){
26439: if( rc!=SQLITE_BUSY ){
26440: pFile->lastErrno = tErrno;
26441: }
26442: goto end_lock;
26443: }else{
26444: pFile->eFileLock = SHARED_LOCK;
26445: pInode->nLock++;
26446: pInode->nShared = 1;
26447: }
26448: }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
26449: /* We are trying for an exclusive lock but another thread in this
26450: ** same process is still holding a shared lock. */
26451: rc = SQLITE_BUSY;
26452: }else{
26453: /* The request was for a RESERVED or EXCLUSIVE lock. It is
26454: ** assumed that there is a SHARED or greater lock on the file
26455: ** already.
26456: */
26457: assert( 0!=pFile->eFileLock );
26458: lock.l_type = F_WRLCK;
26459:
26460: assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
26461: if( eFileLock==RESERVED_LOCK ){
26462: lock.l_start = RESERVED_BYTE;
26463: lock.l_len = 1L;
26464: }else{
26465: lock.l_start = SHARED_FIRST;
26466: lock.l_len = SHARED_SIZE;
26467: }
26468:
26469: if( unixFileLock(pFile, &lock) ){
26470: tErrno = errno;
26471: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
26472: if( rc!=SQLITE_BUSY ){
26473: pFile->lastErrno = tErrno;
26474: }
26475: }
26476: }
26477:
26478:
26479: #ifndef NDEBUG
26480: /* Set up the transaction-counter change checking flags when
26481: ** transitioning from a SHARED to a RESERVED lock. The change
26482: ** from SHARED to RESERVED marks the beginning of a normal
26483: ** write operation (not a hot journal rollback).
26484: */
26485: if( rc==SQLITE_OK
26486: && pFile->eFileLock<=SHARED_LOCK
26487: && eFileLock==RESERVED_LOCK
26488: ){
26489: pFile->transCntrChng = 0;
26490: pFile->dbUpdate = 0;
26491: pFile->inNormalWrite = 1;
26492: }
26493: #endif
26494:
26495:
26496: if( rc==SQLITE_OK ){
26497: pFile->eFileLock = eFileLock;
26498: pInode->eFileLock = eFileLock;
26499: }else if( eFileLock==EXCLUSIVE_LOCK ){
26500: pFile->eFileLock = PENDING_LOCK;
26501: pInode->eFileLock = PENDING_LOCK;
26502: }
26503:
26504: end_lock:
26505: unixLeaveMutex();
26506: OSTRACE(("LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
26507: rc==SQLITE_OK ? "ok" : "failed"));
26508: return rc;
26509: }
26510:
26511: /*
26512: ** Add the file descriptor used by file handle pFile to the corresponding
26513: ** pUnused list.
26514: */
26515: static void setPendingFd(unixFile *pFile){
26516: unixInodeInfo *pInode = pFile->pInode;
26517: UnixUnusedFd *p = pFile->pUnused;
26518: p->pNext = pInode->pUnused;
26519: pInode->pUnused = p;
26520: pFile->h = -1;
26521: pFile->pUnused = 0;
26522: }
26523:
26524: /*
26525: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
26526: ** must be either NO_LOCK or SHARED_LOCK.
26527: **
26528: ** If the locking level of the file descriptor is already at or below
26529: ** the requested locking level, this routine is a no-op.
26530: **
26531: ** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
26532: ** the byte range is divided into 2 parts and the first part is unlocked then
26533: ** set to a read lock, then the other part is simply unlocked. This works
26534: ** around a bug in BSD NFS lockd (also seen on MacOSX 10.3+) that fails to
26535: ** remove the write lock on a region when a read lock is set.
26536: */
26537: static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
26538: unixFile *pFile = (unixFile*)id;
26539: unixInodeInfo *pInode;
26540: struct flock lock;
26541: int rc = SQLITE_OK;
26542:
26543: assert( pFile );
26544: OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
26545: pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
26546: getpid()));
26547:
26548: assert( eFileLock<=SHARED_LOCK );
26549: if( pFile->eFileLock<=eFileLock ){
26550: return SQLITE_OK;
26551: }
26552: unixEnterMutex();
26553: pInode = pFile->pInode;
26554: assert( pInode->nShared!=0 );
26555: if( pFile->eFileLock>SHARED_LOCK ){
26556: assert( pInode->eFileLock==pFile->eFileLock );
26557:
26558: #ifndef NDEBUG
26559: /* When reducing a lock such that other processes can start
26560: ** reading the database file again, make sure that the
26561: ** transaction counter was updated if any part of the database
26562: ** file changed. If the transaction counter is not updated,
26563: ** other connections to the same file might not realize that
26564: ** the file has changed and hence might not know to flush their
26565: ** cache. The use of a stale cache can lead to database corruption.
26566: */
26567: pFile->inNormalWrite = 0;
26568: #endif
26569:
26570: /* downgrading to a shared lock on NFS involves clearing the write lock
26571: ** before establishing the readlock - to avoid a race condition we downgrade
26572: ** the lock in 2 blocks, so that part of the range will be covered by a
26573: ** write lock until the rest is covered by a read lock:
26574: ** 1: [WWWWW]
26575: ** 2: [....W]
26576: ** 3: [RRRRW]
26577: ** 4: [RRRR.]
26578: */
26579: if( eFileLock==SHARED_LOCK ){
26580:
26581: #if !defined(__APPLE__) || !SQLITE_ENABLE_LOCKING_STYLE
26582: (void)handleNFSUnlock;
26583: assert( handleNFSUnlock==0 );
26584: #endif
26585: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
26586: if( handleNFSUnlock ){
26587: int tErrno; /* Error code from system call errors */
26588: off_t divSize = SHARED_SIZE - 1;
26589:
26590: lock.l_type = F_UNLCK;
26591: lock.l_whence = SEEK_SET;
26592: lock.l_start = SHARED_FIRST;
26593: lock.l_len = divSize;
26594: if( unixFileLock(pFile, &lock)==(-1) ){
26595: tErrno = errno;
26596: rc = SQLITE_IOERR_UNLOCK;
26597: if( IS_LOCK_ERROR(rc) ){
26598: pFile->lastErrno = tErrno;
26599: }
26600: goto end_unlock;
26601: }
26602: lock.l_type = F_RDLCK;
26603: lock.l_whence = SEEK_SET;
26604: lock.l_start = SHARED_FIRST;
26605: lock.l_len = divSize;
26606: if( unixFileLock(pFile, &lock)==(-1) ){
26607: tErrno = errno;
26608: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK);
26609: if( IS_LOCK_ERROR(rc) ){
26610: pFile->lastErrno = tErrno;
26611: }
26612: goto end_unlock;
26613: }
26614: lock.l_type = F_UNLCK;
26615: lock.l_whence = SEEK_SET;
26616: lock.l_start = SHARED_FIRST+divSize;
26617: lock.l_len = SHARED_SIZE-divSize;
26618: if( unixFileLock(pFile, &lock)==(-1) ){
26619: tErrno = errno;
26620: rc = SQLITE_IOERR_UNLOCK;
26621: if( IS_LOCK_ERROR(rc) ){
26622: pFile->lastErrno = tErrno;
26623: }
26624: goto end_unlock;
26625: }
26626: }else
26627: #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
26628: {
26629: lock.l_type = F_RDLCK;
26630: lock.l_whence = SEEK_SET;
26631: lock.l_start = SHARED_FIRST;
26632: lock.l_len = SHARED_SIZE;
26633: if( unixFileLock(pFile, &lock) ){
26634: /* In theory, the call to unixFileLock() cannot fail because another
26635: ** process is holding an incompatible lock. If it does, this
26636: ** indicates that the other process is not following the locking
26637: ** protocol. If this happens, return SQLITE_IOERR_RDLOCK. Returning
26638: ** SQLITE_BUSY would confuse the upper layer (in practice it causes
26639: ** an assert to fail). */
26640: rc = SQLITE_IOERR_RDLOCK;
26641: pFile->lastErrno = errno;
26642: goto end_unlock;
26643: }
26644: }
26645: }
26646: lock.l_type = F_UNLCK;
26647: lock.l_whence = SEEK_SET;
26648: lock.l_start = PENDING_BYTE;
26649: lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
26650: if( unixFileLock(pFile, &lock)==0 ){
26651: pInode->eFileLock = SHARED_LOCK;
26652: }else{
26653: rc = SQLITE_IOERR_UNLOCK;
26654: pFile->lastErrno = errno;
26655: goto end_unlock;
26656: }
26657: }
26658: if( eFileLock==NO_LOCK ){
26659: /* Decrement the shared lock counter. Release the lock using an
26660: ** OS call only when all threads in this same process have released
26661: ** the lock.
26662: */
26663: pInode->nShared--;
26664: if( pInode->nShared==0 ){
26665: lock.l_type = F_UNLCK;
26666: lock.l_whence = SEEK_SET;
26667: lock.l_start = lock.l_len = 0L;
26668: if( unixFileLock(pFile, &lock)==0 ){
26669: pInode->eFileLock = NO_LOCK;
26670: }else{
26671: rc = SQLITE_IOERR_UNLOCK;
26672: pFile->lastErrno = errno;
26673: pInode->eFileLock = NO_LOCK;
26674: pFile->eFileLock = NO_LOCK;
26675: }
26676: }
26677:
26678: /* Decrement the count of locks against this same file. When the
26679: ** count reaches zero, close any other file descriptors whose close
26680: ** was deferred because of outstanding locks.
26681: */
26682: pInode->nLock--;
26683: assert( pInode->nLock>=0 );
26684: if( pInode->nLock==0 ){
26685: closePendingFds(pFile);
26686: }
26687: }
26688:
26689: end_unlock:
26690: unixLeaveMutex();
26691: if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
26692: return rc;
26693: }
26694:
26695: /*
26696: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
26697: ** must be either NO_LOCK or SHARED_LOCK.
26698: **
26699: ** If the locking level of the file descriptor is already at or below
26700: ** the requested locking level, this routine is a no-op.
26701: */
26702: static int unixUnlock(sqlite3_file *id, int eFileLock){
26703: return posixUnlock(id, eFileLock, 0);
26704: }
26705:
26706: /*
26707: ** This function performs the parts of the "close file" operation
26708: ** common to all locking schemes. It closes the directory and file
26709: ** handles, if they are valid, and sets all fields of the unixFile
26710: ** structure to 0.
26711: **
26712: ** It is *not* necessary to hold the mutex when this routine is called,
26713: ** even on VxWorks. A mutex will be acquired on VxWorks by the
26714: ** vxworksReleaseFileId() routine.
26715: */
26716: static int closeUnixFile(sqlite3_file *id){
26717: unixFile *pFile = (unixFile*)id;
26718: if( pFile->h>=0 ){
26719: robust_close(pFile, pFile->h, __LINE__);
26720: pFile->h = -1;
26721: }
26722: #if OS_VXWORKS
26723: if( pFile->pId ){
26724: if( pFile->ctrlFlags & UNIXFILE_DELETE ){
26725: osUnlink(pFile->pId->zCanonicalName);
26726: }
26727: vxworksReleaseFileId(pFile->pId);
26728: pFile->pId = 0;
26729: }
26730: #endif
26731: OSTRACE(("CLOSE %-3d\n", pFile->h));
26732: OpenCounter(-1);
26733: sqlite3_free(pFile->pUnused);
26734: memset(pFile, 0, sizeof(unixFile));
26735: return SQLITE_OK;
26736: }
26737:
26738: /*
26739: ** Close a file.
26740: */
26741: static int unixClose(sqlite3_file *id){
26742: int rc = SQLITE_OK;
26743: unixFile *pFile = (unixFile *)id;
26744: unixUnlock(id, NO_LOCK);
26745: unixEnterMutex();
26746:
26747: /* unixFile.pInode is always valid here. Otherwise, a different close
26748: ** routine (e.g. nolockClose()) would be called instead.
26749: */
26750: assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
26751: if( ALWAYS(pFile->pInode) && pFile->pInode->nLock ){
26752: /* If there are outstanding locks, do not actually close the file just
26753: ** yet because that would clear those locks. Instead, add the file
26754: ** descriptor to pInode->pUnused list. It will be automatically closed
26755: ** when the last lock is cleared.
26756: */
26757: setPendingFd(pFile);
26758: }
26759: releaseInodeInfo(pFile);
26760: rc = closeUnixFile(id);
26761: unixLeaveMutex();
26762: return rc;
26763: }
26764:
26765: /************** End of the posix advisory lock implementation *****************
26766: ******************************************************************************/
26767:
26768: /******************************************************************************
26769: ****************************** No-op Locking **********************************
26770: **
26771: ** Of the various locking implementations available, this is by far the
26772: ** simplest: locking is ignored. No attempt is made to lock the database
26773: ** file for reading or writing.
26774: **
26775: ** This locking mode is appropriate for use on read-only databases
26776: ** (ex: databases that are burned into CD-ROM, for example.) It can
26777: ** also be used if the application employs some external mechanism to
26778: ** prevent simultaneous access of the same database by two or more
26779: ** database connections. But there is a serious risk of database
26780: ** corruption if this locking mode is used in situations where multiple
26781: ** database connections are accessing the same database file at the same
26782: ** time and one or more of those connections are writing.
26783: */
26784:
26785: static int nolockCheckReservedLock(sqlite3_file *NotUsed, int *pResOut){
26786: UNUSED_PARAMETER(NotUsed);
26787: *pResOut = 0;
26788: return SQLITE_OK;
26789: }
26790: static int nolockLock(sqlite3_file *NotUsed, int NotUsed2){
26791: UNUSED_PARAMETER2(NotUsed, NotUsed2);
26792: return SQLITE_OK;
26793: }
26794: static int nolockUnlock(sqlite3_file *NotUsed, int NotUsed2){
26795: UNUSED_PARAMETER2(NotUsed, NotUsed2);
26796: return SQLITE_OK;
26797: }
26798:
26799: /*
26800: ** Close the file.
26801: */
26802: static int nolockClose(sqlite3_file *id) {
26803: return closeUnixFile(id);
26804: }
26805:
26806: /******************* End of the no-op lock implementation *********************
26807: ******************************************************************************/
26808:
26809: /******************************************************************************
26810: ************************* Begin dot-file Locking ******************************
26811: **
26812: ** The dotfile locking implementation uses the existance of separate lock
26813: ** files (really a directory) to control access to the database. This works
26814: ** on just about every filesystem imaginable. But there are serious downsides:
26815: **
26816: ** (1) There is zero concurrency. A single reader blocks all other
26817: ** connections from reading or writing the database.
26818: **
26819: ** (2) An application crash or power loss can leave stale lock files
26820: ** sitting around that need to be cleared manually.
26821: **
26822: ** Nevertheless, a dotlock is an appropriate locking mode for use if no
26823: ** other locking strategy is available.
26824: **
26825: ** Dotfile locking works by creating a subdirectory in the same directory as
26826: ** the database and with the same name but with a ".lock" extension added.
26827: ** The existance of a lock directory implies an EXCLUSIVE lock. All other
26828: ** lock types (SHARED, RESERVED, PENDING) are mapped into EXCLUSIVE.
26829: */
26830:
26831: /*
26832: ** The file suffix added to the data base filename in order to create the
26833: ** lock directory.
26834: */
26835: #define DOTLOCK_SUFFIX ".lock"
26836:
26837: /*
26838: ** This routine checks if there is a RESERVED lock held on the specified
26839: ** file by this or any other process. If such a lock is held, set *pResOut
26840: ** to a non-zero value otherwise *pResOut is set to zero. The return value
26841: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
26842: **
26843: ** In dotfile locking, either a lock exists or it does not. So in this
26844: ** variation of CheckReservedLock(), *pResOut is set to true if any lock
26845: ** is held on the file and false if the file is unlocked.
26846: */
26847: static int dotlockCheckReservedLock(sqlite3_file *id, int *pResOut) {
26848: int rc = SQLITE_OK;
26849: int reserved = 0;
26850: unixFile *pFile = (unixFile*)id;
26851:
26852: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
26853:
26854: assert( pFile );
26855:
26856: /* Check if a thread in this process holds such a lock */
26857: if( pFile->eFileLock>SHARED_LOCK ){
26858: /* Either this connection or some other connection in the same process
26859: ** holds a lock on the file. No need to check further. */
26860: reserved = 1;
26861: }else{
26862: /* The lock is held if and only if the lockfile exists */
26863: const char *zLockFile = (const char*)pFile->lockingContext;
26864: reserved = osAccess(zLockFile, 0)==0;
26865: }
26866: OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
26867: *pResOut = reserved;
26868: return rc;
26869: }
26870:
26871: /*
26872: ** Lock the file with the lock specified by parameter eFileLock - one
26873: ** of the following:
26874: **
26875: ** (1) SHARED_LOCK
26876: ** (2) RESERVED_LOCK
26877: ** (3) PENDING_LOCK
26878: ** (4) EXCLUSIVE_LOCK
26879: **
26880: ** Sometimes when requesting one lock state, additional lock states
26881: ** are inserted in between. The locking might fail on one of the later
26882: ** transitions leaving the lock state different from what it started but
26883: ** still short of its goal. The following chart shows the allowed
26884: ** transitions and the inserted intermediate states:
26885: **
26886: ** UNLOCKED -> SHARED
26887: ** SHARED -> RESERVED
26888: ** SHARED -> (PENDING) -> EXCLUSIVE
26889: ** RESERVED -> (PENDING) -> EXCLUSIVE
26890: ** PENDING -> EXCLUSIVE
26891: **
26892: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
26893: ** routine to lower a locking level.
26894: **
26895: ** With dotfile locking, we really only support state (4): EXCLUSIVE.
26896: ** But we track the other locking levels internally.
26897: */
26898: static int dotlockLock(sqlite3_file *id, int eFileLock) {
26899: unixFile *pFile = (unixFile*)id;
26900: char *zLockFile = (char *)pFile->lockingContext;
26901: int rc = SQLITE_OK;
26902:
26903:
26904: /* If we have any lock, then the lock file already exists. All we have
26905: ** to do is adjust our internal record of the lock level.
26906: */
26907: if( pFile->eFileLock > NO_LOCK ){
26908: pFile->eFileLock = eFileLock;
26909: /* Always update the timestamp on the old file */
26910: #ifdef HAVE_UTIME
26911: utime(zLockFile, NULL);
26912: #else
26913: utimes(zLockFile, NULL);
26914: #endif
26915: return SQLITE_OK;
26916: }
26917:
26918: /* grab an exclusive lock */
26919: rc = osMkdir(zLockFile, 0777);
26920: if( rc<0 ){
26921: /* failed to open/create the lock directory */
26922: int tErrno = errno;
26923: if( EEXIST == tErrno ){
26924: rc = SQLITE_BUSY;
26925: } else {
26926: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
26927: if( IS_LOCK_ERROR(rc) ){
26928: pFile->lastErrno = tErrno;
26929: }
26930: }
26931: return rc;
26932: }
26933:
26934: /* got it, set the type and return ok */
26935: pFile->eFileLock = eFileLock;
26936: return rc;
26937: }
26938:
26939: /*
26940: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
26941: ** must be either NO_LOCK or SHARED_LOCK.
26942: **
26943: ** If the locking level of the file descriptor is already at or below
26944: ** the requested locking level, this routine is a no-op.
26945: **
26946: ** When the locking level reaches NO_LOCK, delete the lock file.
26947: */
26948: static int dotlockUnlock(sqlite3_file *id, int eFileLock) {
26949: unixFile *pFile = (unixFile*)id;
26950: char *zLockFile = (char *)pFile->lockingContext;
26951: int rc;
26952:
26953: assert( pFile );
26954: OSTRACE(("UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
26955: pFile->eFileLock, getpid()));
26956: assert( eFileLock<=SHARED_LOCK );
26957:
26958: /* no-op if possible */
26959: if( pFile->eFileLock==eFileLock ){
26960: return SQLITE_OK;
26961: }
26962:
26963: /* To downgrade to shared, simply update our internal notion of the
26964: ** lock state. No need to mess with the file on disk.
26965: */
26966: if( eFileLock==SHARED_LOCK ){
26967: pFile->eFileLock = SHARED_LOCK;
26968: return SQLITE_OK;
26969: }
26970:
26971: /* To fully unlock the database, delete the lock file */
26972: assert( eFileLock==NO_LOCK );
26973: rc = osRmdir(zLockFile);
26974: if( rc<0 && errno==ENOTDIR ) rc = osUnlink(zLockFile);
26975: if( rc<0 ){
26976: int tErrno = errno;
26977: rc = 0;
26978: if( ENOENT != tErrno ){
26979: rc = SQLITE_IOERR_UNLOCK;
26980: }
26981: if( IS_LOCK_ERROR(rc) ){
26982: pFile->lastErrno = tErrno;
26983: }
26984: return rc;
26985: }
26986: pFile->eFileLock = NO_LOCK;
26987: return SQLITE_OK;
26988: }
26989:
26990: /*
26991: ** Close a file. Make sure the lock has been released before closing.
26992: */
26993: static int dotlockClose(sqlite3_file *id) {
26994: int rc;
26995: if( id ){
26996: unixFile *pFile = (unixFile*)id;
26997: dotlockUnlock(id, NO_LOCK);
26998: sqlite3_free(pFile->lockingContext);
26999: }
27000: rc = closeUnixFile(id);
27001: return rc;
27002: }
27003: /****************** End of the dot-file lock implementation *******************
27004: ******************************************************************************/
27005:
27006: /******************************************************************************
27007: ************************** Begin flock Locking ********************************
27008: **
27009: ** Use the flock() system call to do file locking.
27010: **
27011: ** flock() locking is like dot-file locking in that the various
27012: ** fine-grain locking levels supported by SQLite are collapsed into
27013: ** a single exclusive lock. In other words, SHARED, RESERVED, and
27014: ** PENDING locks are the same thing as an EXCLUSIVE lock. SQLite
27015: ** still works when you do this, but concurrency is reduced since
27016: ** only a single process can be reading the database at a time.
27017: **
27018: ** Omit this section if SQLITE_ENABLE_LOCKING_STYLE is turned off or if
27019: ** compiling for VXWORKS.
27020: */
27021: #if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
27022:
27023: /*
27024: ** Retry flock() calls that fail with EINTR
27025: */
27026: #ifdef EINTR
27027: static int robust_flock(int fd, int op){
27028: int rc;
27029: do{ rc = flock(fd,op); }while( rc<0 && errno==EINTR );
27030: return rc;
27031: }
27032: #else
27033: # define robust_flock(a,b) flock(a,b)
27034: #endif
27035:
27036:
27037: /*
27038: ** This routine checks if there is a RESERVED lock held on the specified
27039: ** file by this or any other process. If such a lock is held, set *pResOut
27040: ** to a non-zero value otherwise *pResOut is set to zero. The return value
27041: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
27042: */
27043: static int flockCheckReservedLock(sqlite3_file *id, int *pResOut){
27044: int rc = SQLITE_OK;
27045: int reserved = 0;
27046: unixFile *pFile = (unixFile*)id;
27047:
27048: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
27049:
27050: assert( pFile );
27051:
27052: /* Check if a thread in this process holds such a lock */
27053: if( pFile->eFileLock>SHARED_LOCK ){
27054: reserved = 1;
27055: }
27056:
27057: /* Otherwise see if some other process holds it. */
27058: if( !reserved ){
27059: /* attempt to get the lock */
27060: int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
27061: if( !lrc ){
27062: /* got the lock, unlock it */
27063: lrc = robust_flock(pFile->h, LOCK_UN);
27064: if ( lrc ) {
27065: int tErrno = errno;
27066: /* unlock failed with an error */
27067: lrc = SQLITE_IOERR_UNLOCK;
27068: if( IS_LOCK_ERROR(lrc) ){
27069: pFile->lastErrno = tErrno;
27070: rc = lrc;
27071: }
27072: }
27073: } else {
27074: int tErrno = errno;
27075: reserved = 1;
27076: /* someone else might have it reserved */
27077: lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
27078: if( IS_LOCK_ERROR(lrc) ){
27079: pFile->lastErrno = tErrno;
27080: rc = lrc;
27081: }
27082: }
27083: }
27084: OSTRACE(("TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
27085:
27086: #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
27087: if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){
27088: rc = SQLITE_OK;
27089: reserved=1;
27090: }
27091: #endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
27092: *pResOut = reserved;
27093: return rc;
27094: }
27095:
27096: /*
27097: ** Lock the file with the lock specified by parameter eFileLock - one
27098: ** of the following:
27099: **
27100: ** (1) SHARED_LOCK
27101: ** (2) RESERVED_LOCK
27102: ** (3) PENDING_LOCK
27103: ** (4) EXCLUSIVE_LOCK
27104: **
27105: ** Sometimes when requesting one lock state, additional lock states
27106: ** are inserted in between. The locking might fail on one of the later
27107: ** transitions leaving the lock state different from what it started but
27108: ** still short of its goal. The following chart shows the allowed
27109: ** transitions and the inserted intermediate states:
27110: **
27111: ** UNLOCKED -> SHARED
27112: ** SHARED -> RESERVED
27113: ** SHARED -> (PENDING) -> EXCLUSIVE
27114: ** RESERVED -> (PENDING) -> EXCLUSIVE
27115: ** PENDING -> EXCLUSIVE
27116: **
27117: ** flock() only really support EXCLUSIVE locks. We track intermediate
27118: ** lock states in the sqlite3_file structure, but all locks SHARED or
27119: ** above are really EXCLUSIVE locks and exclude all other processes from
27120: ** access the file.
27121: **
27122: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
27123: ** routine to lower a locking level.
27124: */
27125: static int flockLock(sqlite3_file *id, int eFileLock) {
27126: int rc = SQLITE_OK;
27127: unixFile *pFile = (unixFile*)id;
27128:
27129: assert( pFile );
27130:
27131: /* if we already have a lock, it is exclusive.
27132: ** Just adjust level and punt on outta here. */
27133: if (pFile->eFileLock > NO_LOCK) {
27134: pFile->eFileLock = eFileLock;
27135: return SQLITE_OK;
27136: }
27137:
27138: /* grab an exclusive lock */
27139:
27140: if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
27141: int tErrno = errno;
27142: /* didn't get, must be busy */
27143: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
27144: if( IS_LOCK_ERROR(rc) ){
27145: pFile->lastErrno = tErrno;
27146: }
27147: } else {
27148: /* got it, set the type and return ok */
27149: pFile->eFileLock = eFileLock;
27150: }
27151: OSTRACE(("LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
27152: rc==SQLITE_OK ? "ok" : "failed"));
27153: #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
27154: if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){
27155: rc = SQLITE_BUSY;
27156: }
27157: #endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
27158: return rc;
27159: }
27160:
27161:
27162: /*
27163: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
27164: ** must be either NO_LOCK or SHARED_LOCK.
27165: **
27166: ** If the locking level of the file descriptor is already at or below
27167: ** the requested locking level, this routine is a no-op.
27168: */
27169: static int flockUnlock(sqlite3_file *id, int eFileLock) {
27170: unixFile *pFile = (unixFile*)id;
27171:
27172: assert( pFile );
27173: OSTRACE(("UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
27174: pFile->eFileLock, getpid()));
27175: assert( eFileLock<=SHARED_LOCK );
27176:
27177: /* no-op if possible */
27178: if( pFile->eFileLock==eFileLock ){
27179: return SQLITE_OK;
27180: }
27181:
27182: /* shared can just be set because we always have an exclusive */
27183: if (eFileLock==SHARED_LOCK) {
27184: pFile->eFileLock = eFileLock;
27185: return SQLITE_OK;
27186: }
27187:
27188: /* no, really, unlock. */
27189: if( robust_flock(pFile->h, LOCK_UN) ){
27190: #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS
27191: return SQLITE_OK;
27192: #endif /* SQLITE_IGNORE_FLOCK_LOCK_ERRORS */
27193: return SQLITE_IOERR_UNLOCK;
27194: }else{
27195: pFile->eFileLock = NO_LOCK;
27196: return SQLITE_OK;
27197: }
27198: }
27199:
27200: /*
27201: ** Close a file.
27202: */
27203: static int flockClose(sqlite3_file *id) {
27204: if( id ){
27205: flockUnlock(id, NO_LOCK);
27206: }
27207: return closeUnixFile(id);
27208: }
27209:
27210: #endif /* SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORK */
27211:
27212: /******************* End of the flock lock implementation *********************
27213: ******************************************************************************/
27214:
27215: /******************************************************************************
27216: ************************ Begin Named Semaphore Locking ************************
27217: **
27218: ** Named semaphore locking is only supported on VxWorks.
27219: **
27220: ** Semaphore locking is like dot-lock and flock in that it really only
27221: ** supports EXCLUSIVE locking. Only a single process can read or write
27222: ** the database file at a time. This reduces potential concurrency, but
27223: ** makes the lock implementation much easier.
27224: */
27225: #if OS_VXWORKS
27226:
27227: /*
27228: ** This routine checks if there is a RESERVED lock held on the specified
27229: ** file by this or any other process. If such a lock is held, set *pResOut
27230: ** to a non-zero value otherwise *pResOut is set to zero. The return value
27231: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
27232: */
27233: static int semCheckReservedLock(sqlite3_file *id, int *pResOut) {
27234: int rc = SQLITE_OK;
27235: int reserved = 0;
27236: unixFile *pFile = (unixFile*)id;
27237:
27238: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
27239:
27240: assert( pFile );
27241:
27242: /* Check if a thread in this process holds such a lock */
27243: if( pFile->eFileLock>SHARED_LOCK ){
27244: reserved = 1;
27245: }
27246:
27247: /* Otherwise see if some other process holds it. */
27248: if( !reserved ){
27249: sem_t *pSem = pFile->pInode->pSem;
27250: struct stat statBuf;
27251:
27252: if( sem_trywait(pSem)==-1 ){
27253: int tErrno = errno;
27254: if( EAGAIN != tErrno ){
27255: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK);
27256: pFile->lastErrno = tErrno;
27257: } else {
27258: /* someone else has the lock when we are in NO_LOCK */
27259: reserved = (pFile->eFileLock < SHARED_LOCK);
27260: }
27261: }else{
27262: /* we could have it if we want it */
27263: sem_post(pSem);
27264: }
27265: }
27266: OSTRACE(("TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
27267:
27268: *pResOut = reserved;
27269: return rc;
27270: }
27271:
27272: /*
27273: ** Lock the file with the lock specified by parameter eFileLock - one
27274: ** of the following:
27275: **
27276: ** (1) SHARED_LOCK
27277: ** (2) RESERVED_LOCK
27278: ** (3) PENDING_LOCK
27279: ** (4) EXCLUSIVE_LOCK
27280: **
27281: ** Sometimes when requesting one lock state, additional lock states
27282: ** are inserted in between. The locking might fail on one of the later
27283: ** transitions leaving the lock state different from what it started but
27284: ** still short of its goal. The following chart shows the allowed
27285: ** transitions and the inserted intermediate states:
27286: **
27287: ** UNLOCKED -> SHARED
27288: ** SHARED -> RESERVED
27289: ** SHARED -> (PENDING) -> EXCLUSIVE
27290: ** RESERVED -> (PENDING) -> EXCLUSIVE
27291: ** PENDING -> EXCLUSIVE
27292: **
27293: ** Semaphore locks only really support EXCLUSIVE locks. We track intermediate
27294: ** lock states in the sqlite3_file structure, but all locks SHARED or
27295: ** above are really EXCLUSIVE locks and exclude all other processes from
27296: ** access the file.
27297: **
27298: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
27299: ** routine to lower a locking level.
27300: */
27301: static int semLock(sqlite3_file *id, int eFileLock) {
27302: unixFile *pFile = (unixFile*)id;
27303: int fd;
27304: sem_t *pSem = pFile->pInode->pSem;
27305: int rc = SQLITE_OK;
27306:
27307: /* if we already have a lock, it is exclusive.
27308: ** Just adjust level and punt on outta here. */
27309: if (pFile->eFileLock > NO_LOCK) {
27310: pFile->eFileLock = eFileLock;
27311: rc = SQLITE_OK;
27312: goto sem_end_lock;
27313: }
27314:
27315: /* lock semaphore now but bail out when already locked. */
27316: if( sem_trywait(pSem)==-1 ){
27317: rc = SQLITE_BUSY;
27318: goto sem_end_lock;
27319: }
27320:
27321: /* got it, set the type and return ok */
27322: pFile->eFileLock = eFileLock;
27323:
27324: sem_end_lock:
27325: return rc;
27326: }
27327:
27328: /*
27329: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
27330: ** must be either NO_LOCK or SHARED_LOCK.
27331: **
27332: ** If the locking level of the file descriptor is already at or below
27333: ** the requested locking level, this routine is a no-op.
27334: */
27335: static int semUnlock(sqlite3_file *id, int eFileLock) {
27336: unixFile *pFile = (unixFile*)id;
27337: sem_t *pSem = pFile->pInode->pSem;
27338:
27339: assert( pFile );
27340: assert( pSem );
27341: OSTRACE(("UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
27342: pFile->eFileLock, getpid()));
27343: assert( eFileLock<=SHARED_LOCK );
27344:
27345: /* no-op if possible */
27346: if( pFile->eFileLock==eFileLock ){
27347: return SQLITE_OK;
27348: }
27349:
27350: /* shared can just be set because we always have an exclusive */
27351: if (eFileLock==SHARED_LOCK) {
27352: pFile->eFileLock = eFileLock;
27353: return SQLITE_OK;
27354: }
27355:
27356: /* no, really unlock. */
27357: if ( sem_post(pSem)==-1 ) {
27358: int rc, tErrno = errno;
27359: rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
27360: if( IS_LOCK_ERROR(rc) ){
27361: pFile->lastErrno = tErrno;
27362: }
27363: return rc;
27364: }
27365: pFile->eFileLock = NO_LOCK;
27366: return SQLITE_OK;
27367: }
27368:
27369: /*
27370: ** Close a file.
27371: */
27372: static int semClose(sqlite3_file *id) {
27373: if( id ){
27374: unixFile *pFile = (unixFile*)id;
27375: semUnlock(id, NO_LOCK);
27376: assert( pFile );
27377: unixEnterMutex();
27378: releaseInodeInfo(pFile);
27379: unixLeaveMutex();
27380: closeUnixFile(id);
27381: }
27382: return SQLITE_OK;
27383: }
27384:
27385: #endif /* OS_VXWORKS */
27386: /*
27387: ** Named semaphore locking is only available on VxWorks.
27388: **
27389: *************** End of the named semaphore lock implementation ****************
27390: ******************************************************************************/
27391:
27392:
27393: /******************************************************************************
27394: *************************** Begin AFP Locking *********************************
27395: **
27396: ** AFP is the Apple Filing Protocol. AFP is a network filesystem found
27397: ** on Apple Macintosh computers - both OS9 and OSX.
27398: **
27399: ** Third-party implementations of AFP are available. But this code here
27400: ** only works on OSX.
27401: */
27402:
27403: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
27404: /*
27405: ** The afpLockingContext structure contains all afp lock specific state
27406: */
27407: typedef struct afpLockingContext afpLockingContext;
27408: struct afpLockingContext {
27409: int reserved;
27410: const char *dbPath; /* Name of the open file */
27411: };
27412:
27413: struct ByteRangeLockPB2
27414: {
27415: unsigned long long offset; /* offset to first byte to lock */
27416: unsigned long long length; /* nbr of bytes to lock */
27417: unsigned long long retRangeStart; /* nbr of 1st byte locked if successful */
27418: unsigned char unLockFlag; /* 1 = unlock, 0 = lock */
27419: unsigned char startEndFlag; /* 1=rel to end of fork, 0=rel to start */
27420: int fd; /* file desc to assoc this lock with */
27421: };
27422:
27423: #define afpfsByteRangeLock2FSCTL _IOWR('z', 23, struct ByteRangeLockPB2)
27424:
27425: /*
27426: ** This is a utility for setting or clearing a bit-range lock on an
27427: ** AFP filesystem.
27428: **
27429: ** Return SQLITE_OK on success, SQLITE_BUSY on failure.
27430: */
27431: static int afpSetLock(
27432: const char *path, /* Name of the file to be locked or unlocked */
27433: unixFile *pFile, /* Open file descriptor on path */
27434: unsigned long long offset, /* First byte to be locked */
27435: unsigned long long length, /* Number of bytes to lock */
27436: int setLockFlag /* True to set lock. False to clear lock */
27437: ){
27438: struct ByteRangeLockPB2 pb;
27439: int err;
27440:
27441: pb.unLockFlag = setLockFlag ? 0 : 1;
27442: pb.startEndFlag = 0;
27443: pb.offset = offset;
27444: pb.length = length;
27445: pb.fd = pFile->h;
27446:
27447: OSTRACE(("AFPSETLOCK [%s] for %d%s in range %llx:%llx\n",
27448: (setLockFlag?"ON":"OFF"), pFile->h, (pb.fd==-1?"[testval-1]":""),
27449: offset, length));
27450: err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0);
27451: if ( err==-1 ) {
27452: int rc;
27453: int tErrno = errno;
27454: OSTRACE(("AFPSETLOCK failed to fsctl() '%s' %d %s\n",
27455: path, tErrno, strerror(tErrno)));
27456: #ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS
27457: rc = SQLITE_BUSY;
27458: #else
27459: rc = sqliteErrorFromPosixError(tErrno,
27460: setLockFlag ? SQLITE_IOERR_LOCK : SQLITE_IOERR_UNLOCK);
27461: #endif /* SQLITE_IGNORE_AFP_LOCK_ERRORS */
27462: if( IS_LOCK_ERROR(rc) ){
27463: pFile->lastErrno = tErrno;
27464: }
27465: return rc;
27466: } else {
27467: return SQLITE_OK;
27468: }
27469: }
27470:
27471: /*
27472: ** This routine checks if there is a RESERVED lock held on the specified
27473: ** file by this or any other process. If such a lock is held, set *pResOut
27474: ** to a non-zero value otherwise *pResOut is set to zero. The return value
27475: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
27476: */
27477: static int afpCheckReservedLock(sqlite3_file *id, int *pResOut){
27478: int rc = SQLITE_OK;
27479: int reserved = 0;
27480: unixFile *pFile = (unixFile*)id;
27481: afpLockingContext *context;
27482:
27483: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
27484:
27485: assert( pFile );
27486: context = (afpLockingContext *) pFile->lockingContext;
27487: if( context->reserved ){
27488: *pResOut = 1;
27489: return SQLITE_OK;
27490: }
27491: unixEnterMutex(); /* Because pFile->pInode is shared across threads */
27492:
27493: /* Check if a thread in this process holds such a lock */
27494: if( pFile->pInode->eFileLock>SHARED_LOCK ){
27495: reserved = 1;
27496: }
27497:
27498: /* Otherwise see if some other process holds it.
27499: */
27500: if( !reserved ){
27501: /* lock the RESERVED byte */
27502: int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
27503: if( SQLITE_OK==lrc ){
27504: /* if we succeeded in taking the reserved lock, unlock it to restore
27505: ** the original state */
27506: lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
27507: } else {
27508: /* if we failed to get the lock then someone else must have it */
27509: reserved = 1;
27510: }
27511: if( IS_LOCK_ERROR(lrc) ){
27512: rc=lrc;
27513: }
27514: }
27515:
27516: unixLeaveMutex();
27517: OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
27518:
27519: *pResOut = reserved;
27520: return rc;
27521: }
27522:
27523: /*
27524: ** Lock the file with the lock specified by parameter eFileLock - one
27525: ** of the following:
27526: **
27527: ** (1) SHARED_LOCK
27528: ** (2) RESERVED_LOCK
27529: ** (3) PENDING_LOCK
27530: ** (4) EXCLUSIVE_LOCK
27531: **
27532: ** Sometimes when requesting one lock state, additional lock states
27533: ** are inserted in between. The locking might fail on one of the later
27534: ** transitions leaving the lock state different from what it started but
27535: ** still short of its goal. The following chart shows the allowed
27536: ** transitions and the inserted intermediate states:
27537: **
27538: ** UNLOCKED -> SHARED
27539: ** SHARED -> RESERVED
27540: ** SHARED -> (PENDING) -> EXCLUSIVE
27541: ** RESERVED -> (PENDING) -> EXCLUSIVE
27542: ** PENDING -> EXCLUSIVE
27543: **
27544: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
27545: ** routine to lower a locking level.
27546: */
27547: static int afpLock(sqlite3_file *id, int eFileLock){
27548: int rc = SQLITE_OK;
27549: unixFile *pFile = (unixFile*)id;
27550: unixInodeInfo *pInode = pFile->pInode;
27551: afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
27552:
27553: assert( pFile );
27554: OSTRACE(("LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
27555: azFileLock(eFileLock), azFileLock(pFile->eFileLock),
27556: azFileLock(pInode->eFileLock), pInode->nShared , getpid()));
27557:
27558: /* If there is already a lock of this type or more restrictive on the
27559: ** unixFile, do nothing. Don't use the afp_end_lock: exit path, as
27560: ** unixEnterMutex() hasn't been called yet.
27561: */
27562: if( pFile->eFileLock>=eFileLock ){
27563: OSTRACE(("LOCK %d %s ok (already held) (afp)\n", pFile->h,
27564: azFileLock(eFileLock)));
27565: return SQLITE_OK;
27566: }
27567:
27568: /* Make sure the locking sequence is correct
27569: ** (1) We never move from unlocked to anything higher than shared lock.
27570: ** (2) SQLite never explicitly requests a pendig lock.
27571: ** (3) A shared lock is always held when a reserve lock is requested.
27572: */
27573: assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
27574: assert( eFileLock!=PENDING_LOCK );
27575: assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
27576:
27577: /* This mutex is needed because pFile->pInode is shared across threads
27578: */
27579: unixEnterMutex();
27580: pInode = pFile->pInode;
27581:
27582: /* If some thread using this PID has a lock via a different unixFile*
27583: ** handle that precludes the requested lock, return BUSY.
27584: */
27585: if( (pFile->eFileLock!=pInode->eFileLock &&
27586: (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
27587: ){
27588: rc = SQLITE_BUSY;
27589: goto afp_end_lock;
27590: }
27591:
27592: /* If a SHARED lock is requested, and some thread using this PID already
27593: ** has a SHARED or RESERVED lock, then increment reference counts and
27594: ** return SQLITE_OK.
27595: */
27596: if( eFileLock==SHARED_LOCK &&
27597: (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
27598: assert( eFileLock==SHARED_LOCK );
27599: assert( pFile->eFileLock==0 );
27600: assert( pInode->nShared>0 );
27601: pFile->eFileLock = SHARED_LOCK;
27602: pInode->nShared++;
27603: pInode->nLock++;
27604: goto afp_end_lock;
27605: }
27606:
27607: /* A PENDING lock is needed before acquiring a SHARED lock and before
27608: ** acquiring an EXCLUSIVE lock. For the SHARED lock, the PENDING will
27609: ** be released.
27610: */
27611: if( eFileLock==SHARED_LOCK
27612: || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
27613: ){
27614: int failed;
27615: failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
27616: if (failed) {
27617: rc = failed;
27618: goto afp_end_lock;
27619: }
27620: }
27621:
27622: /* If control gets to this point, then actually go ahead and make
27623: ** operating system calls for the specified lock.
27624: */
27625: if( eFileLock==SHARED_LOCK ){
27626: int lrc1, lrc2, lrc1Errno = 0;
27627: long lk, mask;
27628:
27629: assert( pInode->nShared==0 );
27630: assert( pInode->eFileLock==0 );
27631:
27632: mask = (sizeof(long)==8) ? LARGEST_INT64 : 0x7fffffff;
27633: /* Now get the read-lock SHARED_LOCK */
27634: /* note that the quality of the randomness doesn't matter that much */
27635: lk = random();
27636: pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1);
27637: lrc1 = afpSetLock(context->dbPath, pFile,
27638: SHARED_FIRST+pInode->sharedByte, 1, 1);
27639: if( IS_LOCK_ERROR(lrc1) ){
27640: lrc1Errno = pFile->lastErrno;
27641: }
27642: /* Drop the temporary PENDING lock */
27643: lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
27644:
27645: if( IS_LOCK_ERROR(lrc1) ) {
27646: pFile->lastErrno = lrc1Errno;
27647: rc = lrc1;
27648: goto afp_end_lock;
27649: } else if( IS_LOCK_ERROR(lrc2) ){
27650: rc = lrc2;
27651: goto afp_end_lock;
27652: } else if( lrc1 != SQLITE_OK ) {
27653: rc = lrc1;
27654: } else {
27655: pFile->eFileLock = SHARED_LOCK;
27656: pInode->nLock++;
27657: pInode->nShared = 1;
27658: }
27659: }else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
27660: /* We are trying for an exclusive lock but another thread in this
27661: ** same process is still holding a shared lock. */
27662: rc = SQLITE_BUSY;
27663: }else{
27664: /* The request was for a RESERVED or EXCLUSIVE lock. It is
27665: ** assumed that there is a SHARED or greater lock on the file
27666: ** already.
27667: */
27668: int failed = 0;
27669: assert( 0!=pFile->eFileLock );
27670: if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
27671: /* Acquire a RESERVED lock */
27672: failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
27673: if( !failed ){
27674: context->reserved = 1;
27675: }
27676: }
27677: if (!failed && eFileLock == EXCLUSIVE_LOCK) {
27678: /* Acquire an EXCLUSIVE lock */
27679:
27680: /* Remove the shared lock before trying the range. we'll need to
27681: ** reestablish the shared lock if we can't get the afpUnlock
27682: */
27683: if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
27684: pInode->sharedByte, 1, 0)) ){
27685: int failed2 = SQLITE_OK;
27686: /* now attemmpt to get the exclusive lock range */
27687: failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST,
27688: SHARED_SIZE, 1);
27689: if( failed && (failed2 = afpSetLock(context->dbPath, pFile,
27690: SHARED_FIRST + pInode->sharedByte, 1, 1)) ){
27691: /* Can't reestablish the shared lock. Sqlite can't deal, this is
27692: ** a critical I/O error
27693: */
27694: rc = ((failed & SQLITE_IOERR) == SQLITE_IOERR) ? failed2 :
27695: SQLITE_IOERR_LOCK;
27696: goto afp_end_lock;
27697: }
27698: }else{
27699: rc = failed;
27700: }
27701: }
27702: if( failed ){
27703: rc = failed;
27704: }
27705: }
27706:
27707: if( rc==SQLITE_OK ){
27708: pFile->eFileLock = eFileLock;
27709: pInode->eFileLock = eFileLock;
27710: }else if( eFileLock==EXCLUSIVE_LOCK ){
27711: pFile->eFileLock = PENDING_LOCK;
27712: pInode->eFileLock = PENDING_LOCK;
27713: }
27714:
27715: afp_end_lock:
27716: unixLeaveMutex();
27717: OSTRACE(("LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
27718: rc==SQLITE_OK ? "ok" : "failed"));
27719: return rc;
27720: }
27721:
27722: /*
27723: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
27724: ** must be either NO_LOCK or SHARED_LOCK.
27725: **
27726: ** If the locking level of the file descriptor is already at or below
27727: ** the requested locking level, this routine is a no-op.
27728: */
27729: static int afpUnlock(sqlite3_file *id, int eFileLock) {
27730: int rc = SQLITE_OK;
27731: unixFile *pFile = (unixFile*)id;
27732: unixInodeInfo *pInode;
27733: afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
27734: int skipShared = 0;
27735: #ifdef SQLITE_TEST
27736: int h = pFile->h;
27737: #endif
27738:
27739: assert( pFile );
27740: OSTRACE(("UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
27741: pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
27742: getpid()));
27743:
27744: assert( eFileLock<=SHARED_LOCK );
27745: if( pFile->eFileLock<=eFileLock ){
27746: return SQLITE_OK;
27747: }
27748: unixEnterMutex();
27749: pInode = pFile->pInode;
27750: assert( pInode->nShared!=0 );
27751: if( pFile->eFileLock>SHARED_LOCK ){
27752: assert( pInode->eFileLock==pFile->eFileLock );
27753: SimulateIOErrorBenign(1);
27754: SimulateIOError( h=(-1) )
27755: SimulateIOErrorBenign(0);
27756:
27757: #ifndef NDEBUG
27758: /* When reducing a lock such that other processes can start
27759: ** reading the database file again, make sure that the
27760: ** transaction counter was updated if any part of the database
27761: ** file changed. If the transaction counter is not updated,
27762: ** other connections to the same file might not realize that
27763: ** the file has changed and hence might not know to flush their
27764: ** cache. The use of a stale cache can lead to database corruption.
27765: */
27766: assert( pFile->inNormalWrite==0
27767: || pFile->dbUpdate==0
27768: || pFile->transCntrChng==1 );
27769: pFile->inNormalWrite = 0;
27770: #endif
27771:
27772: if( pFile->eFileLock==EXCLUSIVE_LOCK ){
27773: rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
27774: if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
27775: /* only re-establish the shared lock if necessary */
27776: int sharedLockByte = SHARED_FIRST+pInode->sharedByte;
27777: rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
27778: } else {
27779: skipShared = 1;
27780: }
27781: }
27782: if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
27783: rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
27784: }
27785: if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
27786: rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
27787: if( !rc ){
27788: context->reserved = 0;
27789: }
27790: }
27791: if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
27792: pInode->eFileLock = SHARED_LOCK;
27793: }
27794: }
27795: if( rc==SQLITE_OK && eFileLock==NO_LOCK ){
27796:
27797: /* Decrement the shared lock counter. Release the lock using an
27798: ** OS call only when all threads in this same process have released
27799: ** the lock.
27800: */
27801: unsigned long long sharedLockByte = SHARED_FIRST+pInode->sharedByte;
27802: pInode->nShared--;
27803: if( pInode->nShared==0 ){
27804: SimulateIOErrorBenign(1);
27805: SimulateIOError( h=(-1) )
27806: SimulateIOErrorBenign(0);
27807: if( !skipShared ){
27808: rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0);
27809: }
27810: if( !rc ){
27811: pInode->eFileLock = NO_LOCK;
27812: pFile->eFileLock = NO_LOCK;
27813: }
27814: }
27815: if( rc==SQLITE_OK ){
27816: pInode->nLock--;
27817: assert( pInode->nLock>=0 );
27818: if( pInode->nLock==0 ){
27819: closePendingFds(pFile);
27820: }
27821: }
27822: }
27823:
27824: unixLeaveMutex();
27825: if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
27826: return rc;
27827: }
27828:
27829: /*
27830: ** Close a file & cleanup AFP specific locking context
27831: */
27832: static int afpClose(sqlite3_file *id) {
27833: int rc = SQLITE_OK;
27834: if( id ){
27835: unixFile *pFile = (unixFile*)id;
27836: afpUnlock(id, NO_LOCK);
27837: unixEnterMutex();
27838: if( pFile->pInode && pFile->pInode->nLock ){
27839: /* If there are outstanding locks, do not actually close the file just
27840: ** yet because that would clear those locks. Instead, add the file
27841: ** descriptor to pInode->aPending. It will be automatically closed when
27842: ** the last lock is cleared.
27843: */
27844: setPendingFd(pFile);
27845: }
27846: releaseInodeInfo(pFile);
27847: sqlite3_free(pFile->lockingContext);
27848: rc = closeUnixFile(id);
27849: unixLeaveMutex();
27850: }
27851: return rc;
27852: }
27853:
27854: #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
27855: /*
27856: ** The code above is the AFP lock implementation. The code is specific
27857: ** to MacOSX and does not work on other unix platforms. No alternative
27858: ** is available. If you don't compile for a mac, then the "unix-afp"
27859: ** VFS is not available.
27860: **
27861: ********************* End of the AFP lock implementation **********************
27862: ******************************************************************************/
27863:
27864: /******************************************************************************
27865: *************************** Begin NFS Locking ********************************/
27866:
27867: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
27868: /*
27869: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
27870: ** must be either NO_LOCK or SHARED_LOCK.
27871: **
27872: ** If the locking level of the file descriptor is already at or below
27873: ** the requested locking level, this routine is a no-op.
27874: */
27875: static int nfsUnlock(sqlite3_file *id, int eFileLock){
27876: return posixUnlock(id, eFileLock, 1);
27877: }
27878:
27879: #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
27880: /*
27881: ** The code above is the NFS lock implementation. The code is specific
27882: ** to MacOSX and does not work on other unix platforms. No alternative
27883: ** is available.
27884: **
27885: ********************* End of the NFS lock implementation **********************
27886: ******************************************************************************/
27887:
27888: /******************************************************************************
27889: **************** Non-locking sqlite3_file methods *****************************
27890: **
27891: ** The next division contains implementations for all methods of the
27892: ** sqlite3_file object other than the locking methods. The locking
27893: ** methods were defined in divisions above (one locking method per
27894: ** division). Those methods that are common to all locking modes
27895: ** are gather together into this division.
27896: */
27897:
27898: /*
27899: ** Seek to the offset passed as the second argument, then read cnt
27900: ** bytes into pBuf. Return the number of bytes actually read.
27901: **
27902: ** NB: If you define USE_PREAD or USE_PREAD64, then it might also
27903: ** be necessary to define _XOPEN_SOURCE to be 500. This varies from
27904: ** one system to another. Since SQLite does not define USE_PREAD
27905: ** any any form by default, we will not attempt to define _XOPEN_SOURCE.
27906: ** See tickets #2741 and #2681.
27907: **
27908: ** To avoid stomping the errno value on a failed read the lastErrno value
27909: ** is set before returning.
27910: */
27911: static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
27912: int got;
27913: int prior = 0;
27914: #if (!defined(USE_PREAD) && !defined(USE_PREAD64))
27915: i64 newOffset;
27916: #endif
27917: TIMER_START;
27918: do{
27919: #if defined(USE_PREAD)
27920: got = osPread(id->h, pBuf, cnt, offset);
27921: SimulateIOError( got = -1 );
27922: #elif defined(USE_PREAD64)
27923: got = osPread64(id->h, pBuf, cnt, offset);
27924: SimulateIOError( got = -1 );
27925: #else
27926: newOffset = lseek(id->h, offset, SEEK_SET);
27927: SimulateIOError( newOffset-- );
27928: if( newOffset!=offset ){
27929: if( newOffset == -1 ){
27930: ((unixFile*)id)->lastErrno = errno;
27931: }else{
27932: ((unixFile*)id)->lastErrno = 0;
27933: }
27934: return -1;
27935: }
27936: got = osRead(id->h, pBuf, cnt);
27937: #endif
27938: if( got==cnt ) break;
27939: if( got<0 ){
27940: if( errno==EINTR ){ got = 1; continue; }
27941: prior = 0;
27942: ((unixFile*)id)->lastErrno = errno;
27943: break;
27944: }else if( got>0 ){
27945: cnt -= got;
27946: offset += got;
27947: prior += got;
27948: pBuf = (void*)(got + (char*)pBuf);
27949: }
27950: }while( got>0 );
27951: TIMER_END;
27952: OSTRACE(("READ %-3d %5d %7lld %llu\n",
27953: id->h, got+prior, offset-prior, TIMER_ELAPSED));
27954: return got+prior;
27955: }
27956:
27957: /*
27958: ** Read data from a file into a buffer. Return SQLITE_OK if all
27959: ** bytes were read successfully and SQLITE_IOERR if anything goes
27960: ** wrong.
27961: */
27962: static int unixRead(
27963: sqlite3_file *id,
27964: void *pBuf,
27965: int amt,
27966: sqlite3_int64 offset
27967: ){
27968: unixFile *pFile = (unixFile *)id;
27969: int got;
27970: assert( id );
27971:
27972: /* If this is a database file (not a journal, master-journal or temp
27973: ** file), the bytes in the locking range should never be read or written. */
27974: #if 0
27975: assert( pFile->pUnused==0
27976: || offset>=PENDING_BYTE+512
27977: || offset+amt<=PENDING_BYTE
27978: );
27979: #endif
27980:
27981: got = seekAndRead(pFile, offset, pBuf, amt);
27982: if( got==amt ){
27983: return SQLITE_OK;
27984: }else if( got<0 ){
27985: /* lastErrno set by seekAndRead */
27986: return SQLITE_IOERR_READ;
27987: }else{
27988: pFile->lastErrno = 0; /* not a system error */
27989: /* Unread parts of the buffer must be zero-filled */
27990: memset(&((char*)pBuf)[got], 0, amt-got);
27991: return SQLITE_IOERR_SHORT_READ;
27992: }
27993: }
27994:
27995: /*
27996: ** Seek to the offset in id->offset then read cnt bytes into pBuf.
27997: ** Return the number of bytes actually read. Update the offset.
27998: **
27999: ** To avoid stomping the errno value on a failed write the lastErrno value
28000: ** is set before returning.
28001: */
28002: static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
28003: int got;
28004: #if (!defined(USE_PREAD) && !defined(USE_PREAD64))
28005: i64 newOffset;
28006: #endif
28007: TIMER_START;
28008: #if defined(USE_PREAD)
28009: do{ got = osPwrite(id->h, pBuf, cnt, offset); }while( got<0 && errno==EINTR );
28010: #elif defined(USE_PREAD64)
28011: do{ got = osPwrite64(id->h, pBuf, cnt, offset);}while( got<0 && errno==EINTR);
28012: #else
28013: do{
28014: newOffset = lseek(id->h, offset, SEEK_SET);
28015: SimulateIOError( newOffset-- );
28016: if( newOffset!=offset ){
28017: if( newOffset == -1 ){
28018: ((unixFile*)id)->lastErrno = errno;
28019: }else{
28020: ((unixFile*)id)->lastErrno = 0;
28021: }
28022: return -1;
28023: }
28024: got = osWrite(id->h, pBuf, cnt);
28025: }while( got<0 && errno==EINTR );
28026: #endif
28027: TIMER_END;
28028: if( got<0 ){
28029: ((unixFile*)id)->lastErrno = errno;
28030: }
28031:
28032: OSTRACE(("WRITE %-3d %5d %7lld %llu\n", id->h, got, offset, TIMER_ELAPSED));
28033: return got;
28034: }
28035:
28036:
28037: /*
28038: ** Write data from a buffer into a file. Return SQLITE_OK on success
28039: ** or some other error code on failure.
28040: */
28041: static int unixWrite(
28042: sqlite3_file *id,
28043: const void *pBuf,
28044: int amt,
28045: sqlite3_int64 offset
28046: ){
28047: unixFile *pFile = (unixFile*)id;
28048: int wrote = 0;
28049: assert( id );
28050: assert( amt>0 );
28051:
28052: /* If this is a database file (not a journal, master-journal or temp
28053: ** file), the bytes in the locking range should never be read or written. */
28054: #if 0
28055: assert( pFile->pUnused==0
28056: || offset>=PENDING_BYTE+512
28057: || offset+amt<=PENDING_BYTE
28058: );
28059: #endif
28060:
28061: #ifndef NDEBUG
28062: /* If we are doing a normal write to a database file (as opposed to
28063: ** doing a hot-journal rollback or a write to some file other than a
28064: ** normal database file) then record the fact that the database
28065: ** has changed. If the transaction counter is modified, record that
28066: ** fact too.
28067: */
28068: if( pFile->inNormalWrite ){
28069: pFile->dbUpdate = 1; /* The database has been modified */
28070: if( offset<=24 && offset+amt>=27 ){
28071: int rc;
28072: char oldCntr[4];
28073: SimulateIOErrorBenign(1);
28074: rc = seekAndRead(pFile, 24, oldCntr, 4);
28075: SimulateIOErrorBenign(0);
28076: if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
28077: pFile->transCntrChng = 1; /* The transaction counter has changed */
28078: }
28079: }
28080: }
28081: #endif
28082:
28083: while( amt>0 && (wrote = seekAndWrite(pFile, offset, pBuf, amt))>0 ){
28084: amt -= wrote;
28085: offset += wrote;
28086: pBuf = &((char*)pBuf)[wrote];
28087: }
28088: SimulateIOError(( wrote=(-1), amt=1 ));
28089: SimulateDiskfullError(( wrote=0, amt=1 ));
28090:
28091: if( amt>0 ){
28092: if( wrote<0 && pFile->lastErrno!=ENOSPC ){
28093: /* lastErrno set by seekAndWrite */
28094: return SQLITE_IOERR_WRITE;
28095: }else{
28096: pFile->lastErrno = 0; /* not a system error */
28097: return SQLITE_FULL;
28098: }
28099: }
28100:
28101: return SQLITE_OK;
28102: }
28103:
28104: #ifdef SQLITE_TEST
28105: /*
28106: ** Count the number of fullsyncs and normal syncs. This is used to test
28107: ** that syncs and fullsyncs are occurring at the right times.
28108: */
28109: SQLITE_API int sqlite3_sync_count = 0;
28110: SQLITE_API int sqlite3_fullsync_count = 0;
28111: #endif
28112:
28113: /*
28114: ** We do not trust systems to provide a working fdatasync(). Some do.
28115: ** Others do no. To be safe, we will stick with the (slightly slower)
28116: ** fsync(). If you know that your system does support fdatasync() correctly,
28117: ** then simply compile with -Dfdatasync=fdatasync
28118: */
28119: #if !defined(fdatasync)
28120: # define fdatasync fsync
28121: #endif
28122:
28123: /*
28124: ** Define HAVE_FULLFSYNC to 0 or 1 depending on whether or not
28125: ** the F_FULLFSYNC macro is defined. F_FULLFSYNC is currently
28126: ** only available on Mac OS X. But that could change.
28127: */
28128: #ifdef F_FULLFSYNC
28129: # define HAVE_FULLFSYNC 1
28130: #else
28131: # define HAVE_FULLFSYNC 0
28132: #endif
28133:
28134:
28135: /*
28136: ** The fsync() system call does not work as advertised on many
28137: ** unix systems. The following procedure is an attempt to make
28138: ** it work better.
28139: **
28140: ** The SQLITE_NO_SYNC macro disables all fsync()s. This is useful
28141: ** for testing when we want to run through the test suite quickly.
28142: ** You are strongly advised *not* to deploy with SQLITE_NO_SYNC
28143: ** enabled, however, since with SQLITE_NO_SYNC enabled, an OS crash
28144: ** or power failure will likely corrupt the database file.
28145: **
28146: ** SQLite sets the dataOnly flag if the size of the file is unchanged.
28147: ** The idea behind dataOnly is that it should only write the file content
28148: ** to disk, not the inode. We only set dataOnly if the file size is
28149: ** unchanged since the file size is part of the inode. However,
28150: ** Ted Ts'o tells us that fdatasync() will also write the inode if the
28151: ** file size has changed. The only real difference between fdatasync()
28152: ** and fsync(), Ted tells us, is that fdatasync() will not flush the
28153: ** inode if the mtime or owner or other inode attributes have changed.
28154: ** We only care about the file size, not the other file attributes, so
28155: ** as far as SQLite is concerned, an fdatasync() is always adequate.
28156: ** So, we always use fdatasync() if it is available, regardless of
28157: ** the value of the dataOnly flag.
28158: */
28159: static int full_fsync(int fd, int fullSync, int dataOnly){
28160: int rc;
28161:
28162: /* The following "ifdef/elif/else/" block has the same structure as
28163: ** the one below. It is replicated here solely to avoid cluttering
28164: ** up the real code with the UNUSED_PARAMETER() macros.
28165: */
28166: #ifdef SQLITE_NO_SYNC
28167: UNUSED_PARAMETER(fd);
28168: UNUSED_PARAMETER(fullSync);
28169: UNUSED_PARAMETER(dataOnly);
28170: #elif HAVE_FULLFSYNC
28171: UNUSED_PARAMETER(dataOnly);
28172: #else
28173: UNUSED_PARAMETER(fullSync);
28174: UNUSED_PARAMETER(dataOnly);
28175: #endif
28176:
28177: /* Record the number of times that we do a normal fsync() and
28178: ** FULLSYNC. This is used during testing to verify that this procedure
28179: ** gets called with the correct arguments.
28180: */
28181: #ifdef SQLITE_TEST
28182: if( fullSync ) sqlite3_fullsync_count++;
28183: sqlite3_sync_count++;
28184: #endif
28185:
28186: /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
28187: ** no-op
28188: */
28189: #ifdef SQLITE_NO_SYNC
28190: rc = SQLITE_OK;
28191: #elif HAVE_FULLFSYNC
28192: if( fullSync ){
28193: rc = osFcntl(fd, F_FULLFSYNC, 0);
28194: }else{
28195: rc = 1;
28196: }
28197: /* If the FULLFSYNC failed, fall back to attempting an fsync().
28198: ** It shouldn't be possible for fullfsync to fail on the local
28199: ** file system (on OSX), so failure indicates that FULLFSYNC
28200: ** isn't supported for this file system. So, attempt an fsync
28201: ** and (for now) ignore the overhead of a superfluous fcntl call.
28202: ** It'd be better to detect fullfsync support once and avoid
28203: ** the fcntl call every time sync is called.
28204: */
28205: if( rc ) rc = fsync(fd);
28206:
28207: #elif defined(__APPLE__)
28208: /* fdatasync() on HFS+ doesn't yet flush the file size if it changed correctly
28209: ** so currently we default to the macro that redefines fdatasync to fsync
28210: */
28211: rc = fsync(fd);
28212: #else
28213: rc = fdatasync(fd);
28214: #if OS_VXWORKS
28215: if( rc==-1 && errno==ENOTSUP ){
28216: rc = fsync(fd);
28217: }
28218: #endif /* OS_VXWORKS */
28219: #endif /* ifdef SQLITE_NO_SYNC elif HAVE_FULLFSYNC */
28220:
28221: if( OS_VXWORKS && rc!= -1 ){
28222: rc = 0;
28223: }
28224: return rc;
28225: }
28226:
28227: /*
28228: ** Open a file descriptor to the directory containing file zFilename.
28229: ** If successful, *pFd is set to the opened file descriptor and
28230: ** SQLITE_OK is returned. If an error occurs, either SQLITE_NOMEM
28231: ** or SQLITE_CANTOPEN is returned and *pFd is set to an undefined
28232: ** value.
28233: **
28234: ** The directory file descriptor is used for only one thing - to
28235: ** fsync() a directory to make sure file creation and deletion events
28236: ** are flushed to disk. Such fsyncs are not needed on newer
28237: ** journaling filesystems, but are required on older filesystems.
28238: **
28239: ** This routine can be overridden using the xSetSysCall interface.
28240: ** The ability to override this routine was added in support of the
28241: ** chromium sandbox. Opening a directory is a security risk (we are
28242: ** told) so making it overrideable allows the chromium sandbox to
28243: ** replace this routine with a harmless no-op. To make this routine
28244: ** a no-op, replace it with a stub that returns SQLITE_OK but leaves
28245: ** *pFd set to a negative number.
28246: **
28247: ** If SQLITE_OK is returned, the caller is responsible for closing
28248: ** the file descriptor *pFd using close().
28249: */
28250: static int openDirectory(const char *zFilename, int *pFd){
28251: int ii;
28252: int fd = -1;
28253: char zDirname[MAX_PATHNAME+1];
28254:
28255: sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
28256: for(ii=(int)strlen(zDirname); ii>1 && zDirname[ii]!='/'; ii--);
28257: if( ii>0 ){
28258: zDirname[ii] = '\0';
28259: fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
28260: if( fd>=0 ){
28261: #ifdef FD_CLOEXEC
28262: osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
28263: #endif
28264: OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
28265: }
28266: }
28267: *pFd = fd;
28268: return (fd>=0?SQLITE_OK:unixLogError(SQLITE_CANTOPEN_BKPT, "open", zDirname));
28269: }
28270:
28271: /*
28272: ** Make sure all writes to a particular file are committed to disk.
28273: **
28274: ** If dataOnly==0 then both the file itself and its metadata (file
28275: ** size, access time, etc) are synced. If dataOnly!=0 then only the
28276: ** file data is synced.
28277: **
28278: ** Under Unix, also make sure that the directory entry for the file
28279: ** has been created by fsync-ing the directory that contains the file.
28280: ** If we do not do this and we encounter a power failure, the directory
28281: ** entry for the journal might not exist after we reboot. The next
28282: ** SQLite to access the file will not know that the journal exists (because
28283: ** the directory entry for the journal was never created) and the transaction
28284: ** will not roll back - possibly leading to database corruption.
28285: */
28286: static int unixSync(sqlite3_file *id, int flags){
28287: int rc;
28288: unixFile *pFile = (unixFile*)id;
28289:
28290: int isDataOnly = (flags&SQLITE_SYNC_DATAONLY);
28291: int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL;
28292:
28293: /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
28294: assert((flags&0x0F)==SQLITE_SYNC_NORMAL
28295: || (flags&0x0F)==SQLITE_SYNC_FULL
28296: );
28297:
28298: /* Unix cannot, but some systems may return SQLITE_FULL from here. This
28299: ** line is to test that doing so does not cause any problems.
28300: */
28301: SimulateDiskfullError( return SQLITE_FULL );
28302:
28303: assert( pFile );
28304: OSTRACE(("SYNC %-3d\n", pFile->h));
28305: rc = full_fsync(pFile->h, isFullsync, isDataOnly);
28306: SimulateIOError( rc=1 );
28307: if( rc ){
28308: pFile->lastErrno = errno;
28309: return unixLogError(SQLITE_IOERR_FSYNC, "full_fsync", pFile->zPath);
28310: }
28311:
28312: /* Also fsync the directory containing the file if the DIRSYNC flag
28313: ** is set. This is a one-time occurrance. Many systems (examples: AIX)
28314: ** are unable to fsync a directory, so ignore errors on the fsync.
28315: */
28316: if( pFile->ctrlFlags & UNIXFILE_DIRSYNC ){
28317: int dirfd;
28318: OSTRACE(("DIRSYNC %s (have_fullfsync=%d fullsync=%d)\n", pFile->zPath,
28319: HAVE_FULLFSYNC, isFullsync));
28320: rc = osOpenDirectory(pFile->zPath, &dirfd);
28321: if( rc==SQLITE_OK && dirfd>=0 ){
28322: full_fsync(dirfd, 0, 0);
28323: robust_close(pFile, dirfd, __LINE__);
28324: }else if( rc==SQLITE_CANTOPEN ){
28325: rc = SQLITE_OK;
28326: }
28327: pFile->ctrlFlags &= ~UNIXFILE_DIRSYNC;
28328: }
28329: return rc;
28330: }
28331:
28332: /*
28333: ** Truncate an open file to a specified size
28334: */
28335: static int unixTruncate(sqlite3_file *id, i64 nByte){
28336: unixFile *pFile = (unixFile *)id;
28337: int rc;
28338: assert( pFile );
28339: SimulateIOError( return SQLITE_IOERR_TRUNCATE );
28340:
28341: /* If the user has configured a chunk-size for this file, truncate the
28342: ** file so that it consists of an integer number of chunks (i.e. the
28343: ** actual file size after the operation may be larger than the requested
28344: ** size).
28345: */
28346: if( pFile->szChunk ){
28347: nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
28348: }
28349:
28350: rc = robust_ftruncate(pFile->h, (off_t)nByte);
28351: if( rc ){
28352: pFile->lastErrno = errno;
28353: return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
28354: }else{
28355: #ifndef NDEBUG
28356: /* If we are doing a normal write to a database file (as opposed to
28357: ** doing a hot-journal rollback or a write to some file other than a
28358: ** normal database file) and we truncate the file to zero length,
28359: ** that effectively updates the change counter. This might happen
28360: ** when restoring a database using the backup API from a zero-length
28361: ** source.
28362: */
28363: if( pFile->inNormalWrite && nByte==0 ){
28364: pFile->transCntrChng = 1;
28365: }
28366: #endif
28367:
28368: return SQLITE_OK;
28369: }
28370: }
28371:
28372: /*
28373: ** Determine the current size of a file in bytes
28374: */
28375: static int unixFileSize(sqlite3_file *id, i64 *pSize){
28376: int rc;
28377: struct stat buf;
28378: assert( id );
28379: rc = osFstat(((unixFile*)id)->h, &buf);
28380: SimulateIOError( rc=1 );
28381: if( rc!=0 ){
28382: ((unixFile*)id)->lastErrno = errno;
28383: return SQLITE_IOERR_FSTAT;
28384: }
28385: *pSize = buf.st_size;
28386:
28387: /* When opening a zero-size database, the findInodeInfo() procedure
28388: ** writes a single byte into that file in order to work around a bug
28389: ** in the OS-X msdos filesystem. In order to avoid problems with upper
28390: ** layers, we need to report this file size as zero even though it is
28391: ** really 1. Ticket #3260.
28392: */
28393: if( *pSize==1 ) *pSize = 0;
28394:
28395:
28396: return SQLITE_OK;
28397: }
28398:
28399: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
28400: /*
28401: ** Handler for proxy-locking file-control verbs. Defined below in the
28402: ** proxying locking division.
28403: */
28404: static int proxyFileControl(sqlite3_file*,int,void*);
28405: #endif
28406:
28407: /*
28408: ** This function is called to handle the SQLITE_FCNTL_SIZE_HINT
28409: ** file-control operation. Enlarge the database to nBytes in size
28410: ** (rounded up to the next chunk-size). If the database is already
28411: ** nBytes or larger, this routine is a no-op.
28412: */
28413: static int fcntlSizeHint(unixFile *pFile, i64 nByte){
28414: if( pFile->szChunk>0 ){
28415: i64 nSize; /* Required file size */
28416: struct stat buf; /* Used to hold return values of fstat() */
28417:
28418: if( osFstat(pFile->h, &buf) ) return SQLITE_IOERR_FSTAT;
28419:
28420: nSize = ((nByte+pFile->szChunk-1) / pFile->szChunk) * pFile->szChunk;
28421: if( nSize>(i64)buf.st_size ){
28422:
28423: #if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
28424: /* The code below is handling the return value of osFallocate()
28425: ** correctly. posix_fallocate() is defined to "returns zero on success,
28426: ** or an error number on failure". See the manpage for details. */
28427: int err;
28428: do{
28429: err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
28430: }while( err==EINTR );
28431: if( err ) return SQLITE_IOERR_WRITE;
28432: #else
28433: /* If the OS does not have posix_fallocate(), fake it. First use
28434: ** ftruncate() to set the file size, then write a single byte to
28435: ** the last byte in each block within the extended region. This
28436: ** is the same technique used by glibc to implement posix_fallocate()
28437: ** on systems that do not have a real fallocate() system call.
28438: */
28439: int nBlk = buf.st_blksize; /* File-system block size */
28440: i64 iWrite; /* Next offset to write to */
28441:
28442: if( robust_ftruncate(pFile->h, nSize) ){
28443: pFile->lastErrno = errno;
28444: return unixLogError(SQLITE_IOERR_TRUNCATE, "ftruncate", pFile->zPath);
28445: }
28446: iWrite = ((buf.st_size + 2*nBlk - 1)/nBlk)*nBlk-1;
28447: while( iWrite<nSize ){
28448: int nWrite = seekAndWrite(pFile, iWrite, "", 1);
28449: if( nWrite!=1 ) return SQLITE_IOERR_WRITE;
28450: iWrite += nBlk;
28451: }
28452: #endif
28453: }
28454: }
28455:
28456: return SQLITE_OK;
28457: }
28458:
28459: /*
28460: ** If *pArg is inititially negative then this is a query. Set *pArg to
28461: ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
28462: **
28463: ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
28464: */
28465: static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
28466: if( *pArg<0 ){
28467: *pArg = (pFile->ctrlFlags & mask)!=0;
28468: }else if( (*pArg)==0 ){
28469: pFile->ctrlFlags &= ~mask;
28470: }else{
28471: pFile->ctrlFlags |= mask;
28472: }
28473: }
28474:
28475: /*
28476: ** Information and control of an open file handle.
28477: */
28478: static int unixFileControl(sqlite3_file *id, int op, void *pArg){
28479: unixFile *pFile = (unixFile*)id;
28480: switch( op ){
28481: case SQLITE_FCNTL_LOCKSTATE: {
28482: *(int*)pArg = pFile->eFileLock;
28483: return SQLITE_OK;
28484: }
28485: case SQLITE_LAST_ERRNO: {
28486: *(int*)pArg = pFile->lastErrno;
28487: return SQLITE_OK;
28488: }
28489: case SQLITE_FCNTL_CHUNK_SIZE: {
28490: pFile->szChunk = *(int *)pArg;
28491: return SQLITE_OK;
28492: }
28493: case SQLITE_FCNTL_SIZE_HINT: {
28494: int rc;
28495: SimulateIOErrorBenign(1);
28496: rc = fcntlSizeHint(pFile, *(i64 *)pArg);
28497: SimulateIOErrorBenign(0);
28498: return rc;
28499: }
28500: case SQLITE_FCNTL_PERSIST_WAL: {
28501: unixModeBit(pFile, UNIXFILE_PERSIST_WAL, (int*)pArg);
28502: return SQLITE_OK;
28503: }
28504: case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
28505: unixModeBit(pFile, UNIXFILE_PSOW, (int*)pArg);
28506: return SQLITE_OK;
28507: }
28508: case SQLITE_FCNTL_VFSNAME: {
28509: *(char**)pArg = sqlite3_mprintf("%s", pFile->pVfs->zName);
28510: return SQLITE_OK;
28511: }
28512: #ifndef NDEBUG
28513: /* The pager calls this method to signal that it has done
28514: ** a rollback and that the database is therefore unchanged and
28515: ** it hence it is OK for the transaction change counter to be
28516: ** unchanged.
28517: */
28518: case SQLITE_FCNTL_DB_UNCHANGED: {
28519: ((unixFile*)id)->dbUpdate = 0;
28520: return SQLITE_OK;
28521: }
28522: #endif
28523: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
28524: case SQLITE_SET_LOCKPROXYFILE:
28525: case SQLITE_GET_LOCKPROXYFILE: {
28526: return proxyFileControl(id,op,pArg);
28527: }
28528: #endif /* SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) */
28529: }
28530: return SQLITE_NOTFOUND;
28531: }
28532:
28533: /*
28534: ** Return the sector size in bytes of the underlying block device for
28535: ** the specified file. This is almost always 512 bytes, but may be
28536: ** larger for some devices.
28537: **
28538: ** SQLite code assumes this function cannot fail. It also assumes that
28539: ** if two files are created in the same file-system directory (i.e.
28540: ** a database and its journal file) that the sector size will be the
28541: ** same for both.
28542: */
28543: static int unixSectorSize(sqlite3_file *pFile){
28544: (void)pFile;
28545: return SQLITE_DEFAULT_SECTOR_SIZE;
28546: }
28547:
28548: /*
28549: ** Return the device characteristics for the file.
28550: **
28551: ** This VFS is set up to return SQLITE_IOCAP_POWERSAFE_OVERWRITE by default.
28552: ** However, that choice is contraversial since technically the underlying
28553: ** file system does not always provide powersafe overwrites. (In other
28554: ** words, after a power-loss event, parts of the file that were never
28555: ** written might end up being altered.) However, non-PSOW behavior is very,
28556: ** very rare. And asserting PSOW makes a large reduction in the amount
28557: ** of required I/O for journaling, since a lot of padding is eliminated.
28558: ** Hence, while POWERSAFE_OVERWRITE is on by default, there is a file-control
28559: ** available to turn it off and URI query parameter available to turn it off.
28560: */
28561: static int unixDeviceCharacteristics(sqlite3_file *id){
28562: unixFile *p = (unixFile*)id;
28563: if( p->ctrlFlags & UNIXFILE_PSOW ){
28564: return SQLITE_IOCAP_POWERSAFE_OVERWRITE;
28565: }else{
28566: return 0;
28567: }
28568: }
28569:
28570: #ifndef SQLITE_OMIT_WAL
28571:
28572:
28573: /*
28574: ** Object used to represent an shared memory buffer.
28575: **
28576: ** When multiple threads all reference the same wal-index, each thread
28577: ** has its own unixShm object, but they all point to a single instance
28578: ** of this unixShmNode object. In other words, each wal-index is opened
28579: ** only once per process.
28580: **
28581: ** Each unixShmNode object is connected to a single unixInodeInfo object.
28582: ** We could coalesce this object into unixInodeInfo, but that would mean
28583: ** every open file that does not use shared memory (in other words, most
28584: ** open files) would have to carry around this extra information. So
28585: ** the unixInodeInfo object contains a pointer to this unixShmNode object
28586: ** and the unixShmNode object is created only when needed.
28587: **
28588: ** unixMutexHeld() must be true when creating or destroying
28589: ** this object or while reading or writing the following fields:
28590: **
28591: ** nRef
28592: **
28593: ** The following fields are read-only after the object is created:
28594: **
28595: ** fid
28596: ** zFilename
28597: **
28598: ** Either unixShmNode.mutex must be held or unixShmNode.nRef==0 and
28599: ** unixMutexHeld() is true when reading or writing any other field
28600: ** in this structure.
28601: */
28602: struct unixShmNode {
28603: unixInodeInfo *pInode; /* unixInodeInfo that owns this SHM node */
28604: sqlite3_mutex *mutex; /* Mutex to access this object */
28605: char *zFilename; /* Name of the mmapped file */
28606: int h; /* Open file descriptor */
28607: int szRegion; /* Size of shared-memory regions */
28608: u16 nRegion; /* Size of array apRegion */
28609: u8 isReadonly; /* True if read-only */
28610: char **apRegion; /* Array of mapped shared-memory regions */
28611: int nRef; /* Number of unixShm objects pointing to this */
28612: unixShm *pFirst; /* All unixShm objects pointing to this */
28613: #ifdef SQLITE_DEBUG
28614: u8 exclMask; /* Mask of exclusive locks held */
28615: u8 sharedMask; /* Mask of shared locks held */
28616: u8 nextShmId; /* Next available unixShm.id value */
28617: #endif
28618: };
28619:
28620: /*
28621: ** Structure used internally by this VFS to record the state of an
28622: ** open shared memory connection.
28623: **
28624: ** The following fields are initialized when this object is created and
28625: ** are read-only thereafter:
28626: **
28627: ** unixShm.pFile
28628: ** unixShm.id
28629: **
28630: ** All other fields are read/write. The unixShm.pFile->mutex must be held
28631: ** while accessing any read/write fields.
28632: */
28633: struct unixShm {
28634: unixShmNode *pShmNode; /* The underlying unixShmNode object */
28635: unixShm *pNext; /* Next unixShm with the same unixShmNode */
28636: u8 hasMutex; /* True if holding the unixShmNode mutex */
28637: u8 id; /* Id of this connection within its unixShmNode */
28638: u16 sharedMask; /* Mask of shared locks held */
28639: u16 exclMask; /* Mask of exclusive locks held */
28640: };
28641:
28642: /*
28643: ** Constants used for locking
28644: */
28645: #define UNIX_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */
28646: #define UNIX_SHM_DMS (UNIX_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */
28647:
28648: /*
28649: ** Apply posix advisory locks for all bytes from ofst through ofst+n-1.
28650: **
28651: ** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking
28652: ** otherwise.
28653: */
28654: static int unixShmSystemLock(
28655: unixShmNode *pShmNode, /* Apply locks to this open shared-memory segment */
28656: int lockType, /* F_UNLCK, F_RDLCK, or F_WRLCK */
28657: int ofst, /* First byte of the locking range */
28658: int n /* Number of bytes to lock */
28659: ){
28660: struct flock f; /* The posix advisory locking structure */
28661: int rc = SQLITE_OK; /* Result code form fcntl() */
28662:
28663: /* Access to the unixShmNode object is serialized by the caller */
28664: assert( sqlite3_mutex_held(pShmNode->mutex) || pShmNode->nRef==0 );
28665:
28666: /* Shared locks never span more than one byte */
28667: assert( n==1 || lockType!=F_RDLCK );
28668:
28669: /* Locks are within range */
28670: assert( n>=1 && n<SQLITE_SHM_NLOCK );
28671:
28672: if( pShmNode->h>=0 ){
28673: /* Initialize the locking parameters */
28674: memset(&f, 0, sizeof(f));
28675: f.l_type = lockType;
28676: f.l_whence = SEEK_SET;
28677: f.l_start = ofst;
28678: f.l_len = n;
28679:
28680: rc = osFcntl(pShmNode->h, F_SETLK, &f);
28681: rc = (rc!=(-1)) ? SQLITE_OK : SQLITE_BUSY;
28682: }
28683:
28684: /* Update the global lock state and do debug tracing */
28685: #ifdef SQLITE_DEBUG
28686: { u16 mask;
28687: OSTRACE(("SHM-LOCK "));
28688: mask = (1<<(ofst+n)) - (1<<ofst);
28689: if( rc==SQLITE_OK ){
28690: if( lockType==F_UNLCK ){
28691: OSTRACE(("unlock %d ok", ofst));
28692: pShmNode->exclMask &= ~mask;
28693: pShmNode->sharedMask &= ~mask;
28694: }else if( lockType==F_RDLCK ){
28695: OSTRACE(("read-lock %d ok", ofst));
28696: pShmNode->exclMask &= ~mask;
28697: pShmNode->sharedMask |= mask;
28698: }else{
28699: assert( lockType==F_WRLCK );
28700: OSTRACE(("write-lock %d ok", ofst));
28701: pShmNode->exclMask |= mask;
28702: pShmNode->sharedMask &= ~mask;
28703: }
28704: }else{
28705: if( lockType==F_UNLCK ){
28706: OSTRACE(("unlock %d failed", ofst));
28707: }else if( lockType==F_RDLCK ){
28708: OSTRACE(("read-lock failed"));
28709: }else{
28710: assert( lockType==F_WRLCK );
28711: OSTRACE(("write-lock %d failed", ofst));
28712: }
28713: }
28714: OSTRACE((" - afterwards %03x,%03x\n",
28715: pShmNode->sharedMask, pShmNode->exclMask));
28716: }
28717: #endif
28718:
28719: return rc;
28720: }
28721:
28722:
28723: /*
28724: ** Purge the unixShmNodeList list of all entries with unixShmNode.nRef==0.
28725: **
28726: ** This is not a VFS shared-memory method; it is a utility function called
28727: ** by VFS shared-memory methods.
28728: */
28729: static void unixShmPurge(unixFile *pFd){
28730: unixShmNode *p = pFd->pInode->pShmNode;
28731: assert( unixMutexHeld() );
28732: if( p && p->nRef==0 ){
28733: int i;
28734: assert( p->pInode==pFd->pInode );
28735: sqlite3_mutex_free(p->mutex);
28736: for(i=0; i<p->nRegion; i++){
28737: if( p->h>=0 ){
28738: munmap(p->apRegion[i], p->szRegion);
28739: }else{
28740: sqlite3_free(p->apRegion[i]);
28741: }
28742: }
28743: sqlite3_free(p->apRegion);
28744: if( p->h>=0 ){
28745: robust_close(pFd, p->h, __LINE__);
28746: p->h = -1;
28747: }
28748: p->pInode->pShmNode = 0;
28749: sqlite3_free(p);
28750: }
28751: }
28752:
28753: /*
28754: ** Open a shared-memory area associated with open database file pDbFd.
28755: ** This particular implementation uses mmapped files.
28756: **
28757: ** The file used to implement shared-memory is in the same directory
28758: ** as the open database file and has the same name as the open database
28759: ** file with the "-shm" suffix added. For example, if the database file
28760: ** is "/home/user1/config.db" then the file that is created and mmapped
28761: ** for shared memory will be called "/home/user1/config.db-shm".
28762: **
28763: ** Another approach to is to use files in /dev/shm or /dev/tmp or an
28764: ** some other tmpfs mount. But if a file in a different directory
28765: ** from the database file is used, then differing access permissions
28766: ** or a chroot() might cause two different processes on the same
28767: ** database to end up using different files for shared memory -
28768: ** meaning that their memory would not really be shared - resulting
28769: ** in database corruption. Nevertheless, this tmpfs file usage
28770: ** can be enabled at compile-time using -DSQLITE_SHM_DIRECTORY="/dev/shm"
28771: ** or the equivalent. The use of the SQLITE_SHM_DIRECTORY compile-time
28772: ** option results in an incompatible build of SQLite; builds of SQLite
28773: ** that with differing SQLITE_SHM_DIRECTORY settings attempt to use the
28774: ** same database file at the same time, database corruption will likely
28775: ** result. The SQLITE_SHM_DIRECTORY compile-time option is considered
28776: ** "unsupported" and may go away in a future SQLite release.
28777: **
28778: ** When opening a new shared-memory file, if no other instances of that
28779: ** file are currently open, in this process or in other processes, then
28780: ** the file must be truncated to zero length or have its header cleared.
28781: **
28782: ** If the original database file (pDbFd) is using the "unix-excl" VFS
28783: ** that means that an exclusive lock is held on the database file and
28784: ** that no other processes are able to read or write the database. In
28785: ** that case, we do not really need shared memory. No shared memory
28786: ** file is created. The shared memory will be simulated with heap memory.
28787: */
28788: static int unixOpenSharedMemory(unixFile *pDbFd){
28789: struct unixShm *p = 0; /* The connection to be opened */
28790: struct unixShmNode *pShmNode; /* The underlying mmapped file */
28791: int rc; /* Result code */
28792: unixInodeInfo *pInode; /* The inode of fd */
28793: char *zShmFilename; /* Name of the file used for SHM */
28794: int nShmFilename; /* Size of the SHM filename in bytes */
28795:
28796: /* Allocate space for the new unixShm object. */
28797: p = sqlite3_malloc( sizeof(*p) );
28798: if( p==0 ) return SQLITE_NOMEM;
28799: memset(p, 0, sizeof(*p));
28800: assert( pDbFd->pShm==0 );
28801:
28802: /* Check to see if a unixShmNode object already exists. Reuse an existing
28803: ** one if present. Create a new one if necessary.
28804: */
28805: unixEnterMutex();
28806: pInode = pDbFd->pInode;
28807: pShmNode = pInode->pShmNode;
28808: if( pShmNode==0 ){
28809: struct stat sStat; /* fstat() info for database file */
28810:
28811: /* Call fstat() to figure out the permissions on the database file. If
28812: ** a new *-shm file is created, an attempt will be made to create it
28813: ** with the same permissions. The actual permissions the file is created
28814: ** with are subject to the current umask setting.
28815: */
28816: if( osFstat(pDbFd->h, &sStat) && pInode->bProcessLock==0 ){
28817: rc = SQLITE_IOERR_FSTAT;
28818: goto shm_open_err;
28819: }
28820:
28821: #ifdef SQLITE_SHM_DIRECTORY
28822: nShmFilename = sizeof(SQLITE_SHM_DIRECTORY) + 31;
28823: #else
28824: nShmFilename = 6 + (int)strlen(pDbFd->zPath);
28825: #endif
28826: pShmNode = sqlite3_malloc( sizeof(*pShmNode) + nShmFilename );
28827: if( pShmNode==0 ){
28828: rc = SQLITE_NOMEM;
28829: goto shm_open_err;
28830: }
28831: memset(pShmNode, 0, sizeof(*pShmNode)+nShmFilename);
28832: zShmFilename = pShmNode->zFilename = (char*)&pShmNode[1];
28833: #ifdef SQLITE_SHM_DIRECTORY
28834: sqlite3_snprintf(nShmFilename, zShmFilename,
28835: SQLITE_SHM_DIRECTORY "/sqlite-shm-%x-%x",
28836: (u32)sStat.st_ino, (u32)sStat.st_dev);
28837: #else
28838: sqlite3_snprintf(nShmFilename, zShmFilename, "%s-shm", pDbFd->zPath);
28839: sqlite3FileSuffix3(pDbFd->zPath, zShmFilename);
28840: #endif
28841: pShmNode->h = -1;
28842: pDbFd->pInode->pShmNode = pShmNode;
28843: pShmNode->pInode = pDbFd->pInode;
28844: pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
28845: if( pShmNode->mutex==0 ){
28846: rc = SQLITE_NOMEM;
28847: goto shm_open_err;
28848: }
28849:
28850: if( pInode->bProcessLock==0 ){
28851: int openFlags = O_RDWR | O_CREAT;
28852: if( sqlite3_uri_boolean(pDbFd->zPath, "readonly_shm", 0) ){
28853: openFlags = O_RDONLY;
28854: pShmNode->isReadonly = 1;
28855: }
28856: pShmNode->h = robust_open(zShmFilename, openFlags, (sStat.st_mode&0777));
28857: if( pShmNode->h<0 ){
28858: if( pShmNode->h<0 ){
28859: rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShmFilename);
28860: goto shm_open_err;
28861: }
28862: }
28863:
28864: /* Check to see if another process is holding the dead-man switch.
28865: ** If not, truncate the file to zero length.
28866: */
28867: rc = SQLITE_OK;
28868: if( unixShmSystemLock(pShmNode, F_WRLCK, UNIX_SHM_DMS, 1)==SQLITE_OK ){
28869: if( robust_ftruncate(pShmNode->h, 0) ){
28870: rc = unixLogError(SQLITE_IOERR_SHMOPEN, "ftruncate", zShmFilename);
28871: }
28872: }
28873: if( rc==SQLITE_OK ){
28874: rc = unixShmSystemLock(pShmNode, F_RDLCK, UNIX_SHM_DMS, 1);
28875: }
28876: if( rc ) goto shm_open_err;
28877: }
28878: }
28879:
28880: /* Make the new connection a child of the unixShmNode */
28881: p->pShmNode = pShmNode;
28882: #ifdef SQLITE_DEBUG
28883: p->id = pShmNode->nextShmId++;
28884: #endif
28885: pShmNode->nRef++;
28886: pDbFd->pShm = p;
28887: unixLeaveMutex();
28888:
28889: /* The reference count on pShmNode has already been incremented under
28890: ** the cover of the unixEnterMutex() mutex and the pointer from the
28891: ** new (struct unixShm) object to the pShmNode has been set. All that is
28892: ** left to do is to link the new object into the linked list starting
28893: ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
28894: ** mutex.
28895: */
28896: sqlite3_mutex_enter(pShmNode->mutex);
28897: p->pNext = pShmNode->pFirst;
28898: pShmNode->pFirst = p;
28899: sqlite3_mutex_leave(pShmNode->mutex);
28900: return SQLITE_OK;
28901:
28902: /* Jump here on any error */
28903: shm_open_err:
28904: unixShmPurge(pDbFd); /* This call frees pShmNode if required */
28905: sqlite3_free(p);
28906: unixLeaveMutex();
28907: return rc;
28908: }
28909:
28910: /*
28911: ** This function is called to obtain a pointer to region iRegion of the
28912: ** shared-memory associated with the database file fd. Shared-memory regions
28913: ** are numbered starting from zero. Each shared-memory region is szRegion
28914: ** bytes in size.
28915: **
28916: ** If an error occurs, an error code is returned and *pp is set to NULL.
28917: **
28918: ** Otherwise, if the bExtend parameter is 0 and the requested shared-memory
28919: ** region has not been allocated (by any client, including one running in a
28920: ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
28921: ** bExtend is non-zero and the requested shared-memory region has not yet
28922: ** been allocated, it is allocated by this function.
28923: **
28924: ** If the shared-memory region has already been allocated or is allocated by
28925: ** this call as described above, then it is mapped into this processes
28926: ** address space (if it is not already), *pp is set to point to the mapped
28927: ** memory and SQLITE_OK returned.
28928: */
28929: static int unixShmMap(
28930: sqlite3_file *fd, /* Handle open on database file */
28931: int iRegion, /* Region to retrieve */
28932: int szRegion, /* Size of regions */
28933: int bExtend, /* True to extend file if necessary */
28934: void volatile **pp /* OUT: Mapped memory */
28935: ){
28936: unixFile *pDbFd = (unixFile*)fd;
28937: unixShm *p;
28938: unixShmNode *pShmNode;
28939: int rc = SQLITE_OK;
28940:
28941: /* If the shared-memory file has not yet been opened, open it now. */
28942: if( pDbFd->pShm==0 ){
28943: rc = unixOpenSharedMemory(pDbFd);
28944: if( rc!=SQLITE_OK ) return rc;
28945: }
28946:
28947: p = pDbFd->pShm;
28948: pShmNode = p->pShmNode;
28949: sqlite3_mutex_enter(pShmNode->mutex);
28950: assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
28951: assert( pShmNode->pInode==pDbFd->pInode );
28952: assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
28953: assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
28954:
28955: if( pShmNode->nRegion<=iRegion ){
28956: char **apNew; /* New apRegion[] array */
28957: int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
28958: struct stat sStat; /* Used by fstat() */
28959:
28960: pShmNode->szRegion = szRegion;
28961:
28962: if( pShmNode->h>=0 ){
28963: /* The requested region is not mapped into this processes address space.
28964: ** Check to see if it has been allocated (i.e. if the wal-index file is
28965: ** large enough to contain the requested region).
28966: */
28967: if( osFstat(pShmNode->h, &sStat) ){
28968: rc = SQLITE_IOERR_SHMSIZE;
28969: goto shmpage_out;
28970: }
28971:
28972: if( sStat.st_size<nByte ){
28973: /* The requested memory region does not exist. If bExtend is set to
28974: ** false, exit early. *pp will be set to NULL and SQLITE_OK returned.
28975: **
28976: ** Alternatively, if bExtend is true, use ftruncate() to allocate
28977: ** the requested memory region.
28978: */
28979: if( !bExtend ) goto shmpage_out;
28980: if( robust_ftruncate(pShmNode->h, nByte) ){
28981: rc = unixLogError(SQLITE_IOERR_SHMSIZE, "ftruncate",
28982: pShmNode->zFilename);
28983: goto shmpage_out;
28984: }
28985: }
28986: }
28987:
28988: /* Map the requested memory region into this processes address space. */
28989: apNew = (char **)sqlite3_realloc(
28990: pShmNode->apRegion, (iRegion+1)*sizeof(char *)
28991: );
28992: if( !apNew ){
28993: rc = SQLITE_IOERR_NOMEM;
28994: goto shmpage_out;
28995: }
28996: pShmNode->apRegion = apNew;
28997: while(pShmNode->nRegion<=iRegion){
28998: void *pMem;
28999: if( pShmNode->h>=0 ){
29000: pMem = mmap(0, szRegion,
29001: pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE,
29002: MAP_SHARED, pShmNode->h, pShmNode->nRegion*szRegion
29003: );
29004: if( pMem==MAP_FAILED ){
29005: rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
29006: goto shmpage_out;
29007: }
29008: }else{
29009: pMem = sqlite3_malloc(szRegion);
29010: if( pMem==0 ){
29011: rc = SQLITE_NOMEM;
29012: goto shmpage_out;
29013: }
29014: memset(pMem, 0, szRegion);
29015: }
29016: pShmNode->apRegion[pShmNode->nRegion] = pMem;
29017: pShmNode->nRegion++;
29018: }
29019: }
29020:
29021: shmpage_out:
29022: if( pShmNode->nRegion>iRegion ){
29023: *pp = pShmNode->apRegion[iRegion];
29024: }else{
29025: *pp = 0;
29026: }
29027: if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
29028: sqlite3_mutex_leave(pShmNode->mutex);
29029: return rc;
29030: }
29031:
29032: /*
29033: ** Change the lock state for a shared-memory segment.
29034: **
29035: ** Note that the relationship between SHAREd and EXCLUSIVE locks is a little
29036: ** different here than in posix. In xShmLock(), one can go from unlocked
29037: ** to shared and back or from unlocked to exclusive and back. But one may
29038: ** not go from shared to exclusive or from exclusive to shared.
29039: */
29040: static int unixShmLock(
29041: sqlite3_file *fd, /* Database file holding the shared memory */
29042: int ofst, /* First lock to acquire or release */
29043: int n, /* Number of locks to acquire or release */
29044: int flags /* What to do with the lock */
29045: ){
29046: unixFile *pDbFd = (unixFile*)fd; /* Connection holding shared memory */
29047: unixShm *p = pDbFd->pShm; /* The shared memory being locked */
29048: unixShm *pX; /* For looping over all siblings */
29049: unixShmNode *pShmNode = p->pShmNode; /* The underlying file iNode */
29050: int rc = SQLITE_OK; /* Result code */
29051: u16 mask; /* Mask of locks to take or release */
29052:
29053: assert( pShmNode==pDbFd->pInode->pShmNode );
29054: assert( pShmNode->pInode==pDbFd->pInode );
29055: assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
29056: assert( n>=1 );
29057: assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
29058: || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
29059: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
29060: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
29061: assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
29062: assert( pShmNode->h>=0 || pDbFd->pInode->bProcessLock==1 );
29063: assert( pShmNode->h<0 || pDbFd->pInode->bProcessLock==0 );
29064:
29065: mask = (1<<(ofst+n)) - (1<<ofst);
29066: assert( n>1 || mask==(1<<ofst) );
29067: sqlite3_mutex_enter(pShmNode->mutex);
29068: if( flags & SQLITE_SHM_UNLOCK ){
29069: u16 allMask = 0; /* Mask of locks held by siblings */
29070:
29071: /* See if any siblings hold this same lock */
29072: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
29073: if( pX==p ) continue;
29074: assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
29075: allMask |= pX->sharedMask;
29076: }
29077:
29078: /* Unlock the system-level locks */
29079: if( (mask & allMask)==0 ){
29080: rc = unixShmSystemLock(pShmNode, F_UNLCK, ofst+UNIX_SHM_BASE, n);
29081: }else{
29082: rc = SQLITE_OK;
29083: }
29084:
29085: /* Undo the local locks */
29086: if( rc==SQLITE_OK ){
29087: p->exclMask &= ~mask;
29088: p->sharedMask &= ~mask;
29089: }
29090: }else if( flags & SQLITE_SHM_SHARED ){
29091: u16 allShared = 0; /* Union of locks held by connections other than "p" */
29092:
29093: /* Find out which shared locks are already held by sibling connections.
29094: ** If any sibling already holds an exclusive lock, go ahead and return
29095: ** SQLITE_BUSY.
29096: */
29097: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
29098: if( (pX->exclMask & mask)!=0 ){
29099: rc = SQLITE_BUSY;
29100: break;
29101: }
29102: allShared |= pX->sharedMask;
29103: }
29104:
29105: /* Get shared locks at the system level, if necessary */
29106: if( rc==SQLITE_OK ){
29107: if( (allShared & mask)==0 ){
29108: rc = unixShmSystemLock(pShmNode, F_RDLCK, ofst+UNIX_SHM_BASE, n);
29109: }else{
29110: rc = SQLITE_OK;
29111: }
29112: }
29113:
29114: /* Get the local shared locks */
29115: if( rc==SQLITE_OK ){
29116: p->sharedMask |= mask;
29117: }
29118: }else{
29119: /* Make sure no sibling connections hold locks that will block this
29120: ** lock. If any do, return SQLITE_BUSY right away.
29121: */
29122: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
29123: if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
29124: rc = SQLITE_BUSY;
29125: break;
29126: }
29127: }
29128:
29129: /* Get the exclusive locks at the system level. Then if successful
29130: ** also mark the local connection as being locked.
29131: */
29132: if( rc==SQLITE_OK ){
29133: rc = unixShmSystemLock(pShmNode, F_WRLCK, ofst+UNIX_SHM_BASE, n);
29134: if( rc==SQLITE_OK ){
29135: assert( (p->sharedMask & mask)==0 );
29136: p->exclMask |= mask;
29137: }
29138: }
29139: }
29140: sqlite3_mutex_leave(pShmNode->mutex);
29141: OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n",
29142: p->id, getpid(), p->sharedMask, p->exclMask));
29143: return rc;
29144: }
29145:
29146: /*
29147: ** Implement a memory barrier or memory fence on shared memory.
29148: **
29149: ** All loads and stores begun before the barrier must complete before
29150: ** any load or store begun after the barrier.
29151: */
29152: static void unixShmBarrier(
29153: sqlite3_file *fd /* Database file holding the shared memory */
29154: ){
29155: UNUSED_PARAMETER(fd);
29156: unixEnterMutex();
29157: unixLeaveMutex();
29158: }
29159:
29160: /*
29161: ** Close a connection to shared-memory. Delete the underlying
29162: ** storage if deleteFlag is true.
29163: **
29164: ** If there is no shared memory associated with the connection then this
29165: ** routine is a harmless no-op.
29166: */
29167: static int unixShmUnmap(
29168: sqlite3_file *fd, /* The underlying database file */
29169: int deleteFlag /* Delete shared-memory if true */
29170: ){
29171: unixShm *p; /* The connection to be closed */
29172: unixShmNode *pShmNode; /* The underlying shared-memory file */
29173: unixShm **pp; /* For looping over sibling connections */
29174: unixFile *pDbFd; /* The underlying database file */
29175:
29176: pDbFd = (unixFile*)fd;
29177: p = pDbFd->pShm;
29178: if( p==0 ) return SQLITE_OK;
29179: pShmNode = p->pShmNode;
29180:
29181: assert( pShmNode==pDbFd->pInode->pShmNode );
29182: assert( pShmNode->pInode==pDbFd->pInode );
29183:
29184: /* Remove connection p from the set of connections associated
29185: ** with pShmNode */
29186: sqlite3_mutex_enter(pShmNode->mutex);
29187: for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
29188: *pp = p->pNext;
29189:
29190: /* Free the connection p */
29191: sqlite3_free(p);
29192: pDbFd->pShm = 0;
29193: sqlite3_mutex_leave(pShmNode->mutex);
29194:
29195: /* If pShmNode->nRef has reached 0, then close the underlying
29196: ** shared-memory file, too */
29197: unixEnterMutex();
29198: assert( pShmNode->nRef>0 );
29199: pShmNode->nRef--;
29200: if( pShmNode->nRef==0 ){
29201: if( deleteFlag && pShmNode->h>=0 ) osUnlink(pShmNode->zFilename);
29202: unixShmPurge(pDbFd);
29203: }
29204: unixLeaveMutex();
29205:
29206: return SQLITE_OK;
29207: }
29208:
29209:
29210: #else
29211: # define unixShmMap 0
29212: # define unixShmLock 0
29213: # define unixShmBarrier 0
29214: # define unixShmUnmap 0
29215: #endif /* #ifndef SQLITE_OMIT_WAL */
29216:
29217: /*
29218: ** Here ends the implementation of all sqlite3_file methods.
29219: **
29220: ********************** End sqlite3_file Methods *******************************
29221: ******************************************************************************/
29222:
29223: /*
29224: ** This division contains definitions of sqlite3_io_methods objects that
29225: ** implement various file locking strategies. It also contains definitions
29226: ** of "finder" functions. A finder-function is used to locate the appropriate
29227: ** sqlite3_io_methods object for a particular database file. The pAppData
29228: ** field of the sqlite3_vfs VFS objects are initialized to be pointers to
29229: ** the correct finder-function for that VFS.
29230: **
29231: ** Most finder functions return a pointer to a fixed sqlite3_io_methods
29232: ** object. The only interesting finder-function is autolockIoFinder, which
29233: ** looks at the filesystem type and tries to guess the best locking
29234: ** strategy from that.
29235: **
29236: ** For finder-funtion F, two objects are created:
29237: **
29238: ** (1) The real finder-function named "FImpt()".
29239: **
29240: ** (2) A constant pointer to this function named just "F".
29241: **
29242: **
29243: ** A pointer to the F pointer is used as the pAppData value for VFS
29244: ** objects. We have to do this instead of letting pAppData point
29245: ** directly at the finder-function since C90 rules prevent a void*
29246: ** from be cast into a function pointer.
29247: **
29248: **
29249: ** Each instance of this macro generates two objects:
29250: **
29251: ** * A constant sqlite3_io_methods object call METHOD that has locking
29252: ** methods CLOSE, LOCK, UNLOCK, CKRESLOCK.
29253: **
29254: ** * An I/O method finder function called FINDER that returns a pointer
29255: ** to the METHOD object in the previous bullet.
29256: */
29257: #define IOMETHODS(FINDER, METHOD, VERSION, CLOSE, LOCK, UNLOCK, CKLOCK) \
29258: static const sqlite3_io_methods METHOD = { \
29259: VERSION, /* iVersion */ \
29260: CLOSE, /* xClose */ \
29261: unixRead, /* xRead */ \
29262: unixWrite, /* xWrite */ \
29263: unixTruncate, /* xTruncate */ \
29264: unixSync, /* xSync */ \
29265: unixFileSize, /* xFileSize */ \
29266: LOCK, /* xLock */ \
29267: UNLOCK, /* xUnlock */ \
29268: CKLOCK, /* xCheckReservedLock */ \
29269: unixFileControl, /* xFileControl */ \
29270: unixSectorSize, /* xSectorSize */ \
29271: unixDeviceCharacteristics, /* xDeviceCapabilities */ \
29272: unixShmMap, /* xShmMap */ \
29273: unixShmLock, /* xShmLock */ \
29274: unixShmBarrier, /* xShmBarrier */ \
29275: unixShmUnmap /* xShmUnmap */ \
29276: }; \
29277: static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){ \
29278: UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \
29279: return &METHOD; \
29280: } \
29281: static const sqlite3_io_methods *(*const FINDER)(const char*,unixFile *p) \
29282: = FINDER##Impl;
29283:
29284: /*
29285: ** Here are all of the sqlite3_io_methods objects for each of the
29286: ** locking strategies. Functions that return pointers to these methods
29287: ** are also created.
29288: */
29289: IOMETHODS(
29290: posixIoFinder, /* Finder function name */
29291: posixIoMethods, /* sqlite3_io_methods object name */
29292: 2, /* shared memory is enabled */
29293: unixClose, /* xClose method */
29294: unixLock, /* xLock method */
29295: unixUnlock, /* xUnlock method */
29296: unixCheckReservedLock /* xCheckReservedLock method */
29297: )
29298: IOMETHODS(
29299: nolockIoFinder, /* Finder function name */
29300: nolockIoMethods, /* sqlite3_io_methods object name */
29301: 1, /* shared memory is disabled */
29302: nolockClose, /* xClose method */
29303: nolockLock, /* xLock method */
29304: nolockUnlock, /* xUnlock method */
29305: nolockCheckReservedLock /* xCheckReservedLock method */
29306: )
29307: IOMETHODS(
29308: dotlockIoFinder, /* Finder function name */
29309: dotlockIoMethods, /* sqlite3_io_methods object name */
29310: 1, /* shared memory is disabled */
29311: dotlockClose, /* xClose method */
29312: dotlockLock, /* xLock method */
29313: dotlockUnlock, /* xUnlock method */
29314: dotlockCheckReservedLock /* xCheckReservedLock method */
29315: )
29316:
29317: #if SQLITE_ENABLE_LOCKING_STYLE && !OS_VXWORKS
29318: IOMETHODS(
29319: flockIoFinder, /* Finder function name */
29320: flockIoMethods, /* sqlite3_io_methods object name */
29321: 1, /* shared memory is disabled */
29322: flockClose, /* xClose method */
29323: flockLock, /* xLock method */
29324: flockUnlock, /* xUnlock method */
29325: flockCheckReservedLock /* xCheckReservedLock method */
29326: )
29327: #endif
29328:
29329: #if OS_VXWORKS
29330: IOMETHODS(
29331: semIoFinder, /* Finder function name */
29332: semIoMethods, /* sqlite3_io_methods object name */
29333: 1, /* shared memory is disabled */
29334: semClose, /* xClose method */
29335: semLock, /* xLock method */
29336: semUnlock, /* xUnlock method */
29337: semCheckReservedLock /* xCheckReservedLock method */
29338: )
29339: #endif
29340:
29341: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
29342: IOMETHODS(
29343: afpIoFinder, /* Finder function name */
29344: afpIoMethods, /* sqlite3_io_methods object name */
29345: 1, /* shared memory is disabled */
29346: afpClose, /* xClose method */
29347: afpLock, /* xLock method */
29348: afpUnlock, /* xUnlock method */
29349: afpCheckReservedLock /* xCheckReservedLock method */
29350: )
29351: #endif
29352:
29353: /*
29354: ** The proxy locking method is a "super-method" in the sense that it
29355: ** opens secondary file descriptors for the conch and lock files and
29356: ** it uses proxy, dot-file, AFP, and flock() locking methods on those
29357: ** secondary files. For this reason, the division that implements
29358: ** proxy locking is located much further down in the file. But we need
29359: ** to go ahead and define the sqlite3_io_methods and finder function
29360: ** for proxy locking here. So we forward declare the I/O methods.
29361: */
29362: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
29363: static int proxyClose(sqlite3_file*);
29364: static int proxyLock(sqlite3_file*, int);
29365: static int proxyUnlock(sqlite3_file*, int);
29366: static int proxyCheckReservedLock(sqlite3_file*, int*);
29367: IOMETHODS(
29368: proxyIoFinder, /* Finder function name */
29369: proxyIoMethods, /* sqlite3_io_methods object name */
29370: 1, /* shared memory is disabled */
29371: proxyClose, /* xClose method */
29372: proxyLock, /* xLock method */
29373: proxyUnlock, /* xUnlock method */
29374: proxyCheckReservedLock /* xCheckReservedLock method */
29375: )
29376: #endif
29377:
29378: /* nfs lockd on OSX 10.3+ doesn't clear write locks when a read lock is set */
29379: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
29380: IOMETHODS(
29381: nfsIoFinder, /* Finder function name */
29382: nfsIoMethods, /* sqlite3_io_methods object name */
29383: 1, /* shared memory is disabled */
29384: unixClose, /* xClose method */
29385: unixLock, /* xLock method */
29386: nfsUnlock, /* xUnlock method */
29387: unixCheckReservedLock /* xCheckReservedLock method */
29388: )
29389: #endif
29390:
29391: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
29392: /*
29393: ** This "finder" function attempts to determine the best locking strategy
29394: ** for the database file "filePath". It then returns the sqlite3_io_methods
29395: ** object that implements that strategy.
29396: **
29397: ** This is for MacOSX only.
29398: */
29399: static const sqlite3_io_methods *autolockIoFinderImpl(
29400: const char *filePath, /* name of the database file */
29401: unixFile *pNew /* open file object for the database file */
29402: ){
29403: static const struct Mapping {
29404: const char *zFilesystem; /* Filesystem type name */
29405: const sqlite3_io_methods *pMethods; /* Appropriate locking method */
29406: } aMap[] = {
29407: { "hfs", &posixIoMethods },
29408: { "ufs", &posixIoMethods },
29409: { "afpfs", &afpIoMethods },
29410: { "smbfs", &afpIoMethods },
29411: { "webdav", &nolockIoMethods },
29412: { 0, 0 }
29413: };
29414: int i;
29415: struct statfs fsInfo;
29416: struct flock lockInfo;
29417:
29418: if( !filePath ){
29419: /* If filePath==NULL that means we are dealing with a transient file
29420: ** that does not need to be locked. */
29421: return &nolockIoMethods;
29422: }
29423: if( statfs(filePath, &fsInfo) != -1 ){
29424: if( fsInfo.f_flags & MNT_RDONLY ){
29425: return &nolockIoMethods;
29426: }
29427: for(i=0; aMap[i].zFilesystem; i++){
29428: if( strcmp(fsInfo.f_fstypename, aMap[i].zFilesystem)==0 ){
29429: return aMap[i].pMethods;
29430: }
29431: }
29432: }
29433:
29434: /* Default case. Handles, amongst others, "nfs".
29435: ** Test byte-range lock using fcntl(). If the call succeeds,
29436: ** assume that the file-system supports POSIX style locks.
29437: */
29438: lockInfo.l_len = 1;
29439: lockInfo.l_start = 0;
29440: lockInfo.l_whence = SEEK_SET;
29441: lockInfo.l_type = F_RDLCK;
29442: if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
29443: if( strcmp(fsInfo.f_fstypename, "nfs")==0 ){
29444: return &nfsIoMethods;
29445: } else {
29446: return &posixIoMethods;
29447: }
29448: }else{
29449: return &dotlockIoMethods;
29450: }
29451: }
29452: static const sqlite3_io_methods
29453: *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
29454:
29455: #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
29456:
29457: #if OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE
29458: /*
29459: ** This "finder" function attempts to determine the best locking strategy
29460: ** for the database file "filePath". It then returns the sqlite3_io_methods
29461: ** object that implements that strategy.
29462: **
29463: ** This is for VXWorks only.
29464: */
29465: static const sqlite3_io_methods *autolockIoFinderImpl(
29466: const char *filePath, /* name of the database file */
29467: unixFile *pNew /* the open file object */
29468: ){
29469: struct flock lockInfo;
29470:
29471: if( !filePath ){
29472: /* If filePath==NULL that means we are dealing with a transient file
29473: ** that does not need to be locked. */
29474: return &nolockIoMethods;
29475: }
29476:
29477: /* Test if fcntl() is supported and use POSIX style locks.
29478: ** Otherwise fall back to the named semaphore method.
29479: */
29480: lockInfo.l_len = 1;
29481: lockInfo.l_start = 0;
29482: lockInfo.l_whence = SEEK_SET;
29483: lockInfo.l_type = F_RDLCK;
29484: if( osFcntl(pNew->h, F_GETLK, &lockInfo)!=-1 ) {
29485: return &posixIoMethods;
29486: }else{
29487: return &semIoMethods;
29488: }
29489: }
29490: static const sqlite3_io_methods
29491: *(*const autolockIoFinder)(const char*,unixFile*) = autolockIoFinderImpl;
29492:
29493: #endif /* OS_VXWORKS && SQLITE_ENABLE_LOCKING_STYLE */
29494:
29495: /*
29496: ** An abstract type for a pointer to a IO method finder function:
29497: */
29498: typedef const sqlite3_io_methods *(*finder_type)(const char*,unixFile*);
29499:
29500:
29501: /****************************************************************************
29502: **************************** sqlite3_vfs methods ****************************
29503: **
29504: ** This division contains the implementation of methods on the
29505: ** sqlite3_vfs object.
29506: */
29507:
29508: /*
29509: ** Initialize the contents of the unixFile structure pointed to by pId.
29510: */
29511: static int fillInUnixFile(
29512: sqlite3_vfs *pVfs, /* Pointer to vfs object */
29513: int h, /* Open file descriptor of file being opened */
29514: sqlite3_file *pId, /* Write to the unixFile structure here */
29515: const char *zFilename, /* Name of the file being opened */
29516: int ctrlFlags /* Zero or more UNIXFILE_* values */
29517: ){
29518: const sqlite3_io_methods *pLockingStyle;
29519: unixFile *pNew = (unixFile *)pId;
29520: int rc = SQLITE_OK;
29521:
29522: assert( pNew->pInode==NULL );
29523:
29524: /* Usually the path zFilename should not be a relative pathname. The
29525: ** exception is when opening the proxy "conch" file in builds that
29526: ** include the special Apple locking styles.
29527: */
29528: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
29529: assert( zFilename==0 || zFilename[0]=='/'
29530: || pVfs->pAppData==(void*)&autolockIoFinder );
29531: #else
29532: assert( zFilename==0 || zFilename[0]=='/' );
29533: #endif
29534:
29535: /* No locking occurs in temporary files */
29536: assert( zFilename!=0 || (ctrlFlags & UNIXFILE_NOLOCK)!=0 );
29537:
29538: OSTRACE(("OPEN %-3d %s\n", h, zFilename));
29539: pNew->h = h;
29540: pNew->pVfs = pVfs;
29541: pNew->zPath = zFilename;
29542: pNew->ctrlFlags = (u8)ctrlFlags;
29543: if( sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0),
29544: "psow", SQLITE_POWERSAFE_OVERWRITE) ){
29545: pNew->ctrlFlags |= UNIXFILE_PSOW;
29546: }
29547: if( memcmp(pVfs->zName,"unix-excl",10)==0 ){
29548: pNew->ctrlFlags |= UNIXFILE_EXCL;
29549: }
29550:
29551: #if OS_VXWORKS
29552: pNew->pId = vxworksFindFileId(zFilename);
29553: if( pNew->pId==0 ){
29554: ctrlFlags |= UNIXFILE_NOLOCK;
29555: rc = SQLITE_NOMEM;
29556: }
29557: #endif
29558:
29559: if( ctrlFlags & UNIXFILE_NOLOCK ){
29560: pLockingStyle = &nolockIoMethods;
29561: }else{
29562: pLockingStyle = (**(finder_type*)pVfs->pAppData)(zFilename, pNew);
29563: #if SQLITE_ENABLE_LOCKING_STYLE
29564: /* Cache zFilename in the locking context (AFP and dotlock override) for
29565: ** proxyLock activation is possible (remote proxy is based on db name)
29566: ** zFilename remains valid until file is closed, to support */
29567: pNew->lockingContext = (void*)zFilename;
29568: #endif
29569: }
29570:
29571: if( pLockingStyle == &posixIoMethods
29572: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
29573: || pLockingStyle == &nfsIoMethods
29574: #endif
29575: ){
29576: unixEnterMutex();
29577: rc = findInodeInfo(pNew, &pNew->pInode);
29578: if( rc!=SQLITE_OK ){
29579: /* If an error occured in findInodeInfo(), close the file descriptor
29580: ** immediately, before releasing the mutex. findInodeInfo() may fail
29581: ** in two scenarios:
29582: **
29583: ** (a) A call to fstat() failed.
29584: ** (b) A malloc failed.
29585: **
29586: ** Scenario (b) may only occur if the process is holding no other
29587: ** file descriptors open on the same file. If there were other file
29588: ** descriptors on this file, then no malloc would be required by
29589: ** findInodeInfo(). If this is the case, it is quite safe to close
29590: ** handle h - as it is guaranteed that no posix locks will be released
29591: ** by doing so.
29592: **
29593: ** If scenario (a) caused the error then things are not so safe. The
29594: ** implicit assumption here is that if fstat() fails, things are in
29595: ** such bad shape that dropping a lock or two doesn't matter much.
29596: */
29597: robust_close(pNew, h, __LINE__);
29598: h = -1;
29599: }
29600: unixLeaveMutex();
29601: }
29602:
29603: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
29604: else if( pLockingStyle == &afpIoMethods ){
29605: /* AFP locking uses the file path so it needs to be included in
29606: ** the afpLockingContext.
29607: */
29608: afpLockingContext *pCtx;
29609: pNew->lockingContext = pCtx = sqlite3_malloc( sizeof(*pCtx) );
29610: if( pCtx==0 ){
29611: rc = SQLITE_NOMEM;
29612: }else{
29613: /* NB: zFilename exists and remains valid until the file is closed
29614: ** according to requirement F11141. So we do not need to make a
29615: ** copy of the filename. */
29616: pCtx->dbPath = zFilename;
29617: pCtx->reserved = 0;
29618: srandomdev();
29619: unixEnterMutex();
29620: rc = findInodeInfo(pNew, &pNew->pInode);
29621: if( rc!=SQLITE_OK ){
29622: sqlite3_free(pNew->lockingContext);
29623: robust_close(pNew, h, __LINE__);
29624: h = -1;
29625: }
29626: unixLeaveMutex();
29627: }
29628: }
29629: #endif
29630:
29631: else if( pLockingStyle == &dotlockIoMethods ){
29632: /* Dotfile locking uses the file path so it needs to be included in
29633: ** the dotlockLockingContext
29634: */
29635: char *zLockFile;
29636: int nFilename;
29637: assert( zFilename!=0 );
29638: nFilename = (int)strlen(zFilename) + 6;
29639: zLockFile = (char *)sqlite3_malloc(nFilename);
29640: if( zLockFile==0 ){
29641: rc = SQLITE_NOMEM;
29642: }else{
29643: sqlite3_snprintf(nFilename, zLockFile, "%s" DOTLOCK_SUFFIX, zFilename);
29644: }
29645: pNew->lockingContext = zLockFile;
29646: }
29647:
29648: #if OS_VXWORKS
29649: else if( pLockingStyle == &semIoMethods ){
29650: /* Named semaphore locking uses the file path so it needs to be
29651: ** included in the semLockingContext
29652: */
29653: unixEnterMutex();
29654: rc = findInodeInfo(pNew, &pNew->pInode);
29655: if( (rc==SQLITE_OK) && (pNew->pInode->pSem==NULL) ){
29656: char *zSemName = pNew->pInode->aSemName;
29657: int n;
29658: sqlite3_snprintf(MAX_PATHNAME, zSemName, "/%s.sem",
29659: pNew->pId->zCanonicalName);
29660: for( n=1; zSemName[n]; n++ )
29661: if( zSemName[n]=='/' ) zSemName[n] = '_';
29662: pNew->pInode->pSem = sem_open(zSemName, O_CREAT, 0666, 1);
29663: if( pNew->pInode->pSem == SEM_FAILED ){
29664: rc = SQLITE_NOMEM;
29665: pNew->pInode->aSemName[0] = '\0';
29666: }
29667: }
29668: unixLeaveMutex();
29669: }
29670: #endif
29671:
29672: pNew->lastErrno = 0;
29673: #if OS_VXWORKS
29674: if( rc!=SQLITE_OK ){
29675: if( h>=0 ) robust_close(pNew, h, __LINE__);
29676: h = -1;
29677: osUnlink(zFilename);
29678: isDelete = 0;
29679: }
29680: if( isDelete ) pNew->ctrlFlags |= UNIXFILE_DELETE;
29681: #endif
29682: if( rc!=SQLITE_OK ){
29683: if( h>=0 ) robust_close(pNew, h, __LINE__);
29684: }else{
29685: pNew->pMethod = pLockingStyle;
29686: OpenCounter(+1);
29687: }
29688: return rc;
29689: }
29690:
29691: /*
29692: ** Return the name of a directory in which to put temporary files.
29693: ** If no suitable temporary file directory can be found, return NULL.
29694: */
29695: static const char *unixTempFileDir(void){
29696: static const char *azDirs[] = {
29697: 0,
29698: 0,
29699: "/var/tmp",
29700: "/usr/tmp",
29701: "/tmp",
29702: 0 /* List terminator */
29703: };
29704: unsigned int i;
29705: struct stat buf;
29706: const char *zDir = 0;
29707:
29708: azDirs[0] = sqlite3_temp_directory;
29709: if( !azDirs[1] ) azDirs[1] = getenv("TMPDIR");
29710: for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); zDir=azDirs[i++]){
29711: if( zDir==0 ) continue;
29712: if( osStat(zDir, &buf) ) continue;
29713: if( !S_ISDIR(buf.st_mode) ) continue;
29714: if( osAccess(zDir, 07) ) continue;
29715: break;
29716: }
29717: return zDir;
29718: }
29719:
29720: /*
29721: ** Create a temporary file name in zBuf. zBuf must be allocated
29722: ** by the calling process and must be big enough to hold at least
29723: ** pVfs->mxPathname bytes.
29724: */
29725: static int unixGetTempname(int nBuf, char *zBuf){
29726: static const unsigned char zChars[] =
29727: "abcdefghijklmnopqrstuvwxyz"
29728: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
29729: "0123456789";
29730: unsigned int i, j;
29731: const char *zDir;
29732:
29733: /* It's odd to simulate an io-error here, but really this is just
29734: ** using the io-error infrastructure to test that SQLite handles this
29735: ** function failing.
29736: */
29737: SimulateIOError( return SQLITE_IOERR );
29738:
29739: zDir = unixTempFileDir();
29740: if( zDir==0 ) zDir = ".";
29741:
29742: /* Check that the output buffer is large enough for the temporary file
29743: ** name. If it is not, return SQLITE_ERROR.
29744: */
29745: if( (strlen(zDir) + strlen(SQLITE_TEMP_FILE_PREFIX) + 18) >= (size_t)nBuf ){
29746: return SQLITE_ERROR;
29747: }
29748:
29749: do{
29750: sqlite3_snprintf(nBuf-18, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX, zDir);
29751: j = (int)strlen(zBuf);
29752: sqlite3_randomness(15, &zBuf[j]);
29753: for(i=0; i<15; i++, j++){
29754: zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
29755: }
29756: zBuf[j] = 0;
29757: zBuf[j+1] = 0;
29758: }while( osAccess(zBuf,0)==0 );
29759: return SQLITE_OK;
29760: }
29761:
29762: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
29763: /*
29764: ** Routine to transform a unixFile into a proxy-locking unixFile.
29765: ** Implementation in the proxy-lock division, but used by unixOpen()
29766: ** if SQLITE_PREFER_PROXY_LOCKING is defined.
29767: */
29768: static int proxyTransformUnixFile(unixFile*, const char*);
29769: #endif
29770:
29771: /*
29772: ** Search for an unused file descriptor that was opened on the database
29773: ** file (not a journal or master-journal file) identified by pathname
29774: ** zPath with SQLITE_OPEN_XXX flags matching those passed as the second
29775: ** argument to this function.
29776: **
29777: ** Such a file descriptor may exist if a database connection was closed
29778: ** but the associated file descriptor could not be closed because some
29779: ** other file descriptor open on the same file is holding a file-lock.
29780: ** Refer to comments in the unixClose() function and the lengthy comment
29781: ** describing "Posix Advisory Locking" at the start of this file for
29782: ** further details. Also, ticket #4018.
29783: **
29784: ** If a suitable file descriptor is found, then it is returned. If no
29785: ** such file descriptor is located, -1 is returned.
29786: */
29787: static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
29788: UnixUnusedFd *pUnused = 0;
29789:
29790: /* Do not search for an unused file descriptor on vxworks. Not because
29791: ** vxworks would not benefit from the change (it might, we're not sure),
29792: ** but because no way to test it is currently available. It is better
29793: ** not to risk breaking vxworks support for the sake of such an obscure
29794: ** feature. */
29795: #if !OS_VXWORKS
29796: struct stat sStat; /* Results of stat() call */
29797:
29798: /* A stat() call may fail for various reasons. If this happens, it is
29799: ** almost certain that an open() call on the same path will also fail.
29800: ** For this reason, if an error occurs in the stat() call here, it is
29801: ** ignored and -1 is returned. The caller will try to open a new file
29802: ** descriptor on the same path, fail, and return an error to SQLite.
29803: **
29804: ** Even if a subsequent open() call does succeed, the consequences of
29805: ** not searching for a resusable file descriptor are not dire. */
29806: if( 0==osStat(zPath, &sStat) ){
29807: unixInodeInfo *pInode;
29808:
29809: unixEnterMutex();
29810: pInode = inodeList;
29811: while( pInode && (pInode->fileId.dev!=sStat.st_dev
29812: || pInode->fileId.ino!=sStat.st_ino) ){
29813: pInode = pInode->pNext;
29814: }
29815: if( pInode ){
29816: UnixUnusedFd **pp;
29817: for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
29818: pUnused = *pp;
29819: if( pUnused ){
29820: *pp = pUnused->pNext;
29821: }
29822: }
29823: unixLeaveMutex();
29824: }
29825: #endif /* if !OS_VXWORKS */
29826: return pUnused;
29827: }
29828:
29829: /*
29830: ** This function is called by unixOpen() to determine the unix permissions
29831: ** to create new files with. If no error occurs, then SQLITE_OK is returned
29832: ** and a value suitable for passing as the third argument to open(2) is
29833: ** written to *pMode. If an IO error occurs, an SQLite error code is
29834: ** returned and the value of *pMode is not modified.
29835: **
29836: ** If the file being opened is a temporary file, it is always created with
29837: ** the octal permissions 0600 (read/writable by owner only). If the file
29838: ** is a database or master journal file, it is created with the permissions
29839: ** mask SQLITE_DEFAULT_FILE_PERMISSIONS.
29840: **
29841: ** Finally, if the file being opened is a WAL or regular journal file, then
29842: ** this function queries the file-system for the permissions on the
29843: ** corresponding database file and sets *pMode to this value. Whenever
29844: ** possible, WAL and journal files are created using the same permissions
29845: ** as the associated database file.
29846: **
29847: ** If the SQLITE_ENABLE_8_3_NAMES option is enabled, then the
29848: ** original filename is unavailable. But 8_3_NAMES is only used for
29849: ** FAT filesystems and permissions do not matter there, so just use
29850: ** the default permissions.
29851: */
29852: static int findCreateFileMode(
29853: const char *zPath, /* Path of file (possibly) being created */
29854: int flags, /* Flags passed as 4th argument to xOpen() */
29855: mode_t *pMode /* OUT: Permissions to open file with */
29856: ){
29857: int rc = SQLITE_OK; /* Return Code */
29858: *pMode = SQLITE_DEFAULT_FILE_PERMISSIONS;
29859: if( flags & (SQLITE_OPEN_WAL|SQLITE_OPEN_MAIN_JOURNAL) ){
29860: char zDb[MAX_PATHNAME+1]; /* Database file path */
29861: int nDb; /* Number of valid bytes in zDb */
29862: struct stat sStat; /* Output of stat() on database file */
29863:
29864: /* zPath is a path to a WAL or journal file. The following block derives
29865: ** the path to the associated database file from zPath. This block handles
29866: ** the following naming conventions:
29867: **
29868: ** "<path to db>-journal"
29869: ** "<path to db>-wal"
29870: ** "<path to db>-journalNN"
29871: ** "<path to db>-walNN"
29872: **
29873: ** where NN is a decimal number. The NN naming schemes are
29874: ** used by the test_multiplex.c module.
29875: */
29876: nDb = sqlite3Strlen30(zPath) - 1;
29877: #ifdef SQLITE_ENABLE_8_3_NAMES
29878: while( nDb>0 && sqlite3Isalnum(zPath[nDb]) ) nDb--;
29879: if( nDb==0 || zPath[nDb]!='-' ) return SQLITE_OK;
29880: #else
29881: while( zPath[nDb]!='-' ){
29882: assert( nDb>0 );
29883: assert( zPath[nDb]!='\n' );
29884: nDb--;
29885: }
29886: #endif
29887: memcpy(zDb, zPath, nDb);
29888: zDb[nDb] = '\0';
29889:
29890: if( 0==osStat(zDb, &sStat) ){
29891: *pMode = sStat.st_mode & 0777;
29892: }else{
29893: rc = SQLITE_IOERR_FSTAT;
29894: }
29895: }else if( flags & SQLITE_OPEN_DELETEONCLOSE ){
29896: *pMode = 0600;
29897: }
29898: return rc;
29899: }
29900:
29901: /*
29902: ** Open the file zPath.
29903: **
29904: ** Previously, the SQLite OS layer used three functions in place of this
29905: ** one:
29906: **
29907: ** sqlite3OsOpenReadWrite();
29908: ** sqlite3OsOpenReadOnly();
29909: ** sqlite3OsOpenExclusive();
29910: **
29911: ** These calls correspond to the following combinations of flags:
29912: **
29913: ** ReadWrite() -> (READWRITE | CREATE)
29914: ** ReadOnly() -> (READONLY)
29915: ** OpenExclusive() -> (READWRITE | CREATE | EXCLUSIVE)
29916: **
29917: ** The old OpenExclusive() accepted a boolean argument - "delFlag". If
29918: ** true, the file was configured to be automatically deleted when the
29919: ** file handle closed. To achieve the same effect using this new
29920: ** interface, add the DELETEONCLOSE flag to those specified above for
29921: ** OpenExclusive().
29922: */
29923: static int unixOpen(
29924: sqlite3_vfs *pVfs, /* The VFS for which this is the xOpen method */
29925: const char *zPath, /* Pathname of file to be opened */
29926: sqlite3_file *pFile, /* The file descriptor to be filled in */
29927: int flags, /* Input flags to control the opening */
29928: int *pOutFlags /* Output flags returned to SQLite core */
29929: ){
29930: unixFile *p = (unixFile *)pFile;
29931: int fd = -1; /* File descriptor returned by open() */
29932: int openFlags = 0; /* Flags to pass to open() */
29933: int eType = flags&0xFFFFFF00; /* Type of file to open */
29934: int noLock; /* True to omit locking primitives */
29935: int rc = SQLITE_OK; /* Function Return Code */
29936: int ctrlFlags = 0; /* UNIXFILE_* flags */
29937:
29938: int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
29939: int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
29940: int isCreate = (flags & SQLITE_OPEN_CREATE);
29941: int isReadonly = (flags & SQLITE_OPEN_READONLY);
29942: int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
29943: #if SQLITE_ENABLE_LOCKING_STYLE
29944: int isAutoProxy = (flags & SQLITE_OPEN_AUTOPROXY);
29945: #endif
29946: #if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
29947: struct statfs fsInfo;
29948: #endif
29949:
29950: /* If creating a master or main-file journal, this function will open
29951: ** a file-descriptor on the directory too. The first time unixSync()
29952: ** is called the directory file descriptor will be fsync()ed and close()d.
29953: */
29954: int syncDir = (isCreate && (
29955: eType==SQLITE_OPEN_MASTER_JOURNAL
29956: || eType==SQLITE_OPEN_MAIN_JOURNAL
29957: || eType==SQLITE_OPEN_WAL
29958: ));
29959:
29960: /* If argument zPath is a NULL pointer, this function is required to open
29961: ** a temporary file. Use this buffer to store the file name in.
29962: */
29963: char zTmpname[MAX_PATHNAME+2];
29964: const char *zName = zPath;
29965:
29966: /* Check the following statements are true:
29967: **
29968: ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
29969: ** (b) if CREATE is set, then READWRITE must also be set, and
29970: ** (c) if EXCLUSIVE is set, then CREATE must also be set.
29971: ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
29972: */
29973: assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
29974: assert(isCreate==0 || isReadWrite);
29975: assert(isExclusive==0 || isCreate);
29976: assert(isDelete==0 || isCreate);
29977:
29978: /* The main DB, main journal, WAL file and master journal are never
29979: ** automatically deleted. Nor are they ever temporary files. */
29980: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
29981: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
29982: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
29983: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
29984:
29985: /* Assert that the upper layer has set one of the "file-type" flags. */
29986: assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
29987: || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
29988: || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
29989: || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
29990: );
29991:
29992: memset(p, 0, sizeof(unixFile));
29993:
29994: if( eType==SQLITE_OPEN_MAIN_DB ){
29995: UnixUnusedFd *pUnused;
29996: pUnused = findReusableFd(zName, flags);
29997: if( pUnused ){
29998: fd = pUnused->fd;
29999: }else{
30000: pUnused = sqlite3_malloc(sizeof(*pUnused));
30001: if( !pUnused ){
30002: return SQLITE_NOMEM;
30003: }
30004: }
30005: p->pUnused = pUnused;
30006:
30007: /* Database filenames are double-zero terminated if they are not
30008: ** URIs with parameters. Hence, they can always be passed into
30009: ** sqlite3_uri_parameter(). */
30010: assert( (flags & SQLITE_OPEN_URI) || zName[strlen(zName)+1]==0 );
30011:
30012: }else if( !zName ){
30013: /* If zName is NULL, the upper layer is requesting a temp file. */
30014: assert(isDelete && !syncDir);
30015: rc = unixGetTempname(MAX_PATHNAME+2, zTmpname);
30016: if( rc!=SQLITE_OK ){
30017: return rc;
30018: }
30019: zName = zTmpname;
30020:
30021: /* Generated temporary filenames are always double-zero terminated
30022: ** for use by sqlite3_uri_parameter(). */
30023: assert( zName[strlen(zName)+1]==0 );
30024: }
30025:
30026: /* Determine the value of the flags parameter passed to POSIX function
30027: ** open(). These must be calculated even if open() is not called, as
30028: ** they may be stored as part of the file handle and used by the
30029: ** 'conch file' locking functions later on. */
30030: if( isReadonly ) openFlags |= O_RDONLY;
30031: if( isReadWrite ) openFlags |= O_RDWR;
30032: if( isCreate ) openFlags |= O_CREAT;
30033: if( isExclusive ) openFlags |= (O_EXCL|O_NOFOLLOW);
30034: openFlags |= (O_LARGEFILE|O_BINARY);
30035:
30036: if( fd<0 ){
30037: mode_t openMode; /* Permissions to create file with */
30038: rc = findCreateFileMode(zName, flags, &openMode);
30039: if( rc!=SQLITE_OK ){
30040: assert( !p->pUnused );
30041: assert( eType==SQLITE_OPEN_WAL || eType==SQLITE_OPEN_MAIN_JOURNAL );
30042: return rc;
30043: }
30044: fd = robust_open(zName, openFlags, openMode);
30045: OSTRACE(("OPENX %-3d %s 0%o\n", fd, zName, openFlags));
30046: if( fd<0 && errno!=EISDIR && isReadWrite && !isExclusive ){
30047: /* Failed to open the file for read/write access. Try read-only. */
30048: flags &= ~(SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
30049: openFlags &= ~(O_RDWR|O_CREAT);
30050: flags |= SQLITE_OPEN_READONLY;
30051: openFlags |= O_RDONLY;
30052: isReadonly = 1;
30053: fd = robust_open(zName, openFlags, openMode);
30054: }
30055: if( fd<0 ){
30056: rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zName);
30057: goto open_finished;
30058: }
30059: }
30060: assert( fd>=0 );
30061: if( pOutFlags ){
30062: *pOutFlags = flags;
30063: }
30064:
30065: if( p->pUnused ){
30066: p->pUnused->fd = fd;
30067: p->pUnused->flags = flags;
30068: }
30069:
30070: if( isDelete ){
30071: #if OS_VXWORKS
30072: zPath = zName;
30073: #else
30074: osUnlink(zName);
30075: #endif
30076: }
30077: #if SQLITE_ENABLE_LOCKING_STYLE
30078: else{
30079: p->openFlags = openFlags;
30080: }
30081: #endif
30082:
30083: #ifdef FD_CLOEXEC
30084: osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
30085: #endif
30086:
30087: noLock = eType!=SQLITE_OPEN_MAIN_DB;
30088:
30089:
30090: #if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE
30091: if( fstatfs(fd, &fsInfo) == -1 ){
30092: ((unixFile*)pFile)->lastErrno = errno;
30093: robust_close(p, fd, __LINE__);
30094: return SQLITE_IOERR_ACCESS;
30095: }
30096: if (0 == strncmp("msdos", fsInfo.f_fstypename, 5)) {
30097: ((unixFile*)pFile)->fsFlags |= SQLITE_FSFLAGS_IS_MSDOS;
30098: }
30099: #endif
30100:
30101: /* Set up appropriate ctrlFlags */
30102: if( isDelete ) ctrlFlags |= UNIXFILE_DELETE;
30103: if( isReadonly ) ctrlFlags |= UNIXFILE_RDONLY;
30104: if( noLock ) ctrlFlags |= UNIXFILE_NOLOCK;
30105: if( syncDir ) ctrlFlags |= UNIXFILE_DIRSYNC;
30106: if( flags & SQLITE_OPEN_URI ) ctrlFlags |= UNIXFILE_URI;
30107:
30108: #if SQLITE_ENABLE_LOCKING_STYLE
30109: #if SQLITE_PREFER_PROXY_LOCKING
30110: isAutoProxy = 1;
30111: #endif
30112: if( isAutoProxy && (zPath!=NULL) && (!noLock) && pVfs->xOpen ){
30113: char *envforce = getenv("SQLITE_FORCE_PROXY_LOCKING");
30114: int useProxy = 0;
30115:
30116: /* SQLITE_FORCE_PROXY_LOCKING==1 means force always use proxy, 0 means
30117: ** never use proxy, NULL means use proxy for non-local files only. */
30118: if( envforce!=NULL ){
30119: useProxy = atoi(envforce)>0;
30120: }else{
30121: if( statfs(zPath, &fsInfo) == -1 ){
30122: /* In theory, the close(fd) call is sub-optimal. If the file opened
30123: ** with fd is a database file, and there are other connections open
30124: ** on that file that are currently holding advisory locks on it,
30125: ** then the call to close() will cancel those locks. In practice,
30126: ** we're assuming that statfs() doesn't fail very often. At least
30127: ** not while other file descriptors opened by the same process on
30128: ** the same file are working. */
30129: p->lastErrno = errno;
30130: robust_close(p, fd, __LINE__);
30131: rc = SQLITE_IOERR_ACCESS;
30132: goto open_finished;
30133: }
30134: useProxy = !(fsInfo.f_flags&MNT_LOCAL);
30135: }
30136: if( useProxy ){
30137: rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
30138: if( rc==SQLITE_OK ){
30139: rc = proxyTransformUnixFile((unixFile*)pFile, ":auto:");
30140: if( rc!=SQLITE_OK ){
30141: /* Use unixClose to clean up the resources added in fillInUnixFile
30142: ** and clear all the structure's references. Specifically,
30143: ** pFile->pMethods will be NULL so sqlite3OsClose will be a no-op
30144: */
30145: unixClose(pFile);
30146: return rc;
30147: }
30148: }
30149: goto open_finished;
30150: }
30151: }
30152: #endif
30153:
30154: rc = fillInUnixFile(pVfs, fd, pFile, zPath, ctrlFlags);
30155:
30156: open_finished:
30157: if( rc!=SQLITE_OK ){
30158: sqlite3_free(p->pUnused);
30159: }
30160: return rc;
30161: }
30162:
30163:
30164: /*
30165: ** Delete the file at zPath. If the dirSync argument is true, fsync()
30166: ** the directory after deleting the file.
30167: */
30168: static int unixDelete(
30169: sqlite3_vfs *NotUsed, /* VFS containing this as the xDelete method */
30170: const char *zPath, /* Name of file to be deleted */
30171: int dirSync /* If true, fsync() directory after deleting file */
30172: ){
30173: int rc = SQLITE_OK;
30174: UNUSED_PARAMETER(NotUsed);
30175: SimulateIOError(return SQLITE_IOERR_DELETE);
30176: if( osUnlink(zPath)==(-1) && errno!=ENOENT ){
30177: return unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath);
30178: }
30179: #ifndef SQLITE_DISABLE_DIRSYNC
30180: if( (dirSync & 1)!=0 ){
30181: int fd;
30182: rc = osOpenDirectory(zPath, &fd);
30183: if( rc==SQLITE_OK ){
30184: #if OS_VXWORKS
30185: if( fsync(fd)==-1 )
30186: #else
30187: if( fsync(fd) )
30188: #endif
30189: {
30190: rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
30191: }
30192: robust_close(0, fd, __LINE__);
30193: }else if( rc==SQLITE_CANTOPEN ){
30194: rc = SQLITE_OK;
30195: }
30196: }
30197: #endif
30198: return rc;
30199: }
30200:
30201: /*
30202: ** Test the existance of or access permissions of file zPath. The
30203: ** test performed depends on the value of flags:
30204: **
30205: ** SQLITE_ACCESS_EXISTS: Return 1 if the file exists
30206: ** SQLITE_ACCESS_READWRITE: Return 1 if the file is read and writable.
30207: ** SQLITE_ACCESS_READONLY: Return 1 if the file is readable.
30208: **
30209: ** Otherwise return 0.
30210: */
30211: static int unixAccess(
30212: sqlite3_vfs *NotUsed, /* The VFS containing this xAccess method */
30213: const char *zPath, /* Path of the file to examine */
30214: int flags, /* What do we want to learn about the zPath file? */
30215: int *pResOut /* Write result boolean here */
30216: ){
30217: int amode = 0;
30218: UNUSED_PARAMETER(NotUsed);
30219: SimulateIOError( return SQLITE_IOERR_ACCESS; );
30220: switch( flags ){
30221: case SQLITE_ACCESS_EXISTS:
30222: amode = F_OK;
30223: break;
30224: case SQLITE_ACCESS_READWRITE:
30225: amode = W_OK|R_OK;
30226: break;
30227: case SQLITE_ACCESS_READ:
30228: amode = R_OK;
30229: break;
30230:
30231: default:
30232: assert(!"Invalid flags argument");
30233: }
30234: *pResOut = (osAccess(zPath, amode)==0);
30235: if( flags==SQLITE_ACCESS_EXISTS && *pResOut ){
30236: struct stat buf;
30237: if( 0==osStat(zPath, &buf) && buf.st_size==0 ){
30238: *pResOut = 0;
30239: }
30240: }
30241: return SQLITE_OK;
30242: }
30243:
30244:
30245: /*
30246: ** Turn a relative pathname into a full pathname. The relative path
30247: ** is stored as a nul-terminated string in the buffer pointed to by
30248: ** zPath.
30249: **
30250: ** zOut points to a buffer of at least sqlite3_vfs.mxPathname bytes
30251: ** (in this case, MAX_PATHNAME bytes). The full-path is written to
30252: ** this buffer before returning.
30253: */
30254: static int unixFullPathname(
30255: sqlite3_vfs *pVfs, /* Pointer to vfs object */
30256: const char *zPath, /* Possibly relative input path */
30257: int nOut, /* Size of output buffer in bytes */
30258: char *zOut /* Output buffer */
30259: ){
30260:
30261: /* It's odd to simulate an io-error here, but really this is just
30262: ** using the io-error infrastructure to test that SQLite handles this
30263: ** function failing. This function could fail if, for example, the
30264: ** current working directory has been unlinked.
30265: */
30266: SimulateIOError( return SQLITE_ERROR );
30267:
30268: assert( pVfs->mxPathname==MAX_PATHNAME );
30269: UNUSED_PARAMETER(pVfs);
30270:
30271: zOut[nOut-1] = '\0';
30272: if( zPath[0]=='/' ){
30273: sqlite3_snprintf(nOut, zOut, "%s", zPath);
30274: }else{
30275: int nCwd;
30276: if( osGetcwd(zOut, nOut-1)==0 ){
30277: return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath);
30278: }
30279: nCwd = (int)strlen(zOut);
30280: sqlite3_snprintf(nOut-nCwd, &zOut[nCwd], "/%s", zPath);
30281: }
30282: return SQLITE_OK;
30283: }
30284:
30285:
30286: #ifndef SQLITE_OMIT_LOAD_EXTENSION
30287: /*
30288: ** Interfaces for opening a shared library, finding entry points
30289: ** within the shared library, and closing the shared library.
30290: */
30291: #include <dlfcn.h>
30292: static void *unixDlOpen(sqlite3_vfs *NotUsed, const char *zFilename){
30293: UNUSED_PARAMETER(NotUsed);
30294: return dlopen(zFilename, RTLD_NOW | RTLD_GLOBAL);
30295: }
30296:
30297: /*
30298: ** SQLite calls this function immediately after a call to unixDlSym() or
30299: ** unixDlOpen() fails (returns a null pointer). If a more detailed error
30300: ** message is available, it is written to zBufOut. If no error message
30301: ** is available, zBufOut is left unmodified and SQLite uses a default
30302: ** error message.
30303: */
30304: static void unixDlError(sqlite3_vfs *NotUsed, int nBuf, char *zBufOut){
30305: const char *zErr;
30306: UNUSED_PARAMETER(NotUsed);
30307: unixEnterMutex();
30308: zErr = dlerror();
30309: if( zErr ){
30310: sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
30311: }
30312: unixLeaveMutex();
30313: }
30314: static void (*unixDlSym(sqlite3_vfs *NotUsed, void *p, const char*zSym))(void){
30315: /*
30316: ** GCC with -pedantic-errors says that C90 does not allow a void* to be
30317: ** cast into a pointer to a function. And yet the library dlsym() routine
30318: ** returns a void* which is really a pointer to a function. So how do we
30319: ** use dlsym() with -pedantic-errors?
30320: **
30321: ** Variable x below is defined to be a pointer to a function taking
30322: ** parameters void* and const char* and returning a pointer to a function.
30323: ** We initialize x by assigning it a pointer to the dlsym() function.
30324: ** (That assignment requires a cast.) Then we call the function that
30325: ** x points to.
30326: **
30327: ** This work-around is unlikely to work correctly on any system where
30328: ** you really cannot cast a function pointer into void*. But then, on the
30329: ** other hand, dlsym() will not work on such a system either, so we have
30330: ** not really lost anything.
30331: */
30332: void (*(*x)(void*,const char*))(void);
30333: UNUSED_PARAMETER(NotUsed);
30334: x = (void(*(*)(void*,const char*))(void))dlsym;
30335: return (*x)(p, zSym);
30336: }
30337: static void unixDlClose(sqlite3_vfs *NotUsed, void *pHandle){
30338: UNUSED_PARAMETER(NotUsed);
30339: dlclose(pHandle);
30340: }
30341: #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
30342: #define unixDlOpen 0
30343: #define unixDlError 0
30344: #define unixDlSym 0
30345: #define unixDlClose 0
30346: #endif
30347:
30348: /*
30349: ** Write nBuf bytes of random data to the supplied buffer zBuf.
30350: */
30351: static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){
30352: UNUSED_PARAMETER(NotUsed);
30353: assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));
30354:
30355: /* We have to initialize zBuf to prevent valgrind from reporting
30356: ** errors. The reports issued by valgrind are incorrect - we would
30357: ** prefer that the randomness be increased by making use of the
30358: ** uninitialized space in zBuf - but valgrind errors tend to worry
30359: ** some users. Rather than argue, it seems easier just to initialize
30360: ** the whole array and silence valgrind, even if that means less randomness
30361: ** in the random seed.
30362: **
30363: ** When testing, initializing zBuf[] to zero is all we do. That means
30364: ** that we always use the same random number sequence. This makes the
30365: ** tests repeatable.
30366: */
30367: memset(zBuf, 0, nBuf);
30368: #if !defined(SQLITE_TEST)
30369: {
30370: int pid, fd;
30371: fd = robust_open("/dev/urandom", O_RDONLY, 0);
30372: if( fd<0 ){
30373: time_t t;
30374: time(&t);
30375: memcpy(zBuf, &t, sizeof(t));
30376: pid = getpid();
30377: memcpy(&zBuf[sizeof(t)], &pid, sizeof(pid));
30378: assert( sizeof(t)+sizeof(pid)<=(size_t)nBuf );
30379: nBuf = sizeof(t) + sizeof(pid);
30380: }else{
30381: do{ nBuf = osRead(fd, zBuf, nBuf); }while( nBuf<0 && errno==EINTR );
30382: robust_close(0, fd, __LINE__);
30383: }
30384: }
30385: #endif
30386: return nBuf;
30387: }
30388:
30389:
30390: /*
30391: ** Sleep for a little while. Return the amount of time slept.
30392: ** The argument is the number of microseconds we want to sleep.
30393: ** The return value is the number of microseconds of sleep actually
30394: ** requested from the underlying operating system, a number which
30395: ** might be greater than or equal to the argument, but not less
30396: ** than the argument.
30397: */
30398: static int unixSleep(sqlite3_vfs *NotUsed, int microseconds){
30399: #if OS_VXWORKS
30400: struct timespec sp;
30401:
30402: sp.tv_sec = microseconds / 1000000;
30403: sp.tv_nsec = (microseconds % 1000000) * 1000;
30404: nanosleep(&sp, NULL);
30405: UNUSED_PARAMETER(NotUsed);
30406: return microseconds;
30407: #elif defined(HAVE_USLEEP) && HAVE_USLEEP
30408: usleep(microseconds);
30409: UNUSED_PARAMETER(NotUsed);
30410: return microseconds;
30411: #else
30412: int seconds = (microseconds+999999)/1000000;
30413: sleep(seconds);
30414: UNUSED_PARAMETER(NotUsed);
30415: return seconds*1000000;
30416: #endif
30417: }
30418:
30419: /*
30420: ** The following variable, if set to a non-zero value, is interpreted as
30421: ** the number of seconds since 1970 and is used to set the result of
30422: ** sqlite3OsCurrentTime() during testing.
30423: */
30424: #ifdef SQLITE_TEST
30425: SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
30426: #endif
30427:
30428: /*
30429: ** Find the current time (in Universal Coordinated Time). Write into *piNow
30430: ** the current time and date as a Julian Day number times 86_400_000. In
30431: ** other words, write into *piNow the number of milliseconds since the Julian
30432: ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
30433: ** proleptic Gregorian calendar.
30434: **
30435: ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
30436: ** cannot be found.
30437: */
30438: static int unixCurrentTimeInt64(sqlite3_vfs *NotUsed, sqlite3_int64 *piNow){
30439: static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
30440: int rc = SQLITE_OK;
30441: #if defined(NO_GETTOD)
30442: time_t t;
30443: time(&t);
30444: *piNow = ((sqlite3_int64)t)*1000 + unixEpoch;
30445: #elif OS_VXWORKS
30446: struct timespec sNow;
30447: clock_gettime(CLOCK_REALTIME, &sNow);
30448: *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_nsec/1000000;
30449: #else
30450: struct timeval sNow;
30451: if( gettimeofday(&sNow, 0)==0 ){
30452: *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_usec/1000;
30453: }else{
30454: rc = SQLITE_ERROR;
30455: }
30456: #endif
30457:
30458: #ifdef SQLITE_TEST
30459: if( sqlite3_current_time ){
30460: *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
30461: }
30462: #endif
30463: UNUSED_PARAMETER(NotUsed);
30464: return rc;
30465: }
30466:
30467: /*
30468: ** Find the current time (in Universal Coordinated Time). Write the
30469: ** current time and date as a Julian Day number into *prNow and
30470: ** return 0. Return 1 if the time and date cannot be found.
30471: */
30472: static int unixCurrentTime(sqlite3_vfs *NotUsed, double *prNow){
30473: sqlite3_int64 i = 0;
30474: int rc;
30475: UNUSED_PARAMETER(NotUsed);
30476: rc = unixCurrentTimeInt64(0, &i);
30477: *prNow = i/86400000.0;
30478: return rc;
30479: }
30480:
30481: /*
30482: ** We added the xGetLastError() method with the intention of providing
30483: ** better low-level error messages when operating-system problems come up
30484: ** during SQLite operation. But so far, none of that has been implemented
30485: ** in the core. So this routine is never called. For now, it is merely
30486: ** a place-holder.
30487: */
30488: static int unixGetLastError(sqlite3_vfs *NotUsed, int NotUsed2, char *NotUsed3){
30489: UNUSED_PARAMETER(NotUsed);
30490: UNUSED_PARAMETER(NotUsed2);
30491: UNUSED_PARAMETER(NotUsed3);
30492: return 0;
30493: }
30494:
30495:
30496: /*
30497: ************************ End of sqlite3_vfs methods ***************************
30498: ******************************************************************************/
30499:
30500: /******************************************************************************
30501: ************************** Begin Proxy Locking ********************************
30502: **
30503: ** Proxy locking is a "uber-locking-method" in this sense: It uses the
30504: ** other locking methods on secondary lock files. Proxy locking is a
30505: ** meta-layer over top of the primitive locking implemented above. For
30506: ** this reason, the division that implements of proxy locking is deferred
30507: ** until late in the file (here) after all of the other I/O methods have
30508: ** been defined - so that the primitive locking methods are available
30509: ** as services to help with the implementation of proxy locking.
30510: **
30511: ****
30512: **
30513: ** The default locking schemes in SQLite use byte-range locks on the
30514: ** database file to coordinate safe, concurrent access by multiple readers
30515: ** and writers [http://sqlite.org/lockingv3.html]. The five file locking
30516: ** states (UNLOCKED, PENDING, SHARED, RESERVED, EXCLUSIVE) are implemented
30517: ** as POSIX read & write locks over fixed set of locations (via fsctl),
30518: ** on AFP and SMB only exclusive byte-range locks are available via fsctl
30519: ** with _IOWR('z', 23, struct ByteRangeLockPB2) to track the same 5 states.
30520: ** To simulate a F_RDLCK on the shared range, on AFP a randomly selected
30521: ** address in the shared range is taken for a SHARED lock, the entire
30522: ** shared range is taken for an EXCLUSIVE lock):
30523: **
30524: ** PENDING_BYTE 0x40000000
30525: ** RESERVED_BYTE 0x40000001
30526: ** SHARED_RANGE 0x40000002 -> 0x40000200
30527: **
30528: ** This works well on the local file system, but shows a nearly 100x
30529: ** slowdown in read performance on AFP because the AFP client disables
30530: ** the read cache when byte-range locks are present. Enabling the read
30531: ** cache exposes a cache coherency problem that is present on all OS X
30532: ** supported network file systems. NFS and AFP both observe the
30533: ** close-to-open semantics for ensuring cache coherency
30534: ** [http://nfs.sourceforge.net/#faq_a8], which does not effectively
30535: ** address the requirements for concurrent database access by multiple
30536: ** readers and writers
30537: ** [http://www.nabble.com/SQLite-on-NFS-cache-coherency-td15655701.html].
30538: **
30539: ** To address the performance and cache coherency issues, proxy file locking
30540: ** changes the way database access is controlled by limiting access to a
30541: ** single host at a time and moving file locks off of the database file
30542: ** and onto a proxy file on the local file system.
30543: **
30544: **
30545: ** Using proxy locks
30546: ** -----------------
30547: **
30548: ** C APIs
30549: **
30550: ** sqlite3_file_control(db, dbname, SQLITE_SET_LOCKPROXYFILE,
30551: ** <proxy_path> | ":auto:");
30552: ** sqlite3_file_control(db, dbname, SQLITE_GET_LOCKPROXYFILE, &<proxy_path>);
30553: **
30554: **
30555: ** SQL pragmas
30556: **
30557: ** PRAGMA [database.]lock_proxy_file=<proxy_path> | :auto:
30558: ** PRAGMA [database.]lock_proxy_file
30559: **
30560: ** Specifying ":auto:" means that if there is a conch file with a matching
30561: ** host ID in it, the proxy path in the conch file will be used, otherwise
30562: ** a proxy path based on the user's temp dir
30563: ** (via confstr(_CS_DARWIN_USER_TEMP_DIR,...)) will be used and the
30564: ** actual proxy file name is generated from the name and path of the
30565: ** database file. For example:
30566: **
30567: ** For database path "/Users/me/foo.db"
30568: ** The lock path will be "<tmpdir>/sqliteplocks/_Users_me_foo.db:auto:")
30569: **
30570: ** Once a lock proxy is configured for a database connection, it can not
30571: ** be removed, however it may be switched to a different proxy path via
30572: ** the above APIs (assuming the conch file is not being held by another
30573: ** connection or process).
30574: **
30575: **
30576: ** How proxy locking works
30577: ** -----------------------
30578: **
30579: ** Proxy file locking relies primarily on two new supporting files:
30580: **
30581: ** * conch file to limit access to the database file to a single host
30582: ** at a time
30583: **
30584: ** * proxy file to act as a proxy for the advisory locks normally
30585: ** taken on the database
30586: **
30587: ** The conch file - to use a proxy file, sqlite must first "hold the conch"
30588: ** by taking an sqlite-style shared lock on the conch file, reading the
30589: ** contents and comparing the host's unique host ID (see below) and lock
30590: ** proxy path against the values stored in the conch. The conch file is
30591: ** stored in the same directory as the database file and the file name
30592: ** is patterned after the database file name as ".<databasename>-conch".
30593: ** If the conch file does not exist, or it's contents do not match the
30594: ** host ID and/or proxy path, then the lock is escalated to an exclusive
30595: ** lock and the conch file contents is updated with the host ID and proxy
30596: ** path and the lock is downgraded to a shared lock again. If the conch
30597: ** is held by another process (with a shared lock), the exclusive lock
30598: ** will fail and SQLITE_BUSY is returned.
30599: **
30600: ** The proxy file - a single-byte file used for all advisory file locks
30601: ** normally taken on the database file. This allows for safe sharing
30602: ** of the database file for multiple readers and writers on the same
30603: ** host (the conch ensures that they all use the same local lock file).
30604: **
30605: ** Requesting the lock proxy does not immediately take the conch, it is
30606: ** only taken when the first request to lock database file is made.
30607: ** This matches the semantics of the traditional locking behavior, where
30608: ** opening a connection to a database file does not take a lock on it.
30609: ** The shared lock and an open file descriptor are maintained until
30610: ** the connection to the database is closed.
30611: **
30612: ** The proxy file and the lock file are never deleted so they only need
30613: ** to be created the first time they are used.
30614: **
30615: ** Configuration options
30616: ** ---------------------
30617: **
30618: ** SQLITE_PREFER_PROXY_LOCKING
30619: **
30620: ** Database files accessed on non-local file systems are
30621: ** automatically configured for proxy locking, lock files are
30622: ** named automatically using the same logic as
30623: ** PRAGMA lock_proxy_file=":auto:"
30624: **
30625: ** SQLITE_PROXY_DEBUG
30626: **
30627: ** Enables the logging of error messages during host id file
30628: ** retrieval and creation
30629: **
30630: ** LOCKPROXYDIR
30631: **
30632: ** Overrides the default directory used for lock proxy files that
30633: ** are named automatically via the ":auto:" setting
30634: **
30635: ** SQLITE_DEFAULT_PROXYDIR_PERMISSIONS
30636: **
30637: ** Permissions to use when creating a directory for storing the
30638: ** lock proxy files, only used when LOCKPROXYDIR is not set.
30639: **
30640: **
30641: ** As mentioned above, when compiled with SQLITE_PREFER_PROXY_LOCKING,
30642: ** setting the environment variable SQLITE_FORCE_PROXY_LOCKING to 1 will
30643: ** force proxy locking to be used for every database file opened, and 0
30644: ** will force automatic proxy locking to be disabled for all database
30645: ** files (explicity calling the SQLITE_SET_LOCKPROXYFILE pragma or
30646: ** sqlite_file_control API is not affected by SQLITE_FORCE_PROXY_LOCKING).
30647: */
30648:
30649: /*
30650: ** Proxy locking is only available on MacOSX
30651: */
30652: #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE
30653:
30654: /*
30655: ** The proxyLockingContext has the path and file structures for the remote
30656: ** and local proxy files in it
30657: */
30658: typedef struct proxyLockingContext proxyLockingContext;
30659: struct proxyLockingContext {
30660: unixFile *conchFile; /* Open conch file */
30661: char *conchFilePath; /* Name of the conch file */
30662: unixFile *lockProxy; /* Open proxy lock file */
30663: char *lockProxyPath; /* Name of the proxy lock file */
30664: char *dbPath; /* Name of the open file */
30665: int conchHeld; /* 1 if the conch is held, -1 if lockless */
30666: void *oldLockingContext; /* Original lockingcontext to restore on close */
30667: sqlite3_io_methods const *pOldMethod; /* Original I/O methods for close */
30668: };
30669:
30670: /*
30671: ** The proxy lock file path for the database at dbPath is written into lPath,
30672: ** which must point to valid, writable memory large enough for a maxLen length
30673: ** file path.
30674: */
30675: static int proxyGetLockPath(const char *dbPath, char *lPath, size_t maxLen){
30676: int len;
30677: int dbLen;
30678: int i;
30679:
30680: #ifdef LOCKPROXYDIR
30681: len = strlcpy(lPath, LOCKPROXYDIR, maxLen);
30682: #else
30683: # ifdef _CS_DARWIN_USER_TEMP_DIR
30684: {
30685: if( !confstr(_CS_DARWIN_USER_TEMP_DIR, lPath, maxLen) ){
30686: OSTRACE(("GETLOCKPATH failed %s errno=%d pid=%d\n",
30687: lPath, errno, getpid()));
30688: return SQLITE_IOERR_LOCK;
30689: }
30690: len = strlcat(lPath, "sqliteplocks", maxLen);
30691: }
30692: # else
30693: len = strlcpy(lPath, "/tmp/", maxLen);
30694: # endif
30695: #endif
30696:
30697: if( lPath[len-1]!='/' ){
30698: len = strlcat(lPath, "/", maxLen);
30699: }
30700:
30701: /* transform the db path to a unique cache name */
30702: dbLen = (int)strlen(dbPath);
30703: for( i=0; i<dbLen && (i+len+7)<(int)maxLen; i++){
30704: char c = dbPath[i];
30705: lPath[i+len] = (c=='/')?'_':c;
30706: }
30707: lPath[i+len]='\0';
30708: strlcat(lPath, ":auto:", maxLen);
30709: OSTRACE(("GETLOCKPATH proxy lock path=%s pid=%d\n", lPath, getpid()));
30710: return SQLITE_OK;
30711: }
30712:
30713: /*
30714: ** Creates the lock file and any missing directories in lockPath
30715: */
30716: static int proxyCreateLockPath(const char *lockPath){
30717: int i, len;
30718: char buf[MAXPATHLEN];
30719: int start = 0;
30720:
30721: assert(lockPath!=NULL);
30722: /* try to create all the intermediate directories */
30723: len = (int)strlen(lockPath);
30724: buf[0] = lockPath[0];
30725: for( i=1; i<len; i++ ){
30726: if( lockPath[i] == '/' && (i - start > 0) ){
30727: /* only mkdir if leaf dir != "." or "/" or ".." */
30728: if( i-start>2 || (i-start==1 && buf[start] != '.' && buf[start] != '/')
30729: || (i-start==2 && buf[start] != '.' && buf[start+1] != '.') ){
30730: buf[i]='\0';
30731: if( osMkdir(buf, SQLITE_DEFAULT_PROXYDIR_PERMISSIONS) ){
30732: int err=errno;
30733: if( err!=EEXIST ) {
30734: OSTRACE(("CREATELOCKPATH FAILED creating %s, "
30735: "'%s' proxy lock path=%s pid=%d\n",
30736: buf, strerror(err), lockPath, getpid()));
30737: return err;
30738: }
30739: }
30740: }
30741: start=i+1;
30742: }
30743: buf[i] = lockPath[i];
30744: }
30745: OSTRACE(("CREATELOCKPATH proxy lock path=%s pid=%d\n", lockPath, getpid()));
30746: return 0;
30747: }
30748:
30749: /*
30750: ** Create a new VFS file descriptor (stored in memory obtained from
30751: ** sqlite3_malloc) and open the file named "path" in the file descriptor.
30752: **
30753: ** The caller is responsible not only for closing the file descriptor
30754: ** but also for freeing the memory associated with the file descriptor.
30755: */
30756: static int proxyCreateUnixFile(
30757: const char *path, /* path for the new unixFile */
30758: unixFile **ppFile, /* unixFile created and returned by ref */
30759: int islockfile /* if non zero missing dirs will be created */
30760: ) {
30761: int fd = -1;
30762: unixFile *pNew;
30763: int rc = SQLITE_OK;
30764: int openFlags = O_RDWR | O_CREAT;
30765: sqlite3_vfs dummyVfs;
30766: int terrno = 0;
30767: UnixUnusedFd *pUnused = NULL;
30768:
30769: /* 1. first try to open/create the file
30770: ** 2. if that fails, and this is a lock file (not-conch), try creating
30771: ** the parent directories and then try again.
30772: ** 3. if that fails, try to open the file read-only
30773: ** otherwise return BUSY (if lock file) or CANTOPEN for the conch file
30774: */
30775: pUnused = findReusableFd(path, openFlags);
30776: if( pUnused ){
30777: fd = pUnused->fd;
30778: }else{
30779: pUnused = sqlite3_malloc(sizeof(*pUnused));
30780: if( !pUnused ){
30781: return SQLITE_NOMEM;
30782: }
30783: }
30784: if( fd<0 ){
30785: fd = robust_open(path, openFlags, SQLITE_DEFAULT_FILE_PERMISSIONS);
30786: terrno = errno;
30787: if( fd<0 && errno==ENOENT && islockfile ){
30788: if( proxyCreateLockPath(path) == SQLITE_OK ){
30789: fd = robust_open(path, openFlags, SQLITE_DEFAULT_FILE_PERMISSIONS);
30790: }
30791: }
30792: }
30793: if( fd<0 ){
30794: openFlags = O_RDONLY;
30795: fd = robust_open(path, openFlags, SQLITE_DEFAULT_FILE_PERMISSIONS);
30796: terrno = errno;
30797: }
30798: if( fd<0 ){
30799: if( islockfile ){
30800: return SQLITE_BUSY;
30801: }
30802: switch (terrno) {
30803: case EACCES:
30804: return SQLITE_PERM;
30805: case EIO:
30806: return SQLITE_IOERR_LOCK; /* even though it is the conch */
30807: default:
30808: return SQLITE_CANTOPEN_BKPT;
30809: }
30810: }
30811:
30812: pNew = (unixFile *)sqlite3_malloc(sizeof(*pNew));
30813: if( pNew==NULL ){
30814: rc = SQLITE_NOMEM;
30815: goto end_create_proxy;
30816: }
30817: memset(pNew, 0, sizeof(unixFile));
30818: pNew->openFlags = openFlags;
30819: memset(&dummyVfs, 0, sizeof(dummyVfs));
30820: dummyVfs.pAppData = (void*)&autolockIoFinder;
30821: dummyVfs.zName = "dummy";
30822: pUnused->fd = fd;
30823: pUnused->flags = openFlags;
30824: pNew->pUnused = pUnused;
30825:
30826: rc = fillInUnixFile(&dummyVfs, fd, (sqlite3_file*)pNew, path, 0);
30827: if( rc==SQLITE_OK ){
30828: *ppFile = pNew;
30829: return SQLITE_OK;
30830: }
30831: end_create_proxy:
30832: robust_close(pNew, fd, __LINE__);
30833: sqlite3_free(pNew);
30834: sqlite3_free(pUnused);
30835: return rc;
30836: }
30837:
30838: #ifdef SQLITE_TEST
30839: /* simulate multiple hosts by creating unique hostid file paths */
30840: SQLITE_API int sqlite3_hostid_num = 0;
30841: #endif
30842:
30843: #define PROXY_HOSTIDLEN 16 /* conch file host id length */
30844:
30845: /* Not always defined in the headers as it ought to be */
30846: extern int gethostuuid(uuid_t id, const struct timespec *wait);
30847:
30848: /* get the host ID via gethostuuid(), pHostID must point to PROXY_HOSTIDLEN
30849: ** bytes of writable memory.
30850: */
30851: static int proxyGetHostID(unsigned char *pHostID, int *pError){
30852: assert(PROXY_HOSTIDLEN == sizeof(uuid_t));
30853: memset(pHostID, 0, PROXY_HOSTIDLEN);
30854: #if defined(__MAX_OS_X_VERSION_MIN_REQUIRED)\
30855: && __MAC_OS_X_VERSION_MIN_REQUIRED<1050
30856: {
30857: static const struct timespec timeout = {1, 0}; /* 1 sec timeout */
30858: if( gethostuuid(pHostID, &timeout) ){
30859: int err = errno;
30860: if( pError ){
30861: *pError = err;
30862: }
30863: return SQLITE_IOERR;
30864: }
30865: }
30866: #else
30867: UNUSED_PARAMETER(pError);
30868: #endif
30869: #ifdef SQLITE_TEST
30870: /* simulate multiple hosts by creating unique hostid file paths */
30871: if( sqlite3_hostid_num != 0){
30872: pHostID[0] = (char)(pHostID[0] + (char)(sqlite3_hostid_num & 0xFF));
30873: }
30874: #endif
30875:
30876: return SQLITE_OK;
30877: }
30878:
30879: /* The conch file contains the header, host id and lock file path
30880: */
30881: #define PROXY_CONCHVERSION 2 /* 1-byte header, 16-byte host id, path */
30882: #define PROXY_HEADERLEN 1 /* conch file header length */
30883: #define PROXY_PATHINDEX (PROXY_HEADERLEN+PROXY_HOSTIDLEN)
30884: #define PROXY_MAXCONCHLEN (PROXY_HEADERLEN+PROXY_HOSTIDLEN+MAXPATHLEN)
30885:
30886: /*
30887: ** Takes an open conch file, copies the contents to a new path and then moves
30888: ** it back. The newly created file's file descriptor is assigned to the
30889: ** conch file structure and finally the original conch file descriptor is
30890: ** closed. Returns zero if successful.
30891: */
30892: static int proxyBreakConchLock(unixFile *pFile, uuid_t myHostID){
30893: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
30894: unixFile *conchFile = pCtx->conchFile;
30895: char tPath[MAXPATHLEN];
30896: char buf[PROXY_MAXCONCHLEN];
30897: char *cPath = pCtx->conchFilePath;
30898: size_t readLen = 0;
30899: size_t pathLen = 0;
30900: char errmsg[64] = "";
30901: int fd = -1;
30902: int rc = -1;
30903: UNUSED_PARAMETER(myHostID);
30904:
30905: /* create a new path by replace the trailing '-conch' with '-break' */
30906: pathLen = strlcpy(tPath, cPath, MAXPATHLEN);
30907: if( pathLen>MAXPATHLEN || pathLen<6 ||
30908: (strlcpy(&tPath[pathLen-5], "break", 6) != 5) ){
30909: sqlite3_snprintf(sizeof(errmsg),errmsg,"path error (len %d)",(int)pathLen);
30910: goto end_breaklock;
30911: }
30912: /* read the conch content */
30913: readLen = osPread(conchFile->h, buf, PROXY_MAXCONCHLEN, 0);
30914: if( readLen<PROXY_PATHINDEX ){
30915: sqlite3_snprintf(sizeof(errmsg),errmsg,"read error (len %d)",(int)readLen);
30916: goto end_breaklock;
30917: }
30918: /* write it out to the temporary break file */
30919: fd = robust_open(tPath, (O_RDWR|O_CREAT|O_EXCL),
30920: SQLITE_DEFAULT_FILE_PERMISSIONS);
30921: if( fd<0 ){
30922: sqlite3_snprintf(sizeof(errmsg), errmsg, "create failed (%d)", errno);
30923: goto end_breaklock;
30924: }
30925: if( osPwrite(fd, buf, readLen, 0) != (ssize_t)readLen ){
30926: sqlite3_snprintf(sizeof(errmsg), errmsg, "write failed (%d)", errno);
30927: goto end_breaklock;
30928: }
30929: if( rename(tPath, cPath) ){
30930: sqlite3_snprintf(sizeof(errmsg), errmsg, "rename failed (%d)", errno);
30931: goto end_breaklock;
30932: }
30933: rc = 0;
30934: fprintf(stderr, "broke stale lock on %s\n", cPath);
30935: robust_close(pFile, conchFile->h, __LINE__);
30936: conchFile->h = fd;
30937: conchFile->openFlags = O_RDWR | O_CREAT;
30938:
30939: end_breaklock:
30940: if( rc ){
30941: if( fd>=0 ){
30942: osUnlink(tPath);
30943: robust_close(pFile, fd, __LINE__);
30944: }
30945: fprintf(stderr, "failed to break stale lock on %s, %s\n", cPath, errmsg);
30946: }
30947: return rc;
30948: }
30949:
30950: /* Take the requested lock on the conch file and break a stale lock if the
30951: ** host id matches.
30952: */
30953: static int proxyConchLock(unixFile *pFile, uuid_t myHostID, int lockType){
30954: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
30955: unixFile *conchFile = pCtx->conchFile;
30956: int rc = SQLITE_OK;
30957: int nTries = 0;
30958: struct timespec conchModTime;
30959:
30960: memset(&conchModTime, 0, sizeof(conchModTime));
30961: do {
30962: rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType);
30963: nTries ++;
30964: if( rc==SQLITE_BUSY ){
30965: /* If the lock failed (busy):
30966: * 1st try: get the mod time of the conch, wait 0.5s and try again.
30967: * 2nd try: fail if the mod time changed or host id is different, wait
30968: * 10 sec and try again
30969: * 3rd try: break the lock unless the mod time has changed.
30970: */
30971: struct stat buf;
30972: if( osFstat(conchFile->h, &buf) ){
30973: pFile->lastErrno = errno;
30974: return SQLITE_IOERR_LOCK;
30975: }
30976:
30977: if( nTries==1 ){
30978: conchModTime = buf.st_mtimespec;
30979: usleep(500000); /* wait 0.5 sec and try the lock again*/
30980: continue;
30981: }
30982:
30983: assert( nTries>1 );
30984: if( conchModTime.tv_sec != buf.st_mtimespec.tv_sec ||
30985: conchModTime.tv_nsec != buf.st_mtimespec.tv_nsec ){
30986: return SQLITE_BUSY;
30987: }
30988:
30989: if( nTries==2 ){
30990: char tBuf[PROXY_MAXCONCHLEN];
30991: int len = osPread(conchFile->h, tBuf, PROXY_MAXCONCHLEN, 0);
30992: if( len<0 ){
30993: pFile->lastErrno = errno;
30994: return SQLITE_IOERR_LOCK;
30995: }
30996: if( len>PROXY_PATHINDEX && tBuf[0]==(char)PROXY_CONCHVERSION){
30997: /* don't break the lock if the host id doesn't match */
30998: if( 0!=memcmp(&tBuf[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN) ){
30999: return SQLITE_BUSY;
31000: }
31001: }else{
31002: /* don't break the lock on short read or a version mismatch */
31003: return SQLITE_BUSY;
31004: }
31005: usleep(10000000); /* wait 10 sec and try the lock again */
31006: continue;
31007: }
31008:
31009: assert( nTries==3 );
31010: if( 0==proxyBreakConchLock(pFile, myHostID) ){
31011: rc = SQLITE_OK;
31012: if( lockType==EXCLUSIVE_LOCK ){
31013: rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, SHARED_LOCK);
31014: }
31015: if( !rc ){
31016: rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, lockType);
31017: }
31018: }
31019: }
31020: } while( rc==SQLITE_BUSY && nTries<3 );
31021:
31022: return rc;
31023: }
31024:
31025: /* Takes the conch by taking a shared lock and read the contents conch, if
31026: ** lockPath is non-NULL, the host ID and lock file path must match. A NULL
31027: ** lockPath means that the lockPath in the conch file will be used if the
31028: ** host IDs match, or a new lock path will be generated automatically
31029: ** and written to the conch file.
31030: */
31031: static int proxyTakeConch(unixFile *pFile){
31032: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31033:
31034: if( pCtx->conchHeld!=0 ){
31035: return SQLITE_OK;
31036: }else{
31037: unixFile *conchFile = pCtx->conchFile;
31038: uuid_t myHostID;
31039: int pError = 0;
31040: char readBuf[PROXY_MAXCONCHLEN];
31041: char lockPath[MAXPATHLEN];
31042: char *tempLockPath = NULL;
31043: int rc = SQLITE_OK;
31044: int createConch = 0;
31045: int hostIdMatch = 0;
31046: int readLen = 0;
31047: int tryOldLockPath = 0;
31048: int forceNewLockPath = 0;
31049:
31050: OSTRACE(("TAKECONCH %d for %s pid=%d\n", conchFile->h,
31051: (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"), getpid()));
31052:
31053: rc = proxyGetHostID(myHostID, &pError);
31054: if( (rc&0xff)==SQLITE_IOERR ){
31055: pFile->lastErrno = pError;
31056: goto end_takeconch;
31057: }
31058: rc = proxyConchLock(pFile, myHostID, SHARED_LOCK);
31059: if( rc!=SQLITE_OK ){
31060: goto end_takeconch;
31061: }
31062: /* read the existing conch file */
31063: readLen = seekAndRead((unixFile*)conchFile, 0, readBuf, PROXY_MAXCONCHLEN);
31064: if( readLen<0 ){
31065: /* I/O error: lastErrno set by seekAndRead */
31066: pFile->lastErrno = conchFile->lastErrno;
31067: rc = SQLITE_IOERR_READ;
31068: goto end_takeconch;
31069: }else if( readLen<=(PROXY_HEADERLEN+PROXY_HOSTIDLEN) ||
31070: readBuf[0]!=(char)PROXY_CONCHVERSION ){
31071: /* a short read or version format mismatch means we need to create a new
31072: ** conch file.
31073: */
31074: createConch = 1;
31075: }
31076: /* if the host id matches and the lock path already exists in the conch
31077: ** we'll try to use the path there, if we can't open that path, we'll
31078: ** retry with a new auto-generated path
31079: */
31080: do { /* in case we need to try again for an :auto: named lock file */
31081:
31082: if( !createConch && !forceNewLockPath ){
31083: hostIdMatch = !memcmp(&readBuf[PROXY_HEADERLEN], myHostID,
31084: PROXY_HOSTIDLEN);
31085: /* if the conch has data compare the contents */
31086: if( !pCtx->lockProxyPath ){
31087: /* for auto-named local lock file, just check the host ID and we'll
31088: ** use the local lock file path that's already in there
31089: */
31090: if( hostIdMatch ){
31091: size_t pathLen = (readLen - PROXY_PATHINDEX);
31092:
31093: if( pathLen>=MAXPATHLEN ){
31094: pathLen=MAXPATHLEN-1;
31095: }
31096: memcpy(lockPath, &readBuf[PROXY_PATHINDEX], pathLen);
31097: lockPath[pathLen] = 0;
31098: tempLockPath = lockPath;
31099: tryOldLockPath = 1;
31100: /* create a copy of the lock path if the conch is taken */
31101: goto end_takeconch;
31102: }
31103: }else if( hostIdMatch
31104: && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX],
31105: readLen-PROXY_PATHINDEX)
31106: ){
31107: /* conch host and lock path match */
31108: goto end_takeconch;
31109: }
31110: }
31111:
31112: /* if the conch isn't writable and doesn't match, we can't take it */
31113: if( (conchFile->openFlags&O_RDWR) == 0 ){
31114: rc = SQLITE_BUSY;
31115: goto end_takeconch;
31116: }
31117:
31118: /* either the conch didn't match or we need to create a new one */
31119: if( !pCtx->lockProxyPath ){
31120: proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN);
31121: tempLockPath = lockPath;
31122: /* create a copy of the lock path _only_ if the conch is taken */
31123: }
31124:
31125: /* update conch with host and path (this will fail if other process
31126: ** has a shared lock already), if the host id matches, use the big
31127: ** stick.
31128: */
31129: futimes(conchFile->h, NULL);
31130: if( hostIdMatch && !createConch ){
31131: if( conchFile->pInode && conchFile->pInode->nShared>1 ){
31132: /* We are trying for an exclusive lock but another thread in this
31133: ** same process is still holding a shared lock. */
31134: rc = SQLITE_BUSY;
31135: } else {
31136: rc = proxyConchLock(pFile, myHostID, EXCLUSIVE_LOCK);
31137: }
31138: }else{
31139: rc = conchFile->pMethod->xLock((sqlite3_file*)conchFile, EXCLUSIVE_LOCK);
31140: }
31141: if( rc==SQLITE_OK ){
31142: char writeBuffer[PROXY_MAXCONCHLEN];
31143: int writeSize = 0;
31144:
31145: writeBuffer[0] = (char)PROXY_CONCHVERSION;
31146: memcpy(&writeBuffer[PROXY_HEADERLEN], myHostID, PROXY_HOSTIDLEN);
31147: if( pCtx->lockProxyPath!=NULL ){
31148: strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath, MAXPATHLEN);
31149: }else{
31150: strlcpy(&writeBuffer[PROXY_PATHINDEX], tempLockPath, MAXPATHLEN);
31151: }
31152: writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]);
31153: robust_ftruncate(conchFile->h, writeSize);
31154: rc = unixWrite((sqlite3_file *)conchFile, writeBuffer, writeSize, 0);
31155: fsync(conchFile->h);
31156: /* If we created a new conch file (not just updated the contents of a
31157: ** valid conch file), try to match the permissions of the database
31158: */
31159: if( rc==SQLITE_OK && createConch ){
31160: struct stat buf;
31161: int err = osFstat(pFile->h, &buf);
31162: if( err==0 ){
31163: mode_t cmode = buf.st_mode&(S_IRUSR|S_IWUSR | S_IRGRP|S_IWGRP |
31164: S_IROTH|S_IWOTH);
31165: /* try to match the database file R/W permissions, ignore failure */
31166: #ifndef SQLITE_PROXY_DEBUG
31167: osFchmod(conchFile->h, cmode);
31168: #else
31169: do{
31170: rc = osFchmod(conchFile->h, cmode);
31171: }while( rc==(-1) && errno==EINTR );
31172: if( rc!=0 ){
31173: int code = errno;
31174: fprintf(stderr, "fchmod %o FAILED with %d %s\n",
31175: cmode, code, strerror(code));
31176: } else {
31177: fprintf(stderr, "fchmod %o SUCCEDED\n",cmode);
31178: }
31179: }else{
31180: int code = errno;
31181: fprintf(stderr, "STAT FAILED[%d] with %d %s\n",
31182: err, code, strerror(code));
31183: #endif
31184: }
31185: }
31186: }
31187: conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, SHARED_LOCK);
31188:
31189: end_takeconch:
31190: OSTRACE(("TRANSPROXY: CLOSE %d\n", pFile->h));
31191: if( rc==SQLITE_OK && pFile->openFlags ){
31192: int fd;
31193: if( pFile->h>=0 ){
31194: robust_close(pFile, pFile->h, __LINE__);
31195: }
31196: pFile->h = -1;
31197: fd = robust_open(pCtx->dbPath, pFile->openFlags,
31198: SQLITE_DEFAULT_FILE_PERMISSIONS);
31199: OSTRACE(("TRANSPROXY: OPEN %d\n", fd));
31200: if( fd>=0 ){
31201: pFile->h = fd;
31202: }else{
31203: rc=SQLITE_CANTOPEN_BKPT; /* SQLITE_BUSY? proxyTakeConch called
31204: during locking */
31205: }
31206: }
31207: if( rc==SQLITE_OK && !pCtx->lockProxy ){
31208: char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath;
31209: rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1);
31210: if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM && tryOldLockPath ){
31211: /* we couldn't create the proxy lock file with the old lock file path
31212: ** so try again via auto-naming
31213: */
31214: forceNewLockPath = 1;
31215: tryOldLockPath = 0;
31216: continue; /* go back to the do {} while start point, try again */
31217: }
31218: }
31219: if( rc==SQLITE_OK ){
31220: /* Need to make a copy of path if we extracted the value
31221: ** from the conch file or the path was allocated on the stack
31222: */
31223: if( tempLockPath ){
31224: pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath);
31225: if( !pCtx->lockProxyPath ){
31226: rc = SQLITE_NOMEM;
31227: }
31228: }
31229: }
31230: if( rc==SQLITE_OK ){
31231: pCtx->conchHeld = 1;
31232:
31233: if( pCtx->lockProxy->pMethod == &afpIoMethods ){
31234: afpLockingContext *afpCtx;
31235: afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext;
31236: afpCtx->dbPath = pCtx->lockProxyPath;
31237: }
31238: } else {
31239: conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK);
31240: }
31241: OSTRACE(("TAKECONCH %d %s\n", conchFile->h,
31242: rc==SQLITE_OK?"ok":"failed"));
31243: return rc;
31244: } while (1); /* in case we need to retry the :auto: lock file -
31245: ** we should never get here except via the 'continue' call. */
31246: }
31247: }
31248:
31249: /*
31250: ** If pFile holds a lock on a conch file, then release that lock.
31251: */
31252: static int proxyReleaseConch(unixFile *pFile){
31253: int rc = SQLITE_OK; /* Subroutine return code */
31254: proxyLockingContext *pCtx; /* The locking context for the proxy lock */
31255: unixFile *conchFile; /* Name of the conch file */
31256:
31257: pCtx = (proxyLockingContext *)pFile->lockingContext;
31258: conchFile = pCtx->conchFile;
31259: OSTRACE(("RELEASECONCH %d for %s pid=%d\n", conchFile->h,
31260: (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
31261: getpid()));
31262: if( pCtx->conchHeld>0 ){
31263: rc = conchFile->pMethod->xUnlock((sqlite3_file*)conchFile, NO_LOCK);
31264: }
31265: pCtx->conchHeld = 0;
31266: OSTRACE(("RELEASECONCH %d %s\n", conchFile->h,
31267: (rc==SQLITE_OK ? "ok" : "failed")));
31268: return rc;
31269: }
31270:
31271: /*
31272: ** Given the name of a database file, compute the name of its conch file.
31273: ** Store the conch filename in memory obtained from sqlite3_malloc().
31274: ** Make *pConchPath point to the new name. Return SQLITE_OK on success
31275: ** or SQLITE_NOMEM if unable to obtain memory.
31276: **
31277: ** The caller is responsible for ensuring that the allocated memory
31278: ** space is eventually freed.
31279: **
31280: ** *pConchPath is set to NULL if a memory allocation error occurs.
31281: */
31282: static int proxyCreateConchPathname(char *dbPath, char **pConchPath){
31283: int i; /* Loop counter */
31284: int len = (int)strlen(dbPath); /* Length of database filename - dbPath */
31285: char *conchPath; /* buffer in which to construct conch name */
31286:
31287: /* Allocate space for the conch filename and initialize the name to
31288: ** the name of the original database file. */
31289: *pConchPath = conchPath = (char *)sqlite3_malloc(len + 8);
31290: if( conchPath==0 ){
31291: return SQLITE_NOMEM;
31292: }
31293: memcpy(conchPath, dbPath, len+1);
31294:
31295: /* now insert a "." before the last / character */
31296: for( i=(len-1); i>=0; i-- ){
31297: if( conchPath[i]=='/' ){
31298: i++;
31299: break;
31300: }
31301: }
31302: conchPath[i]='.';
31303: while ( i<len ){
31304: conchPath[i+1]=dbPath[i];
31305: i++;
31306: }
31307:
31308: /* append the "-conch" suffix to the file */
31309: memcpy(&conchPath[i+1], "-conch", 7);
31310: assert( (int)strlen(conchPath) == len+7 );
31311:
31312: return SQLITE_OK;
31313: }
31314:
31315:
31316: /* Takes a fully configured proxy locking-style unix file and switches
31317: ** the local lock file path
31318: */
31319: static int switchLockProxyPath(unixFile *pFile, const char *path) {
31320: proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
31321: char *oldPath = pCtx->lockProxyPath;
31322: int rc = SQLITE_OK;
31323:
31324: if( pFile->eFileLock!=NO_LOCK ){
31325: return SQLITE_BUSY;
31326: }
31327:
31328: /* nothing to do if the path is NULL, :auto: or matches the existing path */
31329: if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ||
31330: (oldPath && !strncmp(oldPath, path, MAXPATHLEN)) ){
31331: return SQLITE_OK;
31332: }else{
31333: unixFile *lockProxy = pCtx->lockProxy;
31334: pCtx->lockProxy=NULL;
31335: pCtx->conchHeld = 0;
31336: if( lockProxy!=NULL ){
31337: rc=lockProxy->pMethod->xClose((sqlite3_file *)lockProxy);
31338: if( rc ) return rc;
31339: sqlite3_free(lockProxy);
31340: }
31341: sqlite3_free(oldPath);
31342: pCtx->lockProxyPath = sqlite3DbStrDup(0, path);
31343: }
31344:
31345: return rc;
31346: }
31347:
31348: /*
31349: ** pFile is a file that has been opened by a prior xOpen call. dbPath
31350: ** is a string buffer at least MAXPATHLEN+1 characters in size.
31351: **
31352: ** This routine find the filename associated with pFile and writes it
31353: ** int dbPath.
31354: */
31355: static int proxyGetDbPathForUnixFile(unixFile *pFile, char *dbPath){
31356: #if defined(__APPLE__)
31357: if( pFile->pMethod == &afpIoMethods ){
31358: /* afp style keeps a reference to the db path in the filePath field
31359: ** of the struct */
31360: assert( (int)strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
31361: strlcpy(dbPath, ((afpLockingContext *)pFile->lockingContext)->dbPath, MAXPATHLEN);
31362: } else
31363: #endif
31364: if( pFile->pMethod == &dotlockIoMethods ){
31365: /* dot lock style uses the locking context to store the dot lock
31366: ** file path */
31367: int len = strlen((char *)pFile->lockingContext) - strlen(DOTLOCK_SUFFIX);
31368: memcpy(dbPath, (char *)pFile->lockingContext, len + 1);
31369: }else{
31370: /* all other styles use the locking context to store the db file path */
31371: assert( strlen((char*)pFile->lockingContext)<=MAXPATHLEN );
31372: strlcpy(dbPath, (char *)pFile->lockingContext, MAXPATHLEN);
31373: }
31374: return SQLITE_OK;
31375: }
31376:
31377: /*
31378: ** Takes an already filled in unix file and alters it so all file locking
31379: ** will be performed on the local proxy lock file. The following fields
31380: ** are preserved in the locking context so that they can be restored and
31381: ** the unix structure properly cleaned up at close time:
31382: ** ->lockingContext
31383: ** ->pMethod
31384: */
31385: static int proxyTransformUnixFile(unixFile *pFile, const char *path) {
31386: proxyLockingContext *pCtx;
31387: char dbPath[MAXPATHLEN+1]; /* Name of the database file */
31388: char *lockPath=NULL;
31389: int rc = SQLITE_OK;
31390:
31391: if( pFile->eFileLock!=NO_LOCK ){
31392: return SQLITE_BUSY;
31393: }
31394: proxyGetDbPathForUnixFile(pFile, dbPath);
31395: if( !path || path[0]=='\0' || !strcmp(path, ":auto:") ){
31396: lockPath=NULL;
31397: }else{
31398: lockPath=(char *)path;
31399: }
31400:
31401: OSTRACE(("TRANSPROXY %d for %s pid=%d\n", pFile->h,
31402: (lockPath ? lockPath : ":auto:"), getpid()));
31403:
31404: pCtx = sqlite3_malloc( sizeof(*pCtx) );
31405: if( pCtx==0 ){
31406: return SQLITE_NOMEM;
31407: }
31408: memset(pCtx, 0, sizeof(*pCtx));
31409:
31410: rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath);
31411: if( rc==SQLITE_OK ){
31412: rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0);
31413: if( rc==SQLITE_CANTOPEN && ((pFile->openFlags&O_RDWR) == 0) ){
31414: /* if (a) the open flags are not O_RDWR, (b) the conch isn't there, and
31415: ** (c) the file system is read-only, then enable no-locking access.
31416: ** Ugh, since O_RDONLY==0x0000 we test for !O_RDWR since unixOpen asserts
31417: ** that openFlags will have only one of O_RDONLY or O_RDWR.
31418: */
31419: struct statfs fsInfo;
31420: struct stat conchInfo;
31421: int goLockless = 0;
31422:
31423: if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) {
31424: int err = errno;
31425: if( (err==ENOENT) && (statfs(dbPath, &fsInfo) != -1) ){
31426: goLockless = (fsInfo.f_flags&MNT_RDONLY) == MNT_RDONLY;
31427: }
31428: }
31429: if( goLockless ){
31430: pCtx->conchHeld = -1; /* read only FS/ lockless */
31431: rc = SQLITE_OK;
31432: }
31433: }
31434: }
31435: if( rc==SQLITE_OK && lockPath ){
31436: pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath);
31437: }
31438:
31439: if( rc==SQLITE_OK ){
31440: pCtx->dbPath = sqlite3DbStrDup(0, dbPath);
31441: if( pCtx->dbPath==NULL ){
31442: rc = SQLITE_NOMEM;
31443: }
31444: }
31445: if( rc==SQLITE_OK ){
31446: /* all memory is allocated, proxys are created and assigned,
31447: ** switch the locking context and pMethod then return.
31448: */
31449: pCtx->oldLockingContext = pFile->lockingContext;
31450: pFile->lockingContext = pCtx;
31451: pCtx->pOldMethod = pFile->pMethod;
31452: pFile->pMethod = &proxyIoMethods;
31453: }else{
31454: if( pCtx->conchFile ){
31455: pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile);
31456: sqlite3_free(pCtx->conchFile);
31457: }
31458: sqlite3DbFree(0, pCtx->lockProxyPath);
31459: sqlite3_free(pCtx->conchFilePath);
31460: sqlite3_free(pCtx);
31461: }
31462: OSTRACE(("TRANSPROXY %d %s\n", pFile->h,
31463: (rc==SQLITE_OK ? "ok" : "failed")));
31464: return rc;
31465: }
31466:
31467:
31468: /*
31469: ** This routine handles sqlite3_file_control() calls that are specific
31470: ** to proxy locking.
31471: */
31472: static int proxyFileControl(sqlite3_file *id, int op, void *pArg){
31473: switch( op ){
31474: case SQLITE_GET_LOCKPROXYFILE: {
31475: unixFile *pFile = (unixFile*)id;
31476: if( pFile->pMethod == &proxyIoMethods ){
31477: proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
31478: proxyTakeConch(pFile);
31479: if( pCtx->lockProxyPath ){
31480: *(const char **)pArg = pCtx->lockProxyPath;
31481: }else{
31482: *(const char **)pArg = ":auto: (not held)";
31483: }
31484: } else {
31485: *(const char **)pArg = NULL;
31486: }
31487: return SQLITE_OK;
31488: }
31489: case SQLITE_SET_LOCKPROXYFILE: {
31490: unixFile *pFile = (unixFile*)id;
31491: int rc = SQLITE_OK;
31492: int isProxyStyle = (pFile->pMethod == &proxyIoMethods);
31493: if( pArg==NULL || (const char *)pArg==0 ){
31494: if( isProxyStyle ){
31495: /* turn off proxy locking - not supported */
31496: rc = SQLITE_ERROR /*SQLITE_PROTOCOL? SQLITE_MISUSE?*/;
31497: }else{
31498: /* turn off proxy locking - already off - NOOP */
31499: rc = SQLITE_OK;
31500: }
31501: }else{
31502: const char *proxyPath = (const char *)pArg;
31503: if( isProxyStyle ){
31504: proxyLockingContext *pCtx =
31505: (proxyLockingContext*)pFile->lockingContext;
31506: if( !strcmp(pArg, ":auto:")
31507: || (pCtx->lockProxyPath &&
31508: !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN))
31509: ){
31510: rc = SQLITE_OK;
31511: }else{
31512: rc = switchLockProxyPath(pFile, proxyPath);
31513: }
31514: }else{
31515: /* turn on proxy file locking */
31516: rc = proxyTransformUnixFile(pFile, proxyPath);
31517: }
31518: }
31519: return rc;
31520: }
31521: default: {
31522: assert( 0 ); /* The call assures that only valid opcodes are sent */
31523: }
31524: }
31525: /*NOTREACHED*/
31526: return SQLITE_ERROR;
31527: }
31528:
31529: /*
31530: ** Within this division (the proxying locking implementation) the procedures
31531: ** above this point are all utilities. The lock-related methods of the
31532: ** proxy-locking sqlite3_io_method object follow.
31533: */
31534:
31535:
31536: /*
31537: ** This routine checks if there is a RESERVED lock held on the specified
31538: ** file by this or any other process. If such a lock is held, set *pResOut
31539: ** to a non-zero value otherwise *pResOut is set to zero. The return value
31540: ** is set to SQLITE_OK unless an I/O error occurs during lock checking.
31541: */
31542: static int proxyCheckReservedLock(sqlite3_file *id, int *pResOut) {
31543: unixFile *pFile = (unixFile*)id;
31544: int rc = proxyTakeConch(pFile);
31545: if( rc==SQLITE_OK ){
31546: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31547: if( pCtx->conchHeld>0 ){
31548: unixFile *proxy = pCtx->lockProxy;
31549: return proxy->pMethod->xCheckReservedLock((sqlite3_file*)proxy, pResOut);
31550: }else{ /* conchHeld < 0 is lockless */
31551: pResOut=0;
31552: }
31553: }
31554: return rc;
31555: }
31556:
31557: /*
31558: ** Lock the file with the lock specified by parameter eFileLock - one
31559: ** of the following:
31560: **
31561: ** (1) SHARED_LOCK
31562: ** (2) RESERVED_LOCK
31563: ** (3) PENDING_LOCK
31564: ** (4) EXCLUSIVE_LOCK
31565: **
31566: ** Sometimes when requesting one lock state, additional lock states
31567: ** are inserted in between. The locking might fail on one of the later
31568: ** transitions leaving the lock state different from what it started but
31569: ** still short of its goal. The following chart shows the allowed
31570: ** transitions and the inserted intermediate states:
31571: **
31572: ** UNLOCKED -> SHARED
31573: ** SHARED -> RESERVED
31574: ** SHARED -> (PENDING) -> EXCLUSIVE
31575: ** RESERVED -> (PENDING) -> EXCLUSIVE
31576: ** PENDING -> EXCLUSIVE
31577: **
31578: ** This routine will only increase a lock. Use the sqlite3OsUnlock()
31579: ** routine to lower a locking level.
31580: */
31581: static int proxyLock(sqlite3_file *id, int eFileLock) {
31582: unixFile *pFile = (unixFile*)id;
31583: int rc = proxyTakeConch(pFile);
31584: if( rc==SQLITE_OK ){
31585: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31586: if( pCtx->conchHeld>0 ){
31587: unixFile *proxy = pCtx->lockProxy;
31588: rc = proxy->pMethod->xLock((sqlite3_file*)proxy, eFileLock);
31589: pFile->eFileLock = proxy->eFileLock;
31590: }else{
31591: /* conchHeld < 0 is lockless */
31592: }
31593: }
31594: return rc;
31595: }
31596:
31597:
31598: /*
31599: ** Lower the locking level on file descriptor pFile to eFileLock. eFileLock
31600: ** must be either NO_LOCK or SHARED_LOCK.
31601: **
31602: ** If the locking level of the file descriptor is already at or below
31603: ** the requested locking level, this routine is a no-op.
31604: */
31605: static int proxyUnlock(sqlite3_file *id, int eFileLock) {
31606: unixFile *pFile = (unixFile*)id;
31607: int rc = proxyTakeConch(pFile);
31608: if( rc==SQLITE_OK ){
31609: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31610: if( pCtx->conchHeld>0 ){
31611: unixFile *proxy = pCtx->lockProxy;
31612: rc = proxy->pMethod->xUnlock((sqlite3_file*)proxy, eFileLock);
31613: pFile->eFileLock = proxy->eFileLock;
31614: }else{
31615: /* conchHeld < 0 is lockless */
31616: }
31617: }
31618: return rc;
31619: }
31620:
31621: /*
31622: ** Close a file that uses proxy locks.
31623: */
31624: static int proxyClose(sqlite3_file *id) {
31625: if( id ){
31626: unixFile *pFile = (unixFile*)id;
31627: proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
31628: unixFile *lockProxy = pCtx->lockProxy;
31629: unixFile *conchFile = pCtx->conchFile;
31630: int rc = SQLITE_OK;
31631:
31632: if( lockProxy ){
31633: rc = lockProxy->pMethod->xUnlock((sqlite3_file*)lockProxy, NO_LOCK);
31634: if( rc ) return rc;
31635: rc = lockProxy->pMethod->xClose((sqlite3_file*)lockProxy);
31636: if( rc ) return rc;
31637: sqlite3_free(lockProxy);
31638: pCtx->lockProxy = 0;
31639: }
31640: if( conchFile ){
31641: if( pCtx->conchHeld ){
31642: rc = proxyReleaseConch(pFile);
31643: if( rc ) return rc;
31644: }
31645: rc = conchFile->pMethod->xClose((sqlite3_file*)conchFile);
31646: if( rc ) return rc;
31647: sqlite3_free(conchFile);
31648: }
31649: sqlite3DbFree(0, pCtx->lockProxyPath);
31650: sqlite3_free(pCtx->conchFilePath);
31651: sqlite3DbFree(0, pCtx->dbPath);
31652: /* restore the original locking context and pMethod then close it */
31653: pFile->lockingContext = pCtx->oldLockingContext;
31654: pFile->pMethod = pCtx->pOldMethod;
31655: sqlite3_free(pCtx);
31656: return pFile->pMethod->xClose(id);
31657: }
31658: return SQLITE_OK;
31659: }
31660:
31661:
31662:
31663: #endif /* defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE */
31664: /*
31665: ** The proxy locking style is intended for use with AFP filesystems.
31666: ** And since AFP is only supported on MacOSX, the proxy locking is also
31667: ** restricted to MacOSX.
31668: **
31669: **
31670: ******************* End of the proxy lock implementation **********************
31671: ******************************************************************************/
31672:
31673: /*
31674: ** Initialize the operating system interface.
31675: **
31676: ** This routine registers all VFS implementations for unix-like operating
31677: ** systems. This routine, and the sqlite3_os_end() routine that follows,
31678: ** should be the only routines in this file that are visible from other
31679: ** files.
31680: **
31681: ** This routine is called once during SQLite initialization and by a
31682: ** single thread. The memory allocation and mutex subsystems have not
31683: ** necessarily been initialized when this routine is called, and so they
31684: ** should not be used.
31685: */
31686: SQLITE_API int sqlite3_os_init(void){
31687: /*
31688: ** The following macro defines an initializer for an sqlite3_vfs object.
31689: ** The name of the VFS is NAME. The pAppData is a pointer to a pointer
31690: ** to the "finder" function. (pAppData is a pointer to a pointer because
31691: ** silly C90 rules prohibit a void* from being cast to a function pointer
31692: ** and so we have to go through the intermediate pointer to avoid problems
31693: ** when compiling with -pedantic-errors on GCC.)
31694: **
31695: ** The FINDER parameter to this macro is the name of the pointer to the
31696: ** finder-function. The finder-function returns a pointer to the
31697: ** sqlite_io_methods object that implements the desired locking
31698: ** behaviors. See the division above that contains the IOMETHODS
31699: ** macro for addition information on finder-functions.
31700: **
31701: ** Most finders simply return a pointer to a fixed sqlite3_io_methods
31702: ** object. But the "autolockIoFinder" available on MacOSX does a little
31703: ** more than that; it looks at the filesystem type that hosts the
31704: ** database file and tries to choose an locking method appropriate for
31705: ** that filesystem time.
31706: */
31707: #define UNIXVFS(VFSNAME, FINDER) { \
31708: 3, /* iVersion */ \
31709: sizeof(unixFile), /* szOsFile */ \
31710: MAX_PATHNAME, /* mxPathname */ \
31711: 0, /* pNext */ \
31712: VFSNAME, /* zName */ \
31713: (void*)&FINDER, /* pAppData */ \
31714: unixOpen, /* xOpen */ \
31715: unixDelete, /* xDelete */ \
31716: unixAccess, /* xAccess */ \
31717: unixFullPathname, /* xFullPathname */ \
31718: unixDlOpen, /* xDlOpen */ \
31719: unixDlError, /* xDlError */ \
31720: unixDlSym, /* xDlSym */ \
31721: unixDlClose, /* xDlClose */ \
31722: unixRandomness, /* xRandomness */ \
31723: unixSleep, /* xSleep */ \
31724: unixCurrentTime, /* xCurrentTime */ \
31725: unixGetLastError, /* xGetLastError */ \
31726: unixCurrentTimeInt64, /* xCurrentTimeInt64 */ \
31727: unixSetSystemCall, /* xSetSystemCall */ \
31728: unixGetSystemCall, /* xGetSystemCall */ \
31729: unixNextSystemCall, /* xNextSystemCall */ \
31730: }
31731:
31732: /*
31733: ** All default VFSes for unix are contained in the following array.
31734: **
31735: ** Note that the sqlite3_vfs.pNext field of the VFS object is modified
31736: ** by the SQLite core when the VFS is registered. So the following
31737: ** array cannot be const.
31738: */
31739: static sqlite3_vfs aVfs[] = {
31740: #if SQLITE_ENABLE_LOCKING_STYLE && (OS_VXWORKS || defined(__APPLE__))
31741: UNIXVFS("unix", autolockIoFinder ),
31742: #else
31743: UNIXVFS("unix", posixIoFinder ),
31744: #endif
31745: UNIXVFS("unix-none", nolockIoFinder ),
31746: UNIXVFS("unix-dotfile", dotlockIoFinder ),
31747: UNIXVFS("unix-excl", posixIoFinder ),
31748: #if OS_VXWORKS
31749: UNIXVFS("unix-namedsem", semIoFinder ),
31750: #endif
31751: #if SQLITE_ENABLE_LOCKING_STYLE
31752: UNIXVFS("unix-posix", posixIoFinder ),
31753: #if !OS_VXWORKS
31754: UNIXVFS("unix-flock", flockIoFinder ),
31755: #endif
31756: #endif
31757: #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
31758: UNIXVFS("unix-afp", afpIoFinder ),
31759: UNIXVFS("unix-nfs", nfsIoFinder ),
31760: UNIXVFS("unix-proxy", proxyIoFinder ),
31761: #endif
31762: };
31763: unsigned int i; /* Loop counter */
31764:
31765: /* Double-check that the aSyscall[] array has been constructed
31766: ** correctly. See ticket [bb3a86e890c8e96ab] */
31767: assert( ArraySize(aSyscall)==20 );
31768:
31769: /* Register all VFSes defined in the aVfs[] array */
31770: for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
31771: sqlite3_vfs_register(&aVfs[i], i==0);
31772: }
31773: return SQLITE_OK;
31774: }
31775:
31776: /*
31777: ** Shutdown the operating system interface.
31778: **
31779: ** Some operating systems might need to do some cleanup in this routine,
31780: ** to release dynamically allocated objects. But not on unix.
31781: ** This routine is a no-op for unix.
31782: */
31783: SQLITE_API int sqlite3_os_end(void){
31784: return SQLITE_OK;
31785: }
31786:
31787: #endif /* SQLITE_OS_UNIX */
31788:
31789: /************** End of os_unix.c *********************************************/
31790: /************** Begin file os_win.c ******************************************/
31791: /*
31792: ** 2004 May 22
31793: **
31794: ** The author disclaims copyright to this source code. In place of
31795: ** a legal notice, here is a blessing:
31796: **
31797: ** May you do good and not evil.
31798: ** May you find forgiveness for yourself and forgive others.
31799: ** May you share freely, never taking more than you give.
31800: **
31801: ******************************************************************************
31802: **
31803: ** This file contains code that is specific to Windows.
31804: */
31805: #if SQLITE_OS_WIN /* This file is used for Windows only */
31806:
31807: #ifdef __CYGWIN__
31808: # include <sys/cygwin.h>
31809: #endif
31810:
31811: /*
31812: ** Include code that is common to all os_*.c files
31813: */
31814: /************** Include os_common.h in the middle of os_win.c ****************/
31815: /************** Begin file os_common.h ***************************************/
31816: /*
31817: ** 2004 May 22
31818: **
31819: ** The author disclaims copyright to this source code. In place of
31820: ** a legal notice, here is a blessing:
31821: **
31822: ** May you do good and not evil.
31823: ** May you find forgiveness for yourself and forgive others.
31824: ** May you share freely, never taking more than you give.
31825: **
31826: ******************************************************************************
31827: **
31828: ** This file contains macros and a little bit of code that is common to
31829: ** all of the platform-specific files (os_*.c) and is #included into those
31830: ** files.
31831: **
31832: ** This file should be #included by the os_*.c files only. It is not a
31833: ** general purpose header file.
31834: */
31835: #ifndef _OS_COMMON_H_
31836: #define _OS_COMMON_H_
31837:
31838: /*
31839: ** At least two bugs have slipped in because we changed the MEMORY_DEBUG
31840: ** macro to SQLITE_DEBUG and some older makefiles have not yet made the
31841: ** switch. The following code should catch this problem at compile-time.
31842: */
31843: #ifdef MEMORY_DEBUG
31844: # error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead."
31845: #endif
31846:
31847: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
31848: # ifndef SQLITE_DEBUG_OS_TRACE
31849: # define SQLITE_DEBUG_OS_TRACE 0
31850: # endif
31851: int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE;
31852: # define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X
31853: #else
31854: # define OSTRACE(X)
31855: #endif
31856:
31857: /*
31858: ** Macros for performance tracing. Normally turned off. Only works
31859: ** on i486 hardware.
31860: */
31861: #ifdef SQLITE_PERFORMANCE_TRACE
31862:
31863: /*
31864: ** hwtime.h contains inline assembler code for implementing
31865: ** high-performance timing routines.
31866: */
31867: /************** Include hwtime.h in the middle of os_common.h ****************/
31868: /************** Begin file hwtime.h ******************************************/
31869: /*
31870: ** 2008 May 27
31871: **
31872: ** The author disclaims copyright to this source code. In place of
31873: ** a legal notice, here is a blessing:
31874: **
31875: ** May you do good and not evil.
31876: ** May you find forgiveness for yourself and forgive others.
31877: ** May you share freely, never taking more than you give.
31878: **
31879: ******************************************************************************
31880: **
31881: ** This file contains inline asm code for retrieving "high-performance"
31882: ** counters for x86 class CPUs.
31883: */
31884: #ifndef _HWTIME_H_
31885: #define _HWTIME_H_
31886:
31887: /*
31888: ** The following routine only works on pentium-class (or newer) processors.
31889: ** It uses the RDTSC opcode to read the cycle count value out of the
31890: ** processor and returns that value. This can be used for high-res
31891: ** profiling.
31892: */
31893: #if (defined(__GNUC__) || defined(_MSC_VER)) && \
31894: (defined(i386) || defined(__i386__) || defined(_M_IX86))
31895:
31896: #if defined(__GNUC__)
31897:
31898: __inline__ sqlite_uint64 sqlite3Hwtime(void){
31899: unsigned int lo, hi;
31900: __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
31901: return (sqlite_uint64)hi << 32 | lo;
31902: }
31903:
31904: #elif defined(_MSC_VER)
31905:
31906: __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
31907: __asm {
31908: rdtsc
31909: ret ; return value at EDX:EAX
31910: }
31911: }
31912:
31913: #endif
31914:
31915: #elif (defined(__GNUC__) && defined(__x86_64__))
31916:
31917: __inline__ sqlite_uint64 sqlite3Hwtime(void){
31918: unsigned long val;
31919: __asm__ __volatile__ ("rdtsc" : "=A" (val));
31920: return val;
31921: }
31922:
31923: #elif (defined(__GNUC__) && defined(__ppc__))
31924:
31925: __inline__ sqlite_uint64 sqlite3Hwtime(void){
31926: unsigned long long retval;
31927: unsigned long junk;
31928: __asm__ __volatile__ ("\n\
31929: 1: mftbu %1\n\
31930: mftb %L0\n\
31931: mftbu %0\n\
31932: cmpw %0,%1\n\
31933: bne 1b"
31934: : "=r" (retval), "=r" (junk));
31935: return retval;
31936: }
31937:
31938: #else
31939:
31940: #error Need implementation of sqlite3Hwtime() for your platform.
31941:
31942: /*
31943: ** To compile without implementing sqlite3Hwtime() for your platform,
31944: ** you can remove the above #error and use the following
31945: ** stub function. You will lose timing support for many
31946: ** of the debugging and testing utilities, but it should at
31947: ** least compile and run.
31948: */
31949: SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
31950:
31951: #endif
31952:
31953: #endif /* !defined(_HWTIME_H_) */
31954:
31955: /************** End of hwtime.h **********************************************/
31956: /************** Continuing where we left off in os_common.h ******************/
31957:
31958: static sqlite_uint64 g_start;
31959: static sqlite_uint64 g_elapsed;
31960: #define TIMER_START g_start=sqlite3Hwtime()
31961: #define TIMER_END g_elapsed=sqlite3Hwtime()-g_start
31962: #define TIMER_ELAPSED g_elapsed
31963: #else
31964: #define TIMER_START
31965: #define TIMER_END
31966: #define TIMER_ELAPSED ((sqlite_uint64)0)
31967: #endif
31968:
31969: /*
31970: ** If we compile with the SQLITE_TEST macro set, then the following block
31971: ** of code will give us the ability to simulate a disk I/O error. This
31972: ** is used for testing the I/O recovery logic.
31973: */
31974: #ifdef SQLITE_TEST
31975: SQLITE_API int sqlite3_io_error_hit = 0; /* Total number of I/O Errors */
31976: SQLITE_API int sqlite3_io_error_hardhit = 0; /* Number of non-benign errors */
31977: SQLITE_API int sqlite3_io_error_pending = 0; /* Count down to first I/O error */
31978: SQLITE_API int sqlite3_io_error_persist = 0; /* True if I/O errors persist */
31979: SQLITE_API int sqlite3_io_error_benign = 0; /* True if errors are benign */
31980: SQLITE_API int sqlite3_diskfull_pending = 0;
31981: SQLITE_API int sqlite3_diskfull = 0;
31982: #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
31983: #define SimulateIOError(CODE) \
31984: if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
31985: || sqlite3_io_error_pending-- == 1 ) \
31986: { local_ioerr(); CODE; }
31987: static void local_ioerr(){
31988: IOTRACE(("IOERR\n"));
31989: sqlite3_io_error_hit++;
31990: if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
31991: }
31992: #define SimulateDiskfullError(CODE) \
31993: if( sqlite3_diskfull_pending ){ \
31994: if( sqlite3_diskfull_pending == 1 ){ \
31995: local_ioerr(); \
31996: sqlite3_diskfull = 1; \
31997: sqlite3_io_error_hit = 1; \
31998: CODE; \
31999: }else{ \
32000: sqlite3_diskfull_pending--; \
32001: } \
32002: }
32003: #else
32004: #define SimulateIOErrorBenign(X)
32005: #define SimulateIOError(A)
32006: #define SimulateDiskfullError(A)
32007: #endif
32008:
32009: /*
32010: ** When testing, keep a count of the number of open files.
32011: */
32012: #ifdef SQLITE_TEST
32013: SQLITE_API int sqlite3_open_file_count = 0;
32014: #define OpenCounter(X) sqlite3_open_file_count+=(X)
32015: #else
32016: #define OpenCounter(X)
32017: #endif
32018:
32019: #endif /* !defined(_OS_COMMON_H_) */
32020:
32021: /************** End of os_common.h *******************************************/
32022: /************** Continuing where we left off in os_win.c *********************/
32023:
32024: /*
32025: ** Some Microsoft compilers lack this definition.
32026: */
32027: #ifndef INVALID_FILE_ATTRIBUTES
32028: # define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
32029: #endif
32030:
32031: /* Forward references */
32032: typedef struct winShm winShm; /* A connection to shared-memory */
32033: typedef struct winShmNode winShmNode; /* A region of shared-memory */
32034:
32035: /*
32036: ** WinCE lacks native support for file locking so we have to fake it
32037: ** with some code of our own.
32038: */
32039: #if SQLITE_OS_WINCE
32040: typedef struct winceLock {
32041: int nReaders; /* Number of reader locks obtained */
32042: BOOL bPending; /* Indicates a pending lock has been obtained */
32043: BOOL bReserved; /* Indicates a reserved lock has been obtained */
32044: BOOL bExclusive; /* Indicates an exclusive lock has been obtained */
32045: } winceLock;
32046: #endif
32047:
32048: /*
32049: ** The winFile structure is a subclass of sqlite3_file* specific to the win32
32050: ** portability layer.
32051: */
32052: typedef struct winFile winFile;
32053: struct winFile {
32054: const sqlite3_io_methods *pMethod; /*** Must be first ***/
32055: sqlite3_vfs *pVfs; /* The VFS used to open this file */
32056: HANDLE h; /* Handle for accessing the file */
32057: u8 locktype; /* Type of lock currently held on this file */
32058: short sharedLockByte; /* Randomly chosen byte used as a shared lock */
32059: u8 ctrlFlags; /* Flags. See WINFILE_* below */
32060: DWORD lastErrno; /* The Windows errno from the last I/O error */
32061: winShm *pShm; /* Instance of shared memory on this file */
32062: const char *zPath; /* Full pathname of this file */
32063: int szChunk; /* Chunk size configured by FCNTL_CHUNK_SIZE */
32064: #if SQLITE_OS_WINCE
32065: LPWSTR zDeleteOnClose; /* Name of file to delete when closing */
32066: HANDLE hMutex; /* Mutex used to control access to shared lock */
32067: HANDLE hShared; /* Shared memory segment used for locking */
32068: winceLock local; /* Locks obtained by this instance of winFile */
32069: winceLock *shared; /* Global shared lock memory for the file */
32070: #endif
32071: };
32072:
32073: /*
32074: ** Allowed values for winFile.ctrlFlags
32075: */
32076: #define WINFILE_PERSIST_WAL 0x04 /* Persistent WAL mode */
32077: #define WINFILE_PSOW 0x10 /* SQLITE_IOCAP_POWERSAFE_OVERWRITE */
32078:
32079: /*
32080: * If compiled with SQLITE_WIN32_MALLOC on Windows, we will use the
32081: * various Win32 API heap functions instead of our own.
32082: */
32083: #ifdef SQLITE_WIN32_MALLOC
32084: /*
32085: * The initial size of the Win32-specific heap. This value may be zero.
32086: */
32087: #ifndef SQLITE_WIN32_HEAP_INIT_SIZE
32088: # define SQLITE_WIN32_HEAP_INIT_SIZE ((SQLITE_DEFAULT_CACHE_SIZE) * \
32089: (SQLITE_DEFAULT_PAGE_SIZE) + 4194304)
32090: #endif
32091:
32092: /*
32093: * The maximum size of the Win32-specific heap. This value may be zero.
32094: */
32095: #ifndef SQLITE_WIN32_HEAP_MAX_SIZE
32096: # define SQLITE_WIN32_HEAP_MAX_SIZE (0)
32097: #endif
32098:
32099: /*
32100: * The extra flags to use in calls to the Win32 heap APIs. This value may be
32101: * zero for the default behavior.
32102: */
32103: #ifndef SQLITE_WIN32_HEAP_FLAGS
32104: # define SQLITE_WIN32_HEAP_FLAGS (0)
32105: #endif
32106:
32107: /*
32108: ** The winMemData structure stores information required by the Win32-specific
32109: ** sqlite3_mem_methods implementation.
32110: */
32111: typedef struct winMemData winMemData;
32112: struct winMemData {
32113: #ifndef NDEBUG
32114: u32 magic; /* Magic number to detect structure corruption. */
32115: #endif
32116: HANDLE hHeap; /* The handle to our heap. */
32117: BOOL bOwned; /* Do we own the heap (i.e. destroy it on shutdown)? */
32118: };
32119:
32120: #ifndef NDEBUG
32121: #define WINMEM_MAGIC 0x42b2830b
32122: #endif
32123:
32124: static struct winMemData win_mem_data = {
32125: #ifndef NDEBUG
32126: WINMEM_MAGIC,
32127: #endif
32128: NULL, FALSE
32129: };
32130:
32131: #ifndef NDEBUG
32132: #define winMemAssertMagic() assert( win_mem_data.magic==WINMEM_MAGIC )
32133: #else
32134: #define winMemAssertMagic()
32135: #endif
32136:
32137: #define winMemGetHeap() win_mem_data.hHeap
32138:
32139: static void *winMemMalloc(int nBytes);
32140: static void winMemFree(void *pPrior);
32141: static void *winMemRealloc(void *pPrior, int nBytes);
32142: static int winMemSize(void *p);
32143: static int winMemRoundup(int n);
32144: static int winMemInit(void *pAppData);
32145: static void winMemShutdown(void *pAppData);
32146:
32147: SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetWin32(void);
32148: #endif /* SQLITE_WIN32_MALLOC */
32149:
32150: /*
32151: ** The following variable is (normally) set once and never changes
32152: ** thereafter. It records whether the operating system is Win9x
32153: ** or WinNT.
32154: **
32155: ** 0: Operating system unknown.
32156: ** 1: Operating system is Win9x.
32157: ** 2: Operating system is WinNT.
32158: **
32159: ** In order to facilitate testing on a WinNT system, the test fixture
32160: ** can manually set this value to 1 to emulate Win98 behavior.
32161: */
32162: #ifdef SQLITE_TEST
32163: SQLITE_API int sqlite3_os_type = 0;
32164: #else
32165: static int sqlite3_os_type = 0;
32166: #endif
32167:
32168: /*
32169: ** Many system calls are accessed through pointer-to-functions so that
32170: ** they may be overridden at runtime to facilitate fault injection during
32171: ** testing and sandboxing. The following array holds the names and pointers
32172: ** to all overrideable system calls.
32173: */
32174: #if !SQLITE_OS_WINCE
32175: # define SQLITE_WIN32_HAS_ANSI
32176: #endif
32177:
32178: #if SQLITE_OS_WINCE || SQLITE_OS_WINNT
32179: # define SQLITE_WIN32_HAS_WIDE
32180: #endif
32181:
32182: #ifndef SYSCALL
32183: # define SYSCALL sqlite3_syscall_ptr
32184: #endif
32185:
32186: #if SQLITE_OS_WINCE
32187: /*
32188: ** These macros are necessary because Windows CE does not natively support the
32189: ** Win32 APIs LockFile, UnlockFile, and LockFileEx.
32190: */
32191:
32192: # define LockFile(a,b,c,d,e) winceLockFile(&a, b, c, d, e)
32193: # define UnlockFile(a,b,c,d,e) winceUnlockFile(&a, b, c, d, e)
32194: # define LockFileEx(a,b,c,d,e,f) winceLockFileEx(&a, b, c, d, e, f)
32195:
32196: /*
32197: ** These are the special syscall hacks for Windows CE. The locking related
32198: ** defines here refer to the macros defined just above.
32199: */
32200:
32201: # define osAreFileApisANSI() 1
32202: # define osLockFile LockFile
32203: # define osUnlockFile UnlockFile
32204: # define osLockFileEx LockFileEx
32205: #endif
32206:
32207: static struct win_syscall {
32208: const char *zName; /* Name of the sytem call */
32209: sqlite3_syscall_ptr pCurrent; /* Current value of the system call */
32210: sqlite3_syscall_ptr pDefault; /* Default value */
32211: } aSyscall[] = {
32212: #if !SQLITE_OS_WINCE
32213: { "AreFileApisANSI", (SYSCALL)AreFileApisANSI, 0 },
32214:
32215: #define osAreFileApisANSI ((BOOL(WINAPI*)(VOID))aSyscall[0].pCurrent)
32216: #else
32217: { "AreFileApisANSI", (SYSCALL)0, 0 },
32218: #endif
32219:
32220: #if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)
32221: { "CharLowerW", (SYSCALL)CharLowerW, 0 },
32222: #else
32223: { "CharLowerW", (SYSCALL)0, 0 },
32224: #endif
32225:
32226: #define osCharLowerW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[1].pCurrent)
32227:
32228: #if SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)
32229: { "CharUpperW", (SYSCALL)CharUpperW, 0 },
32230: #else
32231: { "CharUpperW", (SYSCALL)0, 0 },
32232: #endif
32233:
32234: #define osCharUpperW ((LPWSTR(WINAPI*)(LPWSTR))aSyscall[2].pCurrent)
32235:
32236: { "CloseHandle", (SYSCALL)CloseHandle, 0 },
32237:
32238: #define osCloseHandle ((BOOL(WINAPI*)(HANDLE))aSyscall[3].pCurrent)
32239:
32240: #if defined(SQLITE_WIN32_HAS_ANSI)
32241: { "CreateFileA", (SYSCALL)CreateFileA, 0 },
32242: #else
32243: { "CreateFileA", (SYSCALL)0, 0 },
32244: #endif
32245:
32246: #define osCreateFileA ((HANDLE(WINAPI*)(LPCSTR,DWORD,DWORD, \
32247: LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[4].pCurrent)
32248:
32249: #if defined(SQLITE_WIN32_HAS_WIDE)
32250: { "CreateFileW", (SYSCALL)CreateFileW, 0 },
32251: #else
32252: { "CreateFileW", (SYSCALL)0, 0 },
32253: #endif
32254:
32255: #define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \
32256: LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent)
32257:
32258: { "CreateFileMapping", (SYSCALL)CreateFileMapping, 0 },
32259:
32260: #define osCreateFileMapping ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \
32261: DWORD,DWORD,DWORD,LPCTSTR))aSyscall[6].pCurrent)
32262:
32263: #if defined(SQLITE_WIN32_HAS_WIDE)
32264: { "CreateFileMappingW", (SYSCALL)CreateFileMappingW, 0 },
32265: #else
32266: { "CreateFileMappingW", (SYSCALL)0, 0 },
32267: #endif
32268:
32269: #define osCreateFileMappingW ((HANDLE(WINAPI*)(HANDLE,LPSECURITY_ATTRIBUTES, \
32270: DWORD,DWORD,DWORD,LPCWSTR))aSyscall[7].pCurrent)
32271:
32272: #if defined(SQLITE_WIN32_HAS_WIDE)
32273: { "CreateMutexW", (SYSCALL)CreateMutexW, 0 },
32274: #else
32275: { "CreateMutexW", (SYSCALL)0, 0 },
32276: #endif
32277:
32278: #define osCreateMutexW ((HANDLE(WINAPI*)(LPSECURITY_ATTRIBUTES,BOOL, \
32279: LPCWSTR))aSyscall[8].pCurrent)
32280:
32281: #if defined(SQLITE_WIN32_HAS_ANSI)
32282: { "DeleteFileA", (SYSCALL)DeleteFileA, 0 },
32283: #else
32284: { "DeleteFileA", (SYSCALL)0, 0 },
32285: #endif
32286:
32287: #define osDeleteFileA ((BOOL(WINAPI*)(LPCSTR))aSyscall[9].pCurrent)
32288:
32289: #if defined(SQLITE_WIN32_HAS_WIDE)
32290: { "DeleteFileW", (SYSCALL)DeleteFileW, 0 },
32291: #else
32292: { "DeleteFileW", (SYSCALL)0, 0 },
32293: #endif
32294:
32295: #define osDeleteFileW ((BOOL(WINAPI*)(LPCWSTR))aSyscall[10].pCurrent)
32296:
32297: #if SQLITE_OS_WINCE
32298: { "FileTimeToLocalFileTime", (SYSCALL)FileTimeToLocalFileTime, 0 },
32299: #else
32300: { "FileTimeToLocalFileTime", (SYSCALL)0, 0 },
32301: #endif
32302:
32303: #define osFileTimeToLocalFileTime ((BOOL(WINAPI*)(CONST FILETIME*, \
32304: LPFILETIME))aSyscall[11].pCurrent)
32305:
32306: #if SQLITE_OS_WINCE
32307: { "FileTimeToSystemTime", (SYSCALL)FileTimeToSystemTime, 0 },
32308: #else
32309: { "FileTimeToSystemTime", (SYSCALL)0, 0 },
32310: #endif
32311:
32312: #define osFileTimeToSystemTime ((BOOL(WINAPI*)(CONST FILETIME*, \
32313: LPSYSTEMTIME))aSyscall[12].pCurrent)
32314:
32315: { "FlushFileBuffers", (SYSCALL)FlushFileBuffers, 0 },
32316:
32317: #define osFlushFileBuffers ((BOOL(WINAPI*)(HANDLE))aSyscall[13].pCurrent)
32318:
32319: #if defined(SQLITE_WIN32_HAS_ANSI)
32320: { "FormatMessageA", (SYSCALL)FormatMessageA, 0 },
32321: #else
32322: { "FormatMessageA", (SYSCALL)0, 0 },
32323: #endif
32324:
32325: #define osFormatMessageA ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPSTR, \
32326: DWORD,va_list*))aSyscall[14].pCurrent)
32327:
32328: #if defined(SQLITE_WIN32_HAS_WIDE)
32329: { "FormatMessageW", (SYSCALL)FormatMessageW, 0 },
32330: #else
32331: { "FormatMessageW", (SYSCALL)0, 0 },
32332: #endif
32333:
32334: #define osFormatMessageW ((DWORD(WINAPI*)(DWORD,LPCVOID,DWORD,DWORD,LPWSTR, \
32335: DWORD,va_list*))aSyscall[15].pCurrent)
32336:
32337: { "FreeLibrary", (SYSCALL)FreeLibrary, 0 },
32338:
32339: #define osFreeLibrary ((BOOL(WINAPI*)(HMODULE))aSyscall[16].pCurrent)
32340:
32341: { "GetCurrentProcessId", (SYSCALL)GetCurrentProcessId, 0 },
32342:
32343: #define osGetCurrentProcessId ((DWORD(WINAPI*)(VOID))aSyscall[17].pCurrent)
32344:
32345: #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI)
32346: { "GetDiskFreeSpaceA", (SYSCALL)GetDiskFreeSpaceA, 0 },
32347: #else
32348: { "GetDiskFreeSpaceA", (SYSCALL)0, 0 },
32349: #endif
32350:
32351: #define osGetDiskFreeSpaceA ((BOOL(WINAPI*)(LPCSTR,LPDWORD,LPDWORD,LPDWORD, \
32352: LPDWORD))aSyscall[18].pCurrent)
32353:
32354: #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)
32355: { "GetDiskFreeSpaceW", (SYSCALL)GetDiskFreeSpaceW, 0 },
32356: #else
32357: { "GetDiskFreeSpaceW", (SYSCALL)0, 0 },
32358: #endif
32359:
32360: #define osGetDiskFreeSpaceW ((BOOL(WINAPI*)(LPCWSTR,LPDWORD,LPDWORD,LPDWORD, \
32361: LPDWORD))aSyscall[19].pCurrent)
32362:
32363: #if defined(SQLITE_WIN32_HAS_ANSI)
32364: { "GetFileAttributesA", (SYSCALL)GetFileAttributesA, 0 },
32365: #else
32366: { "GetFileAttributesA", (SYSCALL)0, 0 },
32367: #endif
32368:
32369: #define osGetFileAttributesA ((DWORD(WINAPI*)(LPCSTR))aSyscall[20].pCurrent)
32370:
32371: #if defined(SQLITE_WIN32_HAS_WIDE)
32372: { "GetFileAttributesW", (SYSCALL)GetFileAttributesW, 0 },
32373: #else
32374: { "GetFileAttributesW", (SYSCALL)0, 0 },
32375: #endif
32376:
32377: #define osGetFileAttributesW ((DWORD(WINAPI*)(LPCWSTR))aSyscall[21].pCurrent)
32378:
32379: #if defined(SQLITE_WIN32_HAS_WIDE)
32380: { "GetFileAttributesExW", (SYSCALL)GetFileAttributesExW, 0 },
32381: #else
32382: { "GetFileAttributesExW", (SYSCALL)0, 0 },
32383: #endif
32384:
32385: #define osGetFileAttributesExW ((BOOL(WINAPI*)(LPCWSTR,GET_FILEEX_INFO_LEVELS, \
32386: LPVOID))aSyscall[22].pCurrent)
32387:
32388: { "GetFileSize", (SYSCALL)GetFileSize, 0 },
32389:
32390: #define osGetFileSize ((DWORD(WINAPI*)(HANDLE,LPDWORD))aSyscall[23].pCurrent)
32391:
32392: #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_ANSI)
32393: { "GetFullPathNameA", (SYSCALL)GetFullPathNameA, 0 },
32394: #else
32395: { "GetFullPathNameA", (SYSCALL)0, 0 },
32396: #endif
32397:
32398: #define osGetFullPathNameA ((DWORD(WINAPI*)(LPCSTR,DWORD,LPSTR, \
32399: LPSTR*))aSyscall[24].pCurrent)
32400:
32401: #if !SQLITE_OS_WINCE && defined(SQLITE_WIN32_HAS_WIDE)
32402: { "GetFullPathNameW", (SYSCALL)GetFullPathNameW, 0 },
32403: #else
32404: { "GetFullPathNameW", (SYSCALL)0, 0 },
32405: #endif
32406:
32407: #define osGetFullPathNameW ((DWORD(WINAPI*)(LPCWSTR,DWORD,LPWSTR, \
32408: LPWSTR*))aSyscall[25].pCurrent)
32409:
32410: { "GetLastError", (SYSCALL)GetLastError, 0 },
32411:
32412: #define osGetLastError ((DWORD(WINAPI*)(VOID))aSyscall[26].pCurrent)
32413:
32414: #if SQLITE_OS_WINCE
32415: /* The GetProcAddressA() routine is only available on Windows CE. */
32416: { "GetProcAddressA", (SYSCALL)GetProcAddressA, 0 },
32417: #else
32418: /* All other Windows platforms expect GetProcAddress() to take
32419: ** an ANSI string regardless of the _UNICODE setting */
32420: { "GetProcAddressA", (SYSCALL)GetProcAddress, 0 },
32421: #endif
32422:
32423: #define osGetProcAddressA ((FARPROC(WINAPI*)(HMODULE, \
32424: LPCSTR))aSyscall[27].pCurrent)
32425:
32426: { "GetSystemInfo", (SYSCALL)GetSystemInfo, 0 },
32427:
32428: #define osGetSystemInfo ((VOID(WINAPI*)(LPSYSTEM_INFO))aSyscall[28].pCurrent)
32429:
32430: { "GetSystemTime", (SYSCALL)GetSystemTime, 0 },
32431:
32432: #define osGetSystemTime ((VOID(WINAPI*)(LPSYSTEMTIME))aSyscall[29].pCurrent)
32433:
32434: #if !SQLITE_OS_WINCE
32435: { "GetSystemTimeAsFileTime", (SYSCALL)GetSystemTimeAsFileTime, 0 },
32436: #else
32437: { "GetSystemTimeAsFileTime", (SYSCALL)0, 0 },
32438: #endif
32439:
32440: #define osGetSystemTimeAsFileTime ((VOID(WINAPI*)( \
32441: LPFILETIME))aSyscall[30].pCurrent)
32442:
32443: #if defined(SQLITE_WIN32_HAS_ANSI)
32444: { "GetTempPathA", (SYSCALL)GetTempPathA, 0 },
32445: #else
32446: { "GetTempPathA", (SYSCALL)0, 0 },
32447: #endif
32448:
32449: #define osGetTempPathA ((DWORD(WINAPI*)(DWORD,LPSTR))aSyscall[31].pCurrent)
32450:
32451: #if defined(SQLITE_WIN32_HAS_WIDE)
32452: { "GetTempPathW", (SYSCALL)GetTempPathW, 0 },
32453: #else
32454: { "GetTempPathW", (SYSCALL)0, 0 },
32455: #endif
32456:
32457: #define osGetTempPathW ((DWORD(WINAPI*)(DWORD,LPWSTR))aSyscall[32].pCurrent)
32458:
32459: { "GetTickCount", (SYSCALL)GetTickCount, 0 },
32460:
32461: #define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[33].pCurrent)
32462:
32463: #if defined(SQLITE_WIN32_HAS_ANSI)
32464: { "GetVersionExA", (SYSCALL)GetVersionExA, 0 },
32465: #else
32466: { "GetVersionExA", (SYSCALL)0, 0 },
32467: #endif
32468:
32469: #define osGetVersionExA ((BOOL(WINAPI*)( \
32470: LPOSVERSIONINFOA))aSyscall[34].pCurrent)
32471:
32472: { "HeapAlloc", (SYSCALL)HeapAlloc, 0 },
32473:
32474: #define osHeapAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD, \
32475: SIZE_T))aSyscall[35].pCurrent)
32476:
32477: { "HeapCreate", (SYSCALL)HeapCreate, 0 },
32478:
32479: #define osHeapCreate ((HANDLE(WINAPI*)(DWORD,SIZE_T, \
32480: SIZE_T))aSyscall[36].pCurrent)
32481:
32482: { "HeapDestroy", (SYSCALL)HeapDestroy, 0 },
32483:
32484: #define osHeapDestroy ((BOOL(WINAPI*)(HANDLE))aSyscall[37].pCurrent)
32485:
32486: { "HeapFree", (SYSCALL)HeapFree, 0 },
32487:
32488: #define osHeapFree ((BOOL(WINAPI*)(HANDLE,DWORD,LPVOID))aSyscall[38].pCurrent)
32489:
32490: { "HeapReAlloc", (SYSCALL)HeapReAlloc, 0 },
32491:
32492: #define osHeapReAlloc ((LPVOID(WINAPI*)(HANDLE,DWORD,LPVOID, \
32493: SIZE_T))aSyscall[39].pCurrent)
32494:
32495: { "HeapSize", (SYSCALL)HeapSize, 0 },
32496:
32497: #define osHeapSize ((SIZE_T(WINAPI*)(HANDLE,DWORD, \
32498: LPCVOID))aSyscall[40].pCurrent)
32499:
32500: { "HeapValidate", (SYSCALL)HeapValidate, 0 },
32501:
32502: #define osHeapValidate ((BOOL(WINAPI*)(HANDLE,DWORD, \
32503: LPCVOID))aSyscall[41].pCurrent)
32504:
32505: #if defined(SQLITE_WIN32_HAS_ANSI)
32506: { "LoadLibraryA", (SYSCALL)LoadLibraryA, 0 },
32507: #else
32508: { "LoadLibraryA", (SYSCALL)0, 0 },
32509: #endif
32510:
32511: #define osLoadLibraryA ((HMODULE(WINAPI*)(LPCSTR))aSyscall[42].pCurrent)
32512:
32513: #if defined(SQLITE_WIN32_HAS_WIDE)
32514: { "LoadLibraryW", (SYSCALL)LoadLibraryW, 0 },
32515: #else
32516: { "LoadLibraryW", (SYSCALL)0, 0 },
32517: #endif
32518:
32519: #define osLoadLibraryW ((HMODULE(WINAPI*)(LPCWSTR))aSyscall[43].pCurrent)
32520:
32521: { "LocalFree", (SYSCALL)LocalFree, 0 },
32522:
32523: #define osLocalFree ((HLOCAL(WINAPI*)(HLOCAL))aSyscall[44].pCurrent)
32524:
32525: #if !SQLITE_OS_WINCE
32526: { "LockFile", (SYSCALL)LockFile, 0 },
32527:
32528: #define osLockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
32529: DWORD))aSyscall[45].pCurrent)
32530: #else
32531: { "LockFile", (SYSCALL)0, 0 },
32532: #endif
32533:
32534: #if !SQLITE_OS_WINCE
32535: { "LockFileEx", (SYSCALL)LockFileEx, 0 },
32536:
32537: #define osLockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD,DWORD, \
32538: LPOVERLAPPED))aSyscall[46].pCurrent)
32539: #else
32540: { "LockFileEx", (SYSCALL)0, 0 },
32541: #endif
32542:
32543: { "MapViewOfFile", (SYSCALL)MapViewOfFile, 0 },
32544:
32545: #define osMapViewOfFile ((LPVOID(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
32546: SIZE_T))aSyscall[47].pCurrent)
32547:
32548: { "MultiByteToWideChar", (SYSCALL)MultiByteToWideChar, 0 },
32549:
32550: #define osMultiByteToWideChar ((int(WINAPI*)(UINT,DWORD,LPCSTR,int,LPWSTR, \
32551: int))aSyscall[48].pCurrent)
32552:
32553: { "QueryPerformanceCounter", (SYSCALL)QueryPerformanceCounter, 0 },
32554:
32555: #define osQueryPerformanceCounter ((BOOL(WINAPI*)( \
32556: LARGE_INTEGER*))aSyscall[49].pCurrent)
32557:
32558: { "ReadFile", (SYSCALL)ReadFile, 0 },
32559:
32560: #define osReadFile ((BOOL(WINAPI*)(HANDLE,LPVOID,DWORD,LPDWORD, \
32561: LPOVERLAPPED))aSyscall[50].pCurrent)
32562:
32563: { "SetEndOfFile", (SYSCALL)SetEndOfFile, 0 },
32564:
32565: #define osSetEndOfFile ((BOOL(WINAPI*)(HANDLE))aSyscall[51].pCurrent)
32566:
32567: { "SetFilePointer", (SYSCALL)SetFilePointer, 0 },
32568:
32569: #define osSetFilePointer ((DWORD(WINAPI*)(HANDLE,LONG,PLONG, \
32570: DWORD))aSyscall[52].pCurrent)
32571:
32572: { "Sleep", (SYSCALL)Sleep, 0 },
32573:
32574: #define osSleep ((VOID(WINAPI*)(DWORD))aSyscall[53].pCurrent)
32575:
32576: { "SystemTimeToFileTime", (SYSCALL)SystemTimeToFileTime, 0 },
32577:
32578: #define osSystemTimeToFileTime ((BOOL(WINAPI*)(CONST SYSTEMTIME*, \
32579: LPFILETIME))aSyscall[54].pCurrent)
32580:
32581: #if !SQLITE_OS_WINCE
32582: { "UnlockFile", (SYSCALL)UnlockFile, 0 },
32583:
32584: #define osUnlockFile ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
32585: DWORD))aSyscall[55].pCurrent)
32586: #else
32587: { "UnlockFile", (SYSCALL)0, 0 },
32588: #endif
32589:
32590: #if !SQLITE_OS_WINCE
32591: { "UnlockFileEx", (SYSCALL)UnlockFileEx, 0 },
32592:
32593: #define osUnlockFileEx ((BOOL(WINAPI*)(HANDLE,DWORD,DWORD,DWORD, \
32594: LPOVERLAPPED))aSyscall[56].pCurrent)
32595: #else
32596: { "UnlockFileEx", (SYSCALL)0, 0 },
32597: #endif
32598:
32599: { "UnmapViewOfFile", (SYSCALL)UnmapViewOfFile, 0 },
32600:
32601: #define osUnmapViewOfFile ((BOOL(WINAPI*)(LPCVOID))aSyscall[57].pCurrent)
32602:
32603: { "WideCharToMultiByte", (SYSCALL)WideCharToMultiByte, 0 },
32604:
32605: #define osWideCharToMultiByte ((int(WINAPI*)(UINT,DWORD,LPCWSTR,int,LPSTR,int, \
32606: LPCSTR,LPBOOL))aSyscall[58].pCurrent)
32607:
32608: { "WriteFile", (SYSCALL)WriteFile, 0 },
32609:
32610: #define osWriteFile ((BOOL(WINAPI*)(HANDLE,LPCVOID,DWORD,LPDWORD, \
32611: LPOVERLAPPED))aSyscall[59].pCurrent)
32612:
32613: }; /* End of the overrideable system calls */
32614:
32615: /*
32616: ** This is the xSetSystemCall() method of sqlite3_vfs for all of the
32617: ** "win32" VFSes. Return SQLITE_OK opon successfully updating the
32618: ** system call pointer, or SQLITE_NOTFOUND if there is no configurable
32619: ** system call named zName.
32620: */
32621: static int winSetSystemCall(
32622: sqlite3_vfs *pNotUsed, /* The VFS pointer. Not used */
32623: const char *zName, /* Name of system call to override */
32624: sqlite3_syscall_ptr pNewFunc /* Pointer to new system call value */
32625: ){
32626: unsigned int i;
32627: int rc = SQLITE_NOTFOUND;
32628:
32629: UNUSED_PARAMETER(pNotUsed);
32630: if( zName==0 ){
32631: /* If no zName is given, restore all system calls to their default
32632: ** settings and return NULL
32633: */
32634: rc = SQLITE_OK;
32635: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
32636: if( aSyscall[i].pDefault ){
32637: aSyscall[i].pCurrent = aSyscall[i].pDefault;
32638: }
32639: }
32640: }else{
32641: /* If zName is specified, operate on only the one system call
32642: ** specified.
32643: */
32644: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
32645: if( strcmp(zName, aSyscall[i].zName)==0 ){
32646: if( aSyscall[i].pDefault==0 ){
32647: aSyscall[i].pDefault = aSyscall[i].pCurrent;
32648: }
32649: rc = SQLITE_OK;
32650: if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
32651: aSyscall[i].pCurrent = pNewFunc;
32652: break;
32653: }
32654: }
32655: }
32656: return rc;
32657: }
32658:
32659: /*
32660: ** Return the value of a system call. Return NULL if zName is not a
32661: ** recognized system call name. NULL is also returned if the system call
32662: ** is currently undefined.
32663: */
32664: static sqlite3_syscall_ptr winGetSystemCall(
32665: sqlite3_vfs *pNotUsed,
32666: const char *zName
32667: ){
32668: unsigned int i;
32669:
32670: UNUSED_PARAMETER(pNotUsed);
32671: for(i=0; i<sizeof(aSyscall)/sizeof(aSyscall[0]); i++){
32672: if( strcmp(zName, aSyscall[i].zName)==0 ) return aSyscall[i].pCurrent;
32673: }
32674: return 0;
32675: }
32676:
32677: /*
32678: ** Return the name of the first system call after zName. If zName==NULL
32679: ** then return the name of the first system call. Return NULL if zName
32680: ** is the last system call or if zName is not the name of a valid
32681: ** system call.
32682: */
32683: static const char *winNextSystemCall(sqlite3_vfs *p, const char *zName){
32684: int i = -1;
32685:
32686: UNUSED_PARAMETER(p);
32687: if( zName ){
32688: for(i=0; i<ArraySize(aSyscall)-1; i++){
32689: if( strcmp(zName, aSyscall[i].zName)==0 ) break;
32690: }
32691: }
32692: for(i++; i<ArraySize(aSyscall); i++){
32693: if( aSyscall[i].pCurrent!=0 ) return aSyscall[i].zName;
32694: }
32695: return 0;
32696: }
32697:
32698: /*
32699: ** Return true (non-zero) if we are running under WinNT, Win2K, WinXP,
32700: ** or WinCE. Return false (zero) for Win95, Win98, or WinME.
32701: **
32702: ** Here is an interesting observation: Win95, Win98, and WinME lack
32703: ** the LockFileEx() API. But we can still statically link against that
32704: ** API as long as we don't call it when running Win95/98/ME. A call to
32705: ** this routine is used to determine if the host is Win95/98/ME or
32706: ** WinNT/2K/XP so that we will know whether or not we can safely call
32707: ** the LockFileEx() API.
32708: */
32709: #if SQLITE_OS_WINCE
32710: # define isNT() (1)
32711: #else
32712: static int isNT(void){
32713: if( sqlite3_os_type==0 ){
32714: OSVERSIONINFOA sInfo;
32715: sInfo.dwOSVersionInfoSize = sizeof(sInfo);
32716: osGetVersionExA(&sInfo);
32717: sqlite3_os_type = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1;
32718: }
32719: return sqlite3_os_type==2;
32720: }
32721: #endif /* SQLITE_OS_WINCE */
32722:
32723: #ifdef SQLITE_WIN32_MALLOC
32724: /*
32725: ** Allocate nBytes of memory.
32726: */
32727: static void *winMemMalloc(int nBytes){
32728: HANDLE hHeap;
32729: void *p;
32730:
32731: winMemAssertMagic();
32732: hHeap = winMemGetHeap();
32733: assert( hHeap!=0 );
32734: assert( hHeap!=INVALID_HANDLE_VALUE );
32735: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
32736: assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
32737: #endif
32738: assert( nBytes>=0 );
32739: p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
32740: if( !p ){
32741: sqlite3_log(SQLITE_NOMEM, "failed to HeapAlloc %u bytes (%d), heap=%p",
32742: nBytes, osGetLastError(), (void*)hHeap);
32743: }
32744: return p;
32745: }
32746:
32747: /*
32748: ** Free memory.
32749: */
32750: static void winMemFree(void *pPrior){
32751: HANDLE hHeap;
32752:
32753: winMemAssertMagic();
32754: hHeap = winMemGetHeap();
32755: assert( hHeap!=0 );
32756: assert( hHeap!=INVALID_HANDLE_VALUE );
32757: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
32758: assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
32759: #endif
32760: if( !pPrior ) return; /* Passing NULL to HeapFree is undefined. */
32761: if( !osHeapFree(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) ){
32762: sqlite3_log(SQLITE_NOMEM, "failed to HeapFree block %p (%d), heap=%p",
32763: pPrior, osGetLastError(), (void*)hHeap);
32764: }
32765: }
32766:
32767: /*
32768: ** Change the size of an existing memory allocation
32769: */
32770: static void *winMemRealloc(void *pPrior, int nBytes){
32771: HANDLE hHeap;
32772: void *p;
32773:
32774: winMemAssertMagic();
32775: hHeap = winMemGetHeap();
32776: assert( hHeap!=0 );
32777: assert( hHeap!=INVALID_HANDLE_VALUE );
32778: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
32779: assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior) );
32780: #endif
32781: assert( nBytes>=0 );
32782: if( !pPrior ){
32783: p = osHeapAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, (SIZE_T)nBytes);
32784: }else{
32785: p = osHeapReAlloc(hHeap, SQLITE_WIN32_HEAP_FLAGS, pPrior, (SIZE_T)nBytes);
32786: }
32787: if( !p ){
32788: sqlite3_log(SQLITE_NOMEM, "failed to %s %u bytes (%d), heap=%p",
32789: pPrior ? "HeapReAlloc" : "HeapAlloc", nBytes, osGetLastError(),
32790: (void*)hHeap);
32791: }
32792: return p;
32793: }
32794:
32795: /*
32796: ** Return the size of an outstanding allocation, in bytes.
32797: */
32798: static int winMemSize(void *p){
32799: HANDLE hHeap;
32800: SIZE_T n;
32801:
32802: winMemAssertMagic();
32803: hHeap = winMemGetHeap();
32804: assert( hHeap!=0 );
32805: assert( hHeap!=INVALID_HANDLE_VALUE );
32806: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
32807: assert ( osHeapValidate(hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
32808: #endif
32809: if( !p ) return 0;
32810: n = osHeapSize(hHeap, SQLITE_WIN32_HEAP_FLAGS, p);
32811: if( n==(SIZE_T)-1 ){
32812: sqlite3_log(SQLITE_NOMEM, "failed to HeapSize block %p (%d), heap=%p",
32813: p, osGetLastError(), (void*)hHeap);
32814: return 0;
32815: }
32816: return (int)n;
32817: }
32818:
32819: /*
32820: ** Round up a request size to the next valid allocation size.
32821: */
32822: static int winMemRoundup(int n){
32823: return n;
32824: }
32825:
32826: /*
32827: ** Initialize this module.
32828: */
32829: static int winMemInit(void *pAppData){
32830: winMemData *pWinMemData = (winMemData *)pAppData;
32831:
32832: if( !pWinMemData ) return SQLITE_ERROR;
32833: assert( pWinMemData->magic==WINMEM_MAGIC );
32834: if( !pWinMemData->hHeap ){
32835: pWinMemData->hHeap = osHeapCreate(SQLITE_WIN32_HEAP_FLAGS,
32836: SQLITE_WIN32_HEAP_INIT_SIZE,
32837: SQLITE_WIN32_HEAP_MAX_SIZE);
32838: if( !pWinMemData->hHeap ){
32839: sqlite3_log(SQLITE_NOMEM,
32840: "failed to HeapCreate (%d), flags=%u, initSize=%u, maxSize=%u",
32841: osGetLastError(), SQLITE_WIN32_HEAP_FLAGS,
32842: SQLITE_WIN32_HEAP_INIT_SIZE, SQLITE_WIN32_HEAP_MAX_SIZE);
32843: return SQLITE_NOMEM;
32844: }
32845: pWinMemData->bOwned = TRUE;
32846: }
32847: assert( pWinMemData->hHeap!=0 );
32848: assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
32849: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
32850: assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
32851: #endif
32852: return SQLITE_OK;
32853: }
32854:
32855: /*
32856: ** Deinitialize this module.
32857: */
32858: static void winMemShutdown(void *pAppData){
32859: winMemData *pWinMemData = (winMemData *)pAppData;
32860:
32861: if( !pWinMemData ) return;
32862: if( pWinMemData->hHeap ){
32863: assert( pWinMemData->hHeap!=INVALID_HANDLE_VALUE );
32864: #ifdef SQLITE_WIN32_MALLOC_VALIDATE
32865: assert( osHeapValidate(pWinMemData->hHeap, SQLITE_WIN32_HEAP_FLAGS, NULL) );
32866: #endif
32867: if( pWinMemData->bOwned ){
32868: if( !osHeapDestroy(pWinMemData->hHeap) ){
32869: sqlite3_log(SQLITE_NOMEM, "failed to HeapDestroy (%d), heap=%p",
32870: osGetLastError(), (void*)pWinMemData->hHeap);
32871: }
32872: pWinMemData->bOwned = FALSE;
32873: }
32874: pWinMemData->hHeap = NULL;
32875: }
32876: }
32877:
32878: /*
32879: ** Populate the low-level memory allocation function pointers in
32880: ** sqlite3GlobalConfig.m with pointers to the routines in this file. The
32881: ** arguments specify the block of memory to manage.
32882: **
32883: ** This routine is only called by sqlite3_config(), and therefore
32884: ** is not required to be threadsafe (it is not).
32885: */
32886: SQLITE_PRIVATE const sqlite3_mem_methods *sqlite3MemGetWin32(void){
32887: static const sqlite3_mem_methods winMemMethods = {
32888: winMemMalloc,
32889: winMemFree,
32890: winMemRealloc,
32891: winMemSize,
32892: winMemRoundup,
32893: winMemInit,
32894: winMemShutdown,
32895: &win_mem_data
32896: };
32897: return &winMemMethods;
32898: }
32899:
32900: SQLITE_PRIVATE void sqlite3MemSetDefault(void){
32901: sqlite3_config(SQLITE_CONFIG_MALLOC, sqlite3MemGetWin32());
32902: }
32903: #endif /* SQLITE_WIN32_MALLOC */
32904:
32905: /*
32906: ** Convert a UTF-8 string to Microsoft Unicode (UTF-16?).
32907: **
32908: ** Space to hold the returned string is obtained from malloc.
32909: */
32910: static LPWSTR utf8ToUnicode(const char *zFilename){
32911: int nChar;
32912: LPWSTR zWideFilename;
32913:
32914: nChar = osMultiByteToWideChar(CP_UTF8, 0, zFilename, -1, NULL, 0);
32915: if( nChar==0 ){
32916: return 0;
32917: }
32918: zWideFilename = sqlite3_malloc( nChar*sizeof(zWideFilename[0]) );
32919: if( zWideFilename==0 ){
32920: return 0;
32921: }
32922: nChar = osMultiByteToWideChar(CP_UTF8, 0, zFilename, -1, zWideFilename,
32923: nChar);
32924: if( nChar==0 ){
32925: sqlite3_free(zWideFilename);
32926: zWideFilename = 0;
32927: }
32928: return zWideFilename;
32929: }
32930:
32931: /*
32932: ** Convert Microsoft Unicode to UTF-8. Space to hold the returned string is
32933: ** obtained from sqlite3_malloc().
32934: */
32935: static char *unicodeToUtf8(LPCWSTR zWideFilename){
32936: int nByte;
32937: char *zFilename;
32938:
32939: nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, 0, 0, 0, 0);
32940: if( nByte == 0 ){
32941: return 0;
32942: }
32943: zFilename = sqlite3_malloc( nByte );
32944: if( zFilename==0 ){
32945: return 0;
32946: }
32947: nByte = osWideCharToMultiByte(CP_UTF8, 0, zWideFilename, -1, zFilename, nByte,
32948: 0, 0);
32949: if( nByte == 0 ){
32950: sqlite3_free(zFilename);
32951: zFilename = 0;
32952: }
32953: return zFilename;
32954: }
32955:
32956: /*
32957: ** Convert an ANSI string to Microsoft Unicode, based on the
32958: ** current codepage settings for file apis.
32959: **
32960: ** Space to hold the returned string is obtained
32961: ** from sqlite3_malloc.
32962: */
32963: static LPWSTR mbcsToUnicode(const char *zFilename){
32964: int nByte;
32965: LPWSTR zMbcsFilename;
32966: int codepage = osAreFileApisANSI() ? CP_ACP : CP_OEMCP;
32967:
32968: nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, NULL,
32969: 0)*sizeof(WCHAR);
32970: if( nByte==0 ){
32971: return 0;
32972: }
32973: zMbcsFilename = sqlite3_malloc( nByte*sizeof(zMbcsFilename[0]) );
32974: if( zMbcsFilename==0 ){
32975: return 0;
32976: }
32977: nByte = osMultiByteToWideChar(codepage, 0, zFilename, -1, zMbcsFilename,
32978: nByte);
32979: if( nByte==0 ){
32980: sqlite3_free(zMbcsFilename);
32981: zMbcsFilename = 0;
32982: }
32983: return zMbcsFilename;
32984: }
32985:
32986: /*
32987: ** Convert Microsoft Unicode to multi-byte character string, based on the
32988: ** user's ANSI codepage.
32989: **
32990: ** Space to hold the returned string is obtained from
32991: ** sqlite3_malloc().
32992: */
32993: static char *unicodeToMbcs(LPCWSTR zWideFilename){
32994: int nByte;
32995: char *zFilename;
32996: int codepage = osAreFileApisANSI() ? CP_ACP : CP_OEMCP;
32997:
32998: nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, 0, 0, 0, 0);
32999: if( nByte == 0 ){
33000: return 0;
33001: }
33002: zFilename = sqlite3_malloc( nByte );
33003: if( zFilename==0 ){
33004: return 0;
33005: }
33006: nByte = osWideCharToMultiByte(codepage, 0, zWideFilename, -1, zFilename,
33007: nByte, 0, 0);
33008: if( nByte == 0 ){
33009: sqlite3_free(zFilename);
33010: zFilename = 0;
33011: }
33012: return zFilename;
33013: }
33014:
33015: /*
33016: ** Convert multibyte character string to UTF-8. Space to hold the
33017: ** returned string is obtained from sqlite3_malloc().
33018: */
33019: SQLITE_API char *sqlite3_win32_mbcs_to_utf8(const char *zFilename){
33020: char *zFilenameUtf8;
33021: LPWSTR zTmpWide;
33022:
33023: zTmpWide = mbcsToUnicode(zFilename);
33024: if( zTmpWide==0 ){
33025: return 0;
33026: }
33027: zFilenameUtf8 = unicodeToUtf8(zTmpWide);
33028: sqlite3_free(zTmpWide);
33029: return zFilenameUtf8;
33030: }
33031:
33032: /*
33033: ** Convert UTF-8 to multibyte character string. Space to hold the
33034: ** returned string is obtained from sqlite3_malloc().
33035: */
33036: SQLITE_API char *sqlite3_win32_utf8_to_mbcs(const char *zFilename){
33037: char *zFilenameMbcs;
33038: LPWSTR zTmpWide;
33039:
33040: zTmpWide = utf8ToUnicode(zFilename);
33041: if( zTmpWide==0 ){
33042: return 0;
33043: }
33044: zFilenameMbcs = unicodeToMbcs(zTmpWide);
33045: sqlite3_free(zTmpWide);
33046: return zFilenameMbcs;
33047: }
33048:
33049:
33050: /*
33051: ** The return value of getLastErrorMsg
33052: ** is zero if the error message fits in the buffer, or non-zero
33053: ** otherwise (if the message was truncated).
33054: */
33055: static int getLastErrorMsg(DWORD lastErrno, int nBuf, char *zBuf){
33056: /* FormatMessage returns 0 on failure. Otherwise it
33057: ** returns the number of TCHARs written to the output
33058: ** buffer, excluding the terminating null char.
33059: */
33060: DWORD dwLen = 0;
33061: char *zOut = 0;
33062:
33063: if( isNT() ){
33064: LPWSTR zTempWide = NULL;
33065: dwLen = osFormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
33066: FORMAT_MESSAGE_FROM_SYSTEM |
33067: FORMAT_MESSAGE_IGNORE_INSERTS,
33068: NULL,
33069: lastErrno,
33070: 0,
33071: (LPWSTR) &zTempWide,
33072: 0,
33073: 0);
33074: if( dwLen > 0 ){
33075: /* allocate a buffer and convert to UTF8 */
33076: sqlite3BeginBenignMalloc();
33077: zOut = unicodeToUtf8(zTempWide);
33078: sqlite3EndBenignMalloc();
33079: /* free the system buffer allocated by FormatMessage */
33080: osLocalFree(zTempWide);
33081: }
33082: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
33083: ** Since the ANSI version of these Windows API do not exist for WINCE,
33084: ** it's important to not reference them for WINCE builds.
33085: */
33086: #if SQLITE_OS_WINCE==0
33087: }else{
33088: char *zTemp = NULL;
33089: dwLen = osFormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
33090: FORMAT_MESSAGE_FROM_SYSTEM |
33091: FORMAT_MESSAGE_IGNORE_INSERTS,
33092: NULL,
33093: lastErrno,
33094: 0,
33095: (LPSTR) &zTemp,
33096: 0,
33097: 0);
33098: if( dwLen > 0 ){
33099: /* allocate a buffer and convert to UTF8 */
33100: sqlite3BeginBenignMalloc();
33101: zOut = sqlite3_win32_mbcs_to_utf8(zTemp);
33102: sqlite3EndBenignMalloc();
33103: /* free the system buffer allocated by FormatMessage */
33104: osLocalFree(zTemp);
33105: }
33106: #endif
33107: }
33108: if( 0 == dwLen ){
33109: sqlite3_snprintf(nBuf, zBuf, "OsError 0x%x (%u)", lastErrno, lastErrno);
33110: }else{
33111: /* copy a maximum of nBuf chars to output buffer */
33112: sqlite3_snprintf(nBuf, zBuf, "%s", zOut);
33113: /* free the UTF8 buffer */
33114: sqlite3_free(zOut);
33115: }
33116: return 0;
33117: }
33118:
33119: /*
33120: **
33121: ** This function - winLogErrorAtLine() - is only ever called via the macro
33122: ** winLogError().
33123: **
33124: ** This routine is invoked after an error occurs in an OS function.
33125: ** It logs a message using sqlite3_log() containing the current value of
33126: ** error code and, if possible, the human-readable equivalent from
33127: ** FormatMessage.
33128: **
33129: ** The first argument passed to the macro should be the error code that
33130: ** will be returned to SQLite (e.g. SQLITE_IOERR_DELETE, SQLITE_CANTOPEN).
33131: ** The two subsequent arguments should be the name of the OS function that
33132: ** failed and the the associated file-system path, if any.
33133: */
33134: #define winLogError(a,b,c,d) winLogErrorAtLine(a,b,c,d,__LINE__)
33135: static int winLogErrorAtLine(
33136: int errcode, /* SQLite error code */
33137: DWORD lastErrno, /* Win32 last error */
33138: const char *zFunc, /* Name of OS function that failed */
33139: const char *zPath, /* File path associated with error */
33140: int iLine /* Source line number where error occurred */
33141: ){
33142: char zMsg[500]; /* Human readable error text */
33143: int i; /* Loop counter */
33144:
33145: zMsg[0] = 0;
33146: getLastErrorMsg(lastErrno, sizeof(zMsg), zMsg);
33147: assert( errcode!=SQLITE_OK );
33148: if( zPath==0 ) zPath = "";
33149: for(i=0; zMsg[i] && zMsg[i]!='\r' && zMsg[i]!='\n'; i++){}
33150: zMsg[i] = 0;
33151: sqlite3_log(errcode,
33152: "os_win.c:%d: (%d) %s(%s) - %s",
33153: iLine, lastErrno, zFunc, zPath, zMsg
33154: );
33155:
33156: return errcode;
33157: }
33158:
33159: /*
33160: ** The number of times that a ReadFile(), WriteFile(), and DeleteFile()
33161: ** will be retried following a locking error - probably caused by
33162: ** antivirus software. Also the initial delay before the first retry.
33163: ** The delay increases linearly with each retry.
33164: */
33165: #ifndef SQLITE_WIN32_IOERR_RETRY
33166: # define SQLITE_WIN32_IOERR_RETRY 10
33167: #endif
33168: #ifndef SQLITE_WIN32_IOERR_RETRY_DELAY
33169: # define SQLITE_WIN32_IOERR_RETRY_DELAY 25
33170: #endif
33171: static int win32IoerrRetry = SQLITE_WIN32_IOERR_RETRY;
33172: static int win32IoerrRetryDelay = SQLITE_WIN32_IOERR_RETRY_DELAY;
33173:
33174: /*
33175: ** If a ReadFile() or WriteFile() error occurs, invoke this routine
33176: ** to see if it should be retried. Return TRUE to retry. Return FALSE
33177: ** to give up with an error.
33178: */
33179: static int retryIoerr(int *pnRetry, DWORD *pError){
33180: DWORD e = osGetLastError();
33181: if( *pnRetry>=win32IoerrRetry ){
33182: if( pError ){
33183: *pError = e;
33184: }
33185: return 0;
33186: }
33187: if( e==ERROR_ACCESS_DENIED ||
33188: e==ERROR_LOCK_VIOLATION ||
33189: e==ERROR_SHARING_VIOLATION ){
33190: osSleep(win32IoerrRetryDelay*(1+*pnRetry));
33191: ++*pnRetry;
33192: return 1;
33193: }
33194: if( pError ){
33195: *pError = e;
33196: }
33197: return 0;
33198: }
33199:
33200: /*
33201: ** Log a I/O error retry episode.
33202: */
33203: static void logIoerr(int nRetry){
33204: if( nRetry ){
33205: sqlite3_log(SQLITE_IOERR,
33206: "delayed %dms for lock/sharing conflict",
33207: win32IoerrRetryDelay*nRetry*(nRetry+1)/2
33208: );
33209: }
33210: }
33211:
33212: #if SQLITE_OS_WINCE
33213: /*************************************************************************
33214: ** This section contains code for WinCE only.
33215: */
33216: /*
33217: ** Windows CE does not have a localtime() function. So create a
33218: ** substitute.
33219: */
33220: /* #include <time.h> */
33221: struct tm *__cdecl localtime(const time_t *t)
33222: {
33223: static struct tm y;
33224: FILETIME uTm, lTm;
33225: SYSTEMTIME pTm;
33226: sqlite3_int64 t64;
33227: t64 = *t;
33228: t64 = (t64 + 11644473600)*10000000;
33229: uTm.dwLowDateTime = (DWORD)(t64 & 0xFFFFFFFF);
33230: uTm.dwHighDateTime= (DWORD)(t64 >> 32);
33231: osFileTimeToLocalFileTime(&uTm,&lTm);
33232: osFileTimeToSystemTime(&lTm,&pTm);
33233: y.tm_year = pTm.wYear - 1900;
33234: y.tm_mon = pTm.wMonth - 1;
33235: y.tm_wday = pTm.wDayOfWeek;
33236: y.tm_mday = pTm.wDay;
33237: y.tm_hour = pTm.wHour;
33238: y.tm_min = pTm.wMinute;
33239: y.tm_sec = pTm.wSecond;
33240: return &y;
33241: }
33242:
33243: #define HANDLE_TO_WINFILE(a) (winFile*)&((char*)a)[-(int)offsetof(winFile,h)]
33244:
33245: /*
33246: ** Acquire a lock on the handle h
33247: */
33248: static void winceMutexAcquire(HANDLE h){
33249: DWORD dwErr;
33250: do {
33251: dwErr = WaitForSingleObject(h, INFINITE);
33252: } while (dwErr != WAIT_OBJECT_0 && dwErr != WAIT_ABANDONED);
33253: }
33254: /*
33255: ** Release a lock acquired by winceMutexAcquire()
33256: */
33257: #define winceMutexRelease(h) ReleaseMutex(h)
33258:
33259: /*
33260: ** Create the mutex and shared memory used for locking in the file
33261: ** descriptor pFile
33262: */
33263: static BOOL winceCreateLock(const char *zFilename, winFile *pFile){
33264: LPWSTR zTok;
33265: LPWSTR zName;
33266: BOOL bInit = TRUE;
33267:
33268: zName = utf8ToUnicode(zFilename);
33269: if( zName==0 ){
33270: /* out of memory */
33271: return FALSE;
33272: }
33273:
33274: /* Initialize the local lockdata */
33275: memset(&pFile->local, 0, sizeof(pFile->local));
33276:
33277: /* Replace the backslashes from the filename and lowercase it
33278: ** to derive a mutex name. */
33279: zTok = osCharLowerW(zName);
33280: for (;*zTok;zTok++){
33281: if (*zTok == '\\') *zTok = '_';
33282: }
33283:
33284: /* Create/open the named mutex */
33285: pFile->hMutex = osCreateMutexW(NULL, FALSE, zName);
33286: if (!pFile->hMutex){
33287: pFile->lastErrno = osGetLastError();
33288: winLogError(SQLITE_ERROR, pFile->lastErrno, "winceCreateLock1", zFilename);
33289: sqlite3_free(zName);
33290: return FALSE;
33291: }
33292:
33293: /* Acquire the mutex before continuing */
33294: winceMutexAcquire(pFile->hMutex);
33295:
33296: /* Since the names of named mutexes, semaphores, file mappings etc are
33297: ** case-sensitive, take advantage of that by uppercasing the mutex name
33298: ** and using that as the shared filemapping name.
33299: */
33300: osCharUpperW(zName);
33301: pFile->hShared = osCreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
33302: PAGE_READWRITE, 0, sizeof(winceLock),
33303: zName);
33304:
33305: /* Set a flag that indicates we're the first to create the memory so it
33306: ** must be zero-initialized */
33307: if (osGetLastError() == ERROR_ALREADY_EXISTS){
33308: bInit = FALSE;
33309: }
33310:
33311: sqlite3_free(zName);
33312:
33313: /* If we succeeded in making the shared memory handle, map it. */
33314: if (pFile->hShared){
33315: pFile->shared = (winceLock*)osMapViewOfFile(pFile->hShared,
33316: FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
33317: /* If mapping failed, close the shared memory handle and erase it */
33318: if (!pFile->shared){
33319: pFile->lastErrno = osGetLastError();
33320: winLogError(SQLITE_ERROR, pFile->lastErrno,
33321: "winceCreateLock2", zFilename);
33322: osCloseHandle(pFile->hShared);
33323: pFile->hShared = NULL;
33324: }
33325: }
33326:
33327: /* If shared memory could not be created, then close the mutex and fail */
33328: if (pFile->hShared == NULL){
33329: winceMutexRelease(pFile->hMutex);
33330: osCloseHandle(pFile->hMutex);
33331: pFile->hMutex = NULL;
33332: return FALSE;
33333: }
33334:
33335: /* Initialize the shared memory if we're supposed to */
33336: if (bInit) {
33337: memset(pFile->shared, 0, sizeof(winceLock));
33338: }
33339:
33340: winceMutexRelease(pFile->hMutex);
33341: return TRUE;
33342: }
33343:
33344: /*
33345: ** Destroy the part of winFile that deals with wince locks
33346: */
33347: static void winceDestroyLock(winFile *pFile){
33348: if (pFile->hMutex){
33349: /* Acquire the mutex */
33350: winceMutexAcquire(pFile->hMutex);
33351:
33352: /* The following blocks should probably assert in debug mode, but they
33353: are to cleanup in case any locks remained open */
33354: if (pFile->local.nReaders){
33355: pFile->shared->nReaders --;
33356: }
33357: if (pFile->local.bReserved){
33358: pFile->shared->bReserved = FALSE;
33359: }
33360: if (pFile->local.bPending){
33361: pFile->shared->bPending = FALSE;
33362: }
33363: if (pFile->local.bExclusive){
33364: pFile->shared->bExclusive = FALSE;
33365: }
33366:
33367: /* De-reference and close our copy of the shared memory handle */
33368: osUnmapViewOfFile(pFile->shared);
33369: osCloseHandle(pFile->hShared);
33370:
33371: /* Done with the mutex */
33372: winceMutexRelease(pFile->hMutex);
33373: osCloseHandle(pFile->hMutex);
33374: pFile->hMutex = NULL;
33375: }
33376: }
33377:
33378: /*
33379: ** An implementation of the LockFile() API of Windows for CE
33380: */
33381: static BOOL winceLockFile(
33382: HANDLE *phFile,
33383: DWORD dwFileOffsetLow,
33384: DWORD dwFileOffsetHigh,
33385: DWORD nNumberOfBytesToLockLow,
33386: DWORD nNumberOfBytesToLockHigh
33387: ){
33388: winFile *pFile = HANDLE_TO_WINFILE(phFile);
33389: BOOL bReturn = FALSE;
33390:
33391: UNUSED_PARAMETER(dwFileOffsetHigh);
33392: UNUSED_PARAMETER(nNumberOfBytesToLockHigh);
33393:
33394: if (!pFile->hMutex) return TRUE;
33395: winceMutexAcquire(pFile->hMutex);
33396:
33397: /* Wanting an exclusive lock? */
33398: if (dwFileOffsetLow == (DWORD)SHARED_FIRST
33399: && nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){
33400: if (pFile->shared->nReaders == 0 && pFile->shared->bExclusive == 0){
33401: pFile->shared->bExclusive = TRUE;
33402: pFile->local.bExclusive = TRUE;
33403: bReturn = TRUE;
33404: }
33405: }
33406:
33407: /* Want a read-only lock? */
33408: else if (dwFileOffsetLow == (DWORD)SHARED_FIRST &&
33409: nNumberOfBytesToLockLow == 1){
33410: if (pFile->shared->bExclusive == 0){
33411: pFile->local.nReaders ++;
33412: if (pFile->local.nReaders == 1){
33413: pFile->shared->nReaders ++;
33414: }
33415: bReturn = TRUE;
33416: }
33417: }
33418:
33419: /* Want a pending lock? */
33420: else if (dwFileOffsetLow == (DWORD)PENDING_BYTE && nNumberOfBytesToLockLow == 1){
33421: /* If no pending lock has been acquired, then acquire it */
33422: if (pFile->shared->bPending == 0) {
33423: pFile->shared->bPending = TRUE;
33424: pFile->local.bPending = TRUE;
33425: bReturn = TRUE;
33426: }
33427: }
33428:
33429: /* Want a reserved lock? */
33430: else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE && nNumberOfBytesToLockLow == 1){
33431: if (pFile->shared->bReserved == 0) {
33432: pFile->shared->bReserved = TRUE;
33433: pFile->local.bReserved = TRUE;
33434: bReturn = TRUE;
33435: }
33436: }
33437:
33438: winceMutexRelease(pFile->hMutex);
33439: return bReturn;
33440: }
33441:
33442: /*
33443: ** An implementation of the UnlockFile API of Windows for CE
33444: */
33445: static BOOL winceUnlockFile(
33446: HANDLE *phFile,
33447: DWORD dwFileOffsetLow,
33448: DWORD dwFileOffsetHigh,
33449: DWORD nNumberOfBytesToUnlockLow,
33450: DWORD nNumberOfBytesToUnlockHigh
33451: ){
33452: winFile *pFile = HANDLE_TO_WINFILE(phFile);
33453: BOOL bReturn = FALSE;
33454:
33455: UNUSED_PARAMETER(dwFileOffsetHigh);
33456: UNUSED_PARAMETER(nNumberOfBytesToUnlockHigh);
33457:
33458: if (!pFile->hMutex) return TRUE;
33459: winceMutexAcquire(pFile->hMutex);
33460:
33461: /* Releasing a reader lock or an exclusive lock */
33462: if (dwFileOffsetLow == (DWORD)SHARED_FIRST){
33463: /* Did we have an exclusive lock? */
33464: if (pFile->local.bExclusive){
33465: assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE);
33466: pFile->local.bExclusive = FALSE;
33467: pFile->shared->bExclusive = FALSE;
33468: bReturn = TRUE;
33469: }
33470:
33471: /* Did we just have a reader lock? */
33472: else if (pFile->local.nReaders){
33473: assert(nNumberOfBytesToUnlockLow == (DWORD)SHARED_SIZE || nNumberOfBytesToUnlockLow == 1);
33474: pFile->local.nReaders --;
33475: if (pFile->local.nReaders == 0)
33476: {
33477: pFile->shared->nReaders --;
33478: }
33479: bReturn = TRUE;
33480: }
33481: }
33482:
33483: /* Releasing a pending lock */
33484: else if (dwFileOffsetLow == (DWORD)PENDING_BYTE && nNumberOfBytesToUnlockLow == 1){
33485: if (pFile->local.bPending){
33486: pFile->local.bPending = FALSE;
33487: pFile->shared->bPending = FALSE;
33488: bReturn = TRUE;
33489: }
33490: }
33491: /* Releasing a reserved lock */
33492: else if (dwFileOffsetLow == (DWORD)RESERVED_BYTE && nNumberOfBytesToUnlockLow == 1){
33493: if (pFile->local.bReserved) {
33494: pFile->local.bReserved = FALSE;
33495: pFile->shared->bReserved = FALSE;
33496: bReturn = TRUE;
33497: }
33498: }
33499:
33500: winceMutexRelease(pFile->hMutex);
33501: return bReturn;
33502: }
33503:
33504: /*
33505: ** An implementation of the LockFileEx() API of Windows for CE
33506: */
33507: static BOOL winceLockFileEx(
33508: HANDLE *phFile,
33509: DWORD dwFlags,
33510: DWORD dwReserved,
33511: DWORD nNumberOfBytesToLockLow,
33512: DWORD nNumberOfBytesToLockHigh,
33513: LPOVERLAPPED lpOverlapped
33514: ){
33515: UNUSED_PARAMETER(dwReserved);
33516: UNUSED_PARAMETER(nNumberOfBytesToLockHigh);
33517:
33518: /* If the caller wants a shared read lock, forward this call
33519: ** to winceLockFile */
33520: if (lpOverlapped->Offset == (DWORD)SHARED_FIRST &&
33521: dwFlags == 1 &&
33522: nNumberOfBytesToLockLow == (DWORD)SHARED_SIZE){
33523: return winceLockFile(phFile, SHARED_FIRST, 0, 1, 0);
33524: }
33525: return FALSE;
33526: }
33527: /*
33528: ** End of the special code for wince
33529: *****************************************************************************/
33530: #endif /* SQLITE_OS_WINCE */
33531:
33532: /*****************************************************************************
33533: ** The next group of routines implement the I/O methods specified
33534: ** by the sqlite3_io_methods object.
33535: ******************************************************************************/
33536:
33537: /*
33538: ** Some Microsoft compilers lack this definition.
33539: */
33540: #ifndef INVALID_SET_FILE_POINTER
33541: # define INVALID_SET_FILE_POINTER ((DWORD)-1)
33542: #endif
33543:
33544: /*
33545: ** Move the current position of the file handle passed as the first
33546: ** argument to offset iOffset within the file. If successful, return 0.
33547: ** Otherwise, set pFile->lastErrno and return non-zero.
33548: */
33549: static int seekWinFile(winFile *pFile, sqlite3_int64 iOffset){
33550: LONG upperBits; /* Most sig. 32 bits of new offset */
33551: LONG lowerBits; /* Least sig. 32 bits of new offset */
33552: DWORD dwRet; /* Value returned by SetFilePointer() */
33553: DWORD lastErrno; /* Value returned by GetLastError() */
33554:
33555: upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
33556: lowerBits = (LONG)(iOffset & 0xffffffff);
33557:
33558: /* API oddity: If successful, SetFilePointer() returns a dword
33559: ** containing the lower 32-bits of the new file-offset. Or, if it fails,
33560: ** it returns INVALID_SET_FILE_POINTER. However according to MSDN,
33561: ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine
33562: ** whether an error has actually occured, it is also necessary to call
33563: ** GetLastError().
33564: */
33565: dwRet = osSetFilePointer(pFile->h, lowerBits, &upperBits, FILE_BEGIN);
33566:
33567: if( (dwRet==INVALID_SET_FILE_POINTER
33568: && ((lastErrno = osGetLastError())!=NO_ERROR)) ){
33569: pFile->lastErrno = lastErrno;
33570: winLogError(SQLITE_IOERR_SEEK, pFile->lastErrno,
33571: "seekWinFile", pFile->zPath);
33572: return 1;
33573: }
33574:
33575: return 0;
33576: }
33577:
33578: /*
33579: ** Close a file.
33580: **
33581: ** It is reported that an attempt to close a handle might sometimes
33582: ** fail. This is a very unreasonable result, but Windows is notorious
33583: ** for being unreasonable so I do not doubt that it might happen. If
33584: ** the close fails, we pause for 100 milliseconds and try again. As
33585: ** many as MX_CLOSE_ATTEMPT attempts to close the handle are made before
33586: ** giving up and returning an error.
33587: */
33588: #define MX_CLOSE_ATTEMPT 3
33589: static int winClose(sqlite3_file *id){
33590: int rc, cnt = 0;
33591: winFile *pFile = (winFile*)id;
33592:
33593: assert( id!=0 );
33594: assert( pFile->pShm==0 );
33595: OSTRACE(("CLOSE %d\n", pFile->h));
33596: do{
33597: rc = osCloseHandle(pFile->h);
33598: /* SimulateIOError( rc=0; cnt=MX_CLOSE_ATTEMPT; ); */
33599: }while( rc==0 && ++cnt < MX_CLOSE_ATTEMPT && (osSleep(100), 1) );
33600: #if SQLITE_OS_WINCE
33601: #define WINCE_DELETION_ATTEMPTS 3
33602: winceDestroyLock(pFile);
33603: if( pFile->zDeleteOnClose ){
33604: int cnt = 0;
33605: while(
33606: osDeleteFileW(pFile->zDeleteOnClose)==0
33607: && osGetFileAttributesW(pFile->zDeleteOnClose)!=0xffffffff
33608: && cnt++ < WINCE_DELETION_ATTEMPTS
33609: ){
33610: osSleep(100); /* Wait a little before trying again */
33611: }
33612: sqlite3_free(pFile->zDeleteOnClose);
33613: }
33614: #endif
33615: OSTRACE(("CLOSE %d %s\n", pFile->h, rc ? "ok" : "failed"));
33616: OpenCounter(-1);
33617: return rc ? SQLITE_OK
33618: : winLogError(SQLITE_IOERR_CLOSE, osGetLastError(),
33619: "winClose", pFile->zPath);
33620: }
33621:
33622: /*
33623: ** Read data from a file into a buffer. Return SQLITE_OK if all
33624: ** bytes were read successfully and SQLITE_IOERR if anything goes
33625: ** wrong.
33626: */
33627: static int winRead(
33628: sqlite3_file *id, /* File to read from */
33629: void *pBuf, /* Write content into this buffer */
33630: int amt, /* Number of bytes to read */
33631: sqlite3_int64 offset /* Begin reading at this offset */
33632: ){
33633: winFile *pFile = (winFile*)id; /* file handle */
33634: DWORD nRead; /* Number of bytes actually read from file */
33635: int nRetry = 0; /* Number of retrys */
33636:
33637: assert( id!=0 );
33638: SimulateIOError(return SQLITE_IOERR_READ);
33639: OSTRACE(("READ %d lock=%d\n", pFile->h, pFile->locktype));
33640:
33641: if( seekWinFile(pFile, offset) ){
33642: return SQLITE_FULL;
33643: }
33644: while( !osReadFile(pFile->h, pBuf, amt, &nRead, 0) ){
33645: DWORD lastErrno;
33646: if( retryIoerr(&nRetry, &lastErrno) ) continue;
33647: pFile->lastErrno = lastErrno;
33648: return winLogError(SQLITE_IOERR_READ, pFile->lastErrno,
33649: "winRead", pFile->zPath);
33650: }
33651: logIoerr(nRetry);
33652: if( nRead<(DWORD)amt ){
33653: /* Unread parts of the buffer must be zero-filled */
33654: memset(&((char*)pBuf)[nRead], 0, amt-nRead);
33655: return SQLITE_IOERR_SHORT_READ;
33656: }
33657:
33658: return SQLITE_OK;
33659: }
33660:
33661: /*
33662: ** Write data from a buffer into a file. Return SQLITE_OK on success
33663: ** or some other error code on failure.
33664: */
33665: static int winWrite(
33666: sqlite3_file *id, /* File to write into */
33667: const void *pBuf, /* The bytes to be written */
33668: int amt, /* Number of bytes to write */
33669: sqlite3_int64 offset /* Offset into the file to begin writing at */
33670: ){
33671: int rc; /* True if error has occured, else false */
33672: winFile *pFile = (winFile*)id; /* File handle */
33673: int nRetry = 0; /* Number of retries */
33674:
33675: assert( amt>0 );
33676: assert( pFile );
33677: SimulateIOError(return SQLITE_IOERR_WRITE);
33678: SimulateDiskfullError(return SQLITE_FULL);
33679:
33680: OSTRACE(("WRITE %d lock=%d\n", pFile->h, pFile->locktype));
33681:
33682: rc = seekWinFile(pFile, offset);
33683: if( rc==0 ){
33684: u8 *aRem = (u8 *)pBuf; /* Data yet to be written */
33685: int nRem = amt; /* Number of bytes yet to be written */
33686: DWORD nWrite; /* Bytes written by each WriteFile() call */
33687: DWORD lastErrno = NO_ERROR; /* Value returned by GetLastError() */
33688:
33689: while( nRem>0 ){
33690: if( !osWriteFile(pFile->h, aRem, nRem, &nWrite, 0) ){
33691: if( retryIoerr(&nRetry, &lastErrno) ) continue;
33692: break;
33693: }
33694: if( nWrite<=0 ) break;
33695: aRem += nWrite;
33696: nRem -= nWrite;
33697: }
33698: if( nRem>0 ){
33699: pFile->lastErrno = lastErrno;
33700: rc = 1;
33701: }
33702: }
33703:
33704: if( rc ){
33705: if( ( pFile->lastErrno==ERROR_HANDLE_DISK_FULL )
33706: || ( pFile->lastErrno==ERROR_DISK_FULL )){
33707: return SQLITE_FULL;
33708: }
33709: return winLogError(SQLITE_IOERR_WRITE, pFile->lastErrno,
33710: "winWrite", pFile->zPath);
33711: }else{
33712: logIoerr(nRetry);
33713: }
33714: return SQLITE_OK;
33715: }
33716:
33717: /*
33718: ** Truncate an open file to a specified size
33719: */
33720: static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
33721: winFile *pFile = (winFile*)id; /* File handle object */
33722: int rc = SQLITE_OK; /* Return code for this function */
33723:
33724: assert( pFile );
33725:
33726: OSTRACE(("TRUNCATE %d %lld\n", pFile->h, nByte));
33727: SimulateIOError(return SQLITE_IOERR_TRUNCATE);
33728:
33729: /* If the user has configured a chunk-size for this file, truncate the
33730: ** file so that it consists of an integer number of chunks (i.e. the
33731: ** actual file size after the operation may be larger than the requested
33732: ** size).
33733: */
33734: if( pFile->szChunk>0 ){
33735: nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
33736: }
33737:
33738: /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */
33739: if( seekWinFile(pFile, nByte) ){
33740: rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
33741: "winTruncate1", pFile->zPath);
33742: }else if( 0==osSetEndOfFile(pFile->h) ){
33743: pFile->lastErrno = osGetLastError();
33744: rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
33745: "winTruncate2", pFile->zPath);
33746: }
33747:
33748: OSTRACE(("TRUNCATE %d %lld %s\n", pFile->h, nByte, rc ? "failed" : "ok"));
33749: return rc;
33750: }
33751:
33752: #ifdef SQLITE_TEST
33753: /*
33754: ** Count the number of fullsyncs and normal syncs. This is used to test
33755: ** that syncs and fullsyncs are occuring at the right times.
33756: */
33757: SQLITE_API int sqlite3_sync_count = 0;
33758: SQLITE_API int sqlite3_fullsync_count = 0;
33759: #endif
33760:
33761: /*
33762: ** Make sure all writes to a particular file are committed to disk.
33763: */
33764: static int winSync(sqlite3_file *id, int flags){
33765: #ifndef SQLITE_NO_SYNC
33766: /*
33767: ** Used only when SQLITE_NO_SYNC is not defined.
33768: */
33769: BOOL rc;
33770: #endif
33771: #if !defined(NDEBUG) || !defined(SQLITE_NO_SYNC) || \
33772: (defined(SQLITE_TEST) && defined(SQLITE_DEBUG))
33773: /*
33774: ** Used when SQLITE_NO_SYNC is not defined and by the assert() and/or
33775: ** OSTRACE() macros.
33776: */
33777: winFile *pFile = (winFile*)id;
33778: #else
33779: UNUSED_PARAMETER(id);
33780: #endif
33781:
33782: assert( pFile );
33783: /* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
33784: assert((flags&0x0F)==SQLITE_SYNC_NORMAL
33785: || (flags&0x0F)==SQLITE_SYNC_FULL
33786: );
33787:
33788: OSTRACE(("SYNC %d lock=%d\n", pFile->h, pFile->locktype));
33789:
33790: /* Unix cannot, but some systems may return SQLITE_FULL from here. This
33791: ** line is to test that doing so does not cause any problems.
33792: */
33793: SimulateDiskfullError( return SQLITE_FULL );
33794:
33795: #ifndef SQLITE_TEST
33796: UNUSED_PARAMETER(flags);
33797: #else
33798: if( (flags&0x0F)==SQLITE_SYNC_FULL ){
33799: sqlite3_fullsync_count++;
33800: }
33801: sqlite3_sync_count++;
33802: #endif
33803:
33804: /* If we compiled with the SQLITE_NO_SYNC flag, then syncing is a
33805: ** no-op
33806: */
33807: #ifdef SQLITE_NO_SYNC
33808: return SQLITE_OK;
33809: #else
33810: rc = osFlushFileBuffers(pFile->h);
33811: SimulateIOError( rc=FALSE );
33812: if( rc ){
33813: return SQLITE_OK;
33814: }else{
33815: pFile->lastErrno = osGetLastError();
33816: return winLogError(SQLITE_IOERR_FSYNC, pFile->lastErrno,
33817: "winSync", pFile->zPath);
33818: }
33819: #endif
33820: }
33821:
33822: /*
33823: ** Determine the current size of a file in bytes
33824: */
33825: static int winFileSize(sqlite3_file *id, sqlite3_int64 *pSize){
33826: DWORD upperBits;
33827: DWORD lowerBits;
33828: winFile *pFile = (winFile*)id;
33829: DWORD lastErrno;
33830:
33831: assert( id!=0 );
33832: SimulateIOError(return SQLITE_IOERR_FSTAT);
33833: lowerBits = osGetFileSize(pFile->h, &upperBits);
33834: if( (lowerBits == INVALID_FILE_SIZE)
33835: && ((lastErrno = osGetLastError())!=NO_ERROR) )
33836: {
33837: pFile->lastErrno = lastErrno;
33838: return winLogError(SQLITE_IOERR_FSTAT, pFile->lastErrno,
33839: "winFileSize", pFile->zPath);
33840: }
33841: *pSize = (((sqlite3_int64)upperBits)<<32) + lowerBits;
33842: return SQLITE_OK;
33843: }
33844:
33845: /*
33846: ** LOCKFILE_FAIL_IMMEDIATELY is undefined on some Windows systems.
33847: */
33848: #ifndef LOCKFILE_FAIL_IMMEDIATELY
33849: # define LOCKFILE_FAIL_IMMEDIATELY 1
33850: #endif
33851:
33852: /*
33853: ** Acquire a reader lock.
33854: ** Different API routines are called depending on whether or not this
33855: ** is Win9x or WinNT.
33856: */
33857: static int getReadLock(winFile *pFile){
33858: int res;
33859: if( isNT() ){
33860: OVERLAPPED ovlp;
33861: ovlp.Offset = SHARED_FIRST;
33862: ovlp.OffsetHigh = 0;
33863: ovlp.hEvent = 0;
33864: res = osLockFileEx(pFile->h, LOCKFILE_FAIL_IMMEDIATELY,
33865: 0, SHARED_SIZE, 0, &ovlp);
33866: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
33867: */
33868: #if SQLITE_OS_WINCE==0
33869: }else{
33870: int lk;
33871: sqlite3_randomness(sizeof(lk), &lk);
33872: pFile->sharedLockByte = (short)((lk & 0x7fffffff)%(SHARED_SIZE - 1));
33873: res = osLockFile(pFile->h, SHARED_FIRST+pFile->sharedLockByte, 0, 1, 0);
33874: #endif
33875: }
33876: if( res == 0 ){
33877: pFile->lastErrno = osGetLastError();
33878: /* No need to log a failure to lock */
33879: }
33880: return res;
33881: }
33882:
33883: /*
33884: ** Undo a readlock
33885: */
33886: static int unlockReadLock(winFile *pFile){
33887: int res;
33888: DWORD lastErrno;
33889: if( isNT() ){
33890: res = osUnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
33891: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
33892: */
33893: #if SQLITE_OS_WINCE==0
33894: }else{
33895: res = osUnlockFile(pFile->h, SHARED_FIRST + pFile->sharedLockByte, 0, 1, 0);
33896: #endif
33897: }
33898: if( res==0 && ((lastErrno = osGetLastError())!=ERROR_NOT_LOCKED) ){
33899: pFile->lastErrno = lastErrno;
33900: winLogError(SQLITE_IOERR_UNLOCK, pFile->lastErrno,
33901: "unlockReadLock", pFile->zPath);
33902: }
33903: return res;
33904: }
33905:
33906: /*
33907: ** Lock the file with the lock specified by parameter locktype - one
33908: ** of the following:
33909: **
33910: ** (1) SHARED_LOCK
33911: ** (2) RESERVED_LOCK
33912: ** (3) PENDING_LOCK
33913: ** (4) EXCLUSIVE_LOCK
33914: **
33915: ** Sometimes when requesting one lock state, additional lock states
33916: ** are inserted in between. The locking might fail on one of the later
33917: ** transitions leaving the lock state different from what it started but
33918: ** still short of its goal. The following chart shows the allowed
33919: ** transitions and the inserted intermediate states:
33920: **
33921: ** UNLOCKED -> SHARED
33922: ** SHARED -> RESERVED
33923: ** SHARED -> (PENDING) -> EXCLUSIVE
33924: ** RESERVED -> (PENDING) -> EXCLUSIVE
33925: ** PENDING -> EXCLUSIVE
33926: **
33927: ** This routine will only increase a lock. The winUnlock() routine
33928: ** erases all locks at once and returns us immediately to locking level 0.
33929: ** It is not possible to lower the locking level one step at a time. You
33930: ** must go straight to locking level 0.
33931: */
33932: static int winLock(sqlite3_file *id, int locktype){
33933: int rc = SQLITE_OK; /* Return code from subroutines */
33934: int res = 1; /* Result of a Windows lock call */
33935: int newLocktype; /* Set pFile->locktype to this value before exiting */
33936: int gotPendingLock = 0;/* True if we acquired a PENDING lock this time */
33937: winFile *pFile = (winFile*)id;
33938: DWORD lastErrno = NO_ERROR;
33939:
33940: assert( id!=0 );
33941: OSTRACE(("LOCK %d %d was %d(%d)\n",
33942: pFile->h, locktype, pFile->locktype, pFile->sharedLockByte));
33943:
33944: /* If there is already a lock of this type or more restrictive on the
33945: ** OsFile, do nothing. Don't use the end_lock: exit path, as
33946: ** sqlite3OsEnterMutex() hasn't been called yet.
33947: */
33948: if( pFile->locktype>=locktype ){
33949: return SQLITE_OK;
33950: }
33951:
33952: /* Make sure the locking sequence is correct
33953: */
33954: assert( pFile->locktype!=NO_LOCK || locktype==SHARED_LOCK );
33955: assert( locktype!=PENDING_LOCK );
33956: assert( locktype!=RESERVED_LOCK || pFile->locktype==SHARED_LOCK );
33957:
33958: /* Lock the PENDING_LOCK byte if we need to acquire a PENDING lock or
33959: ** a SHARED lock. If we are acquiring a SHARED lock, the acquisition of
33960: ** the PENDING_LOCK byte is temporary.
33961: */
33962: newLocktype = pFile->locktype;
33963: if( (pFile->locktype==NO_LOCK)
33964: || ( (locktype==EXCLUSIVE_LOCK)
33965: && (pFile->locktype==RESERVED_LOCK))
33966: ){
33967: int cnt = 3;
33968: while( cnt-->0 && (res = osLockFile(pFile->h, PENDING_BYTE, 0, 1, 0))==0 ){
33969: /* Try 3 times to get the pending lock. This is needed to work
33970: ** around problems caused by indexing and/or anti-virus software on
33971: ** Windows systems.
33972: ** If you are using this code as a model for alternative VFSes, do not
33973: ** copy this retry logic. It is a hack intended for Windows only.
33974: */
33975: OSTRACE(("could not get a PENDING lock. cnt=%d\n", cnt));
33976: if( cnt ) osSleep(1);
33977: }
33978: gotPendingLock = res;
33979: if( !res ){
33980: lastErrno = osGetLastError();
33981: }
33982: }
33983:
33984: /* Acquire a shared lock
33985: */
33986: if( locktype==SHARED_LOCK && res ){
33987: assert( pFile->locktype==NO_LOCK );
33988: res = getReadLock(pFile);
33989: if( res ){
33990: newLocktype = SHARED_LOCK;
33991: }else{
33992: lastErrno = osGetLastError();
33993: }
33994: }
33995:
33996: /* Acquire a RESERVED lock
33997: */
33998: if( locktype==RESERVED_LOCK && res ){
33999: assert( pFile->locktype==SHARED_LOCK );
34000: res = osLockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
34001: if( res ){
34002: newLocktype = RESERVED_LOCK;
34003: }else{
34004: lastErrno = osGetLastError();
34005: }
34006: }
34007:
34008: /* Acquire a PENDING lock
34009: */
34010: if( locktype==EXCLUSIVE_LOCK && res ){
34011: newLocktype = PENDING_LOCK;
34012: gotPendingLock = 0;
34013: }
34014:
34015: /* Acquire an EXCLUSIVE lock
34016: */
34017: if( locktype==EXCLUSIVE_LOCK && res ){
34018: assert( pFile->locktype>=SHARED_LOCK );
34019: res = unlockReadLock(pFile);
34020: OSTRACE(("unreadlock = %d\n", res));
34021: res = osLockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
34022: if( res ){
34023: newLocktype = EXCLUSIVE_LOCK;
34024: }else{
34025: lastErrno = osGetLastError();
34026: OSTRACE(("error-code = %d\n", lastErrno));
34027: getReadLock(pFile);
34028: }
34029: }
34030:
34031: /* If we are holding a PENDING lock that ought to be released, then
34032: ** release it now.
34033: */
34034: if( gotPendingLock && locktype==SHARED_LOCK ){
34035: osUnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
34036: }
34037:
34038: /* Update the state of the lock has held in the file descriptor then
34039: ** return the appropriate result code.
34040: */
34041: if( res ){
34042: rc = SQLITE_OK;
34043: }else{
34044: OSTRACE(("LOCK FAILED %d trying for %d but got %d\n", pFile->h,
34045: locktype, newLocktype));
34046: pFile->lastErrno = lastErrno;
34047: rc = SQLITE_BUSY;
34048: }
34049: pFile->locktype = (u8)newLocktype;
34050: return rc;
34051: }
34052:
34053: /*
34054: ** This routine checks if there is a RESERVED lock held on the specified
34055: ** file by this or any other process. If such a lock is held, return
34056: ** non-zero, otherwise zero.
34057: */
34058: static int winCheckReservedLock(sqlite3_file *id, int *pResOut){
34059: int rc;
34060: winFile *pFile = (winFile*)id;
34061:
34062: SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );
34063:
34064: assert( id!=0 );
34065: if( pFile->locktype>=RESERVED_LOCK ){
34066: rc = 1;
34067: OSTRACE(("TEST WR-LOCK %d %d (local)\n", pFile->h, rc));
34068: }else{
34069: rc = osLockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
34070: if( rc ){
34071: osUnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
34072: }
34073: rc = !rc;
34074: OSTRACE(("TEST WR-LOCK %d %d (remote)\n", pFile->h, rc));
34075: }
34076: *pResOut = rc;
34077: return SQLITE_OK;
34078: }
34079:
34080: /*
34081: ** Lower the locking level on file descriptor id to locktype. locktype
34082: ** must be either NO_LOCK or SHARED_LOCK.
34083: **
34084: ** If the locking level of the file descriptor is already at or below
34085: ** the requested locking level, this routine is a no-op.
34086: **
34087: ** It is not possible for this routine to fail if the second argument
34088: ** is NO_LOCK. If the second argument is SHARED_LOCK then this routine
34089: ** might return SQLITE_IOERR;
34090: */
34091: static int winUnlock(sqlite3_file *id, int locktype){
34092: int type;
34093: winFile *pFile = (winFile*)id;
34094: int rc = SQLITE_OK;
34095: assert( pFile!=0 );
34096: assert( locktype<=SHARED_LOCK );
34097: OSTRACE(("UNLOCK %d to %d was %d(%d)\n", pFile->h, locktype,
34098: pFile->locktype, pFile->sharedLockByte));
34099: type = pFile->locktype;
34100: if( type>=EXCLUSIVE_LOCK ){
34101: osUnlockFile(pFile->h, SHARED_FIRST, 0, SHARED_SIZE, 0);
34102: if( locktype==SHARED_LOCK && !getReadLock(pFile) ){
34103: /* This should never happen. We should always be able to
34104: ** reacquire the read lock */
34105: rc = winLogError(SQLITE_IOERR_UNLOCK, osGetLastError(),
34106: "winUnlock", pFile->zPath);
34107: }
34108: }
34109: if( type>=RESERVED_LOCK ){
34110: osUnlockFile(pFile->h, RESERVED_BYTE, 0, 1, 0);
34111: }
34112: if( locktype==NO_LOCK && type>=SHARED_LOCK ){
34113: unlockReadLock(pFile);
34114: }
34115: if( type>=PENDING_LOCK ){
34116: osUnlockFile(pFile->h, PENDING_BYTE, 0, 1, 0);
34117: }
34118: pFile->locktype = (u8)locktype;
34119: return rc;
34120: }
34121:
34122: /*
34123: ** If *pArg is inititially negative then this is a query. Set *pArg to
34124: ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
34125: **
34126: ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
34127: */
34128: static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){
34129: if( *pArg<0 ){
34130: *pArg = (pFile->ctrlFlags & mask)!=0;
34131: }else if( (*pArg)==0 ){
34132: pFile->ctrlFlags &= ~mask;
34133: }else{
34134: pFile->ctrlFlags |= mask;
34135: }
34136: }
34137:
34138: /*
34139: ** Control and query of the open file handle.
34140: */
34141: static int winFileControl(sqlite3_file *id, int op, void *pArg){
34142: winFile *pFile = (winFile*)id;
34143: switch( op ){
34144: case SQLITE_FCNTL_LOCKSTATE: {
34145: *(int*)pArg = pFile->locktype;
34146: return SQLITE_OK;
34147: }
34148: case SQLITE_LAST_ERRNO: {
34149: *(int*)pArg = (int)pFile->lastErrno;
34150: return SQLITE_OK;
34151: }
34152: case SQLITE_FCNTL_CHUNK_SIZE: {
34153: pFile->szChunk = *(int *)pArg;
34154: return SQLITE_OK;
34155: }
34156: case SQLITE_FCNTL_SIZE_HINT: {
34157: if( pFile->szChunk>0 ){
34158: sqlite3_int64 oldSz;
34159: int rc = winFileSize(id, &oldSz);
34160: if( rc==SQLITE_OK ){
34161: sqlite3_int64 newSz = *(sqlite3_int64*)pArg;
34162: if( newSz>oldSz ){
34163: SimulateIOErrorBenign(1);
34164: rc = winTruncate(id, newSz);
34165: SimulateIOErrorBenign(0);
34166: }
34167: }
34168: return rc;
34169: }
34170: return SQLITE_OK;
34171: }
34172: case SQLITE_FCNTL_PERSIST_WAL: {
34173: winModeBit(pFile, WINFILE_PERSIST_WAL, (int*)pArg);
34174: return SQLITE_OK;
34175: }
34176: case SQLITE_FCNTL_POWERSAFE_OVERWRITE: {
34177: winModeBit(pFile, WINFILE_PSOW, (int*)pArg);
34178: return SQLITE_OK;
34179: }
34180: case SQLITE_FCNTL_VFSNAME: {
34181: *(char**)pArg = sqlite3_mprintf("win32");
34182: return SQLITE_OK;
34183: }
34184: case SQLITE_FCNTL_WIN32_AV_RETRY: {
34185: int *a = (int*)pArg;
34186: if( a[0]>0 ){
34187: win32IoerrRetry = a[0];
34188: }else{
34189: a[0] = win32IoerrRetry;
34190: }
34191: if( a[1]>0 ){
34192: win32IoerrRetryDelay = a[1];
34193: }else{
34194: a[1] = win32IoerrRetryDelay;
34195: }
34196: return SQLITE_OK;
34197: }
34198: }
34199: return SQLITE_NOTFOUND;
34200: }
34201:
34202: /*
34203: ** Return the sector size in bytes of the underlying block device for
34204: ** the specified file. This is almost always 512 bytes, but may be
34205: ** larger for some devices.
34206: **
34207: ** SQLite code assumes this function cannot fail. It also assumes that
34208: ** if two files are created in the same file-system directory (i.e.
34209: ** a database and its journal file) that the sector size will be the
34210: ** same for both.
34211: */
34212: static int winSectorSize(sqlite3_file *id){
34213: (void)id;
34214: return SQLITE_DEFAULT_SECTOR_SIZE;
34215: }
34216:
34217: /*
34218: ** Return a vector of device characteristics.
34219: */
34220: static int winDeviceCharacteristics(sqlite3_file *id){
34221: winFile *p = (winFile*)id;
34222: return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN |
34223: ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0);
34224: }
34225:
34226: #ifndef SQLITE_OMIT_WAL
34227:
34228: /*
34229: ** Windows will only let you create file view mappings
34230: ** on allocation size granularity boundaries.
34231: ** During sqlite3_os_init() we do a GetSystemInfo()
34232: ** to get the granularity size.
34233: */
34234: SYSTEM_INFO winSysInfo;
34235:
34236: /*
34237: ** Helper functions to obtain and relinquish the global mutex. The
34238: ** global mutex is used to protect the winLockInfo objects used by
34239: ** this file, all of which may be shared by multiple threads.
34240: **
34241: ** Function winShmMutexHeld() is used to assert() that the global mutex
34242: ** is held when required. This function is only used as part of assert()
34243: ** statements. e.g.
34244: **
34245: ** winShmEnterMutex()
34246: ** assert( winShmMutexHeld() );
34247: ** winShmLeaveMutex()
34248: */
34249: static void winShmEnterMutex(void){
34250: sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
34251: }
34252: static void winShmLeaveMutex(void){
34253: sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
34254: }
34255: #ifdef SQLITE_DEBUG
34256: static int winShmMutexHeld(void) {
34257: return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
34258: }
34259: #endif
34260:
34261: /*
34262: ** Object used to represent a single file opened and mmapped to provide
34263: ** shared memory. When multiple threads all reference the same
34264: ** log-summary, each thread has its own winFile object, but they all
34265: ** point to a single instance of this object. In other words, each
34266: ** log-summary is opened only once per process.
34267: **
34268: ** winShmMutexHeld() must be true when creating or destroying
34269: ** this object or while reading or writing the following fields:
34270: **
34271: ** nRef
34272: ** pNext
34273: **
34274: ** The following fields are read-only after the object is created:
34275: **
34276: ** fid
34277: ** zFilename
34278: **
34279: ** Either winShmNode.mutex must be held or winShmNode.nRef==0 and
34280: ** winShmMutexHeld() is true when reading or writing any other field
34281: ** in this structure.
34282: **
34283: */
34284: struct winShmNode {
34285: sqlite3_mutex *mutex; /* Mutex to access this object */
34286: char *zFilename; /* Name of the file */
34287: winFile hFile; /* File handle from winOpen */
34288:
34289: int szRegion; /* Size of shared-memory regions */
34290: int nRegion; /* Size of array apRegion */
34291: struct ShmRegion {
34292: HANDLE hMap; /* File handle from CreateFileMapping */
34293: void *pMap;
34294: } *aRegion;
34295: DWORD lastErrno; /* The Windows errno from the last I/O error */
34296:
34297: int nRef; /* Number of winShm objects pointing to this */
34298: winShm *pFirst; /* All winShm objects pointing to this */
34299: winShmNode *pNext; /* Next in list of all winShmNode objects */
34300: #ifdef SQLITE_DEBUG
34301: u8 nextShmId; /* Next available winShm.id value */
34302: #endif
34303: };
34304:
34305: /*
34306: ** A global array of all winShmNode objects.
34307: **
34308: ** The winShmMutexHeld() must be true while reading or writing this list.
34309: */
34310: static winShmNode *winShmNodeList = 0;
34311:
34312: /*
34313: ** Structure used internally by this VFS to record the state of an
34314: ** open shared memory connection.
34315: **
34316: ** The following fields are initialized when this object is created and
34317: ** are read-only thereafter:
34318: **
34319: ** winShm.pShmNode
34320: ** winShm.id
34321: **
34322: ** All other fields are read/write. The winShm.pShmNode->mutex must be held
34323: ** while accessing any read/write fields.
34324: */
34325: struct winShm {
34326: winShmNode *pShmNode; /* The underlying winShmNode object */
34327: winShm *pNext; /* Next winShm with the same winShmNode */
34328: u8 hasMutex; /* True if holding the winShmNode mutex */
34329: u16 sharedMask; /* Mask of shared locks held */
34330: u16 exclMask; /* Mask of exclusive locks held */
34331: #ifdef SQLITE_DEBUG
34332: u8 id; /* Id of this connection with its winShmNode */
34333: #endif
34334: };
34335:
34336: /*
34337: ** Constants used for locking
34338: */
34339: #define WIN_SHM_BASE ((22+SQLITE_SHM_NLOCK)*4) /* first lock byte */
34340: #define WIN_SHM_DMS (WIN_SHM_BASE+SQLITE_SHM_NLOCK) /* deadman switch */
34341:
34342: /*
34343: ** Apply advisory locks for all n bytes beginning at ofst.
34344: */
34345: #define _SHM_UNLCK 1
34346: #define _SHM_RDLCK 2
34347: #define _SHM_WRLCK 3
34348: static int winShmSystemLock(
34349: winShmNode *pFile, /* Apply locks to this open shared-memory segment */
34350: int lockType, /* _SHM_UNLCK, _SHM_RDLCK, or _SHM_WRLCK */
34351: int ofst, /* Offset to first byte to be locked/unlocked */
34352: int nByte /* Number of bytes to lock or unlock */
34353: ){
34354: OVERLAPPED ovlp;
34355: DWORD dwFlags;
34356: int rc = 0; /* Result code form Lock/UnlockFileEx() */
34357:
34358: /* Access to the winShmNode object is serialized by the caller */
34359: assert( sqlite3_mutex_held(pFile->mutex) || pFile->nRef==0 );
34360:
34361: /* Initialize the locking parameters */
34362: dwFlags = LOCKFILE_FAIL_IMMEDIATELY;
34363: if( lockType == _SHM_WRLCK ) dwFlags |= LOCKFILE_EXCLUSIVE_LOCK;
34364:
34365: memset(&ovlp, 0, sizeof(OVERLAPPED));
34366: ovlp.Offset = ofst;
34367:
34368: /* Release/Acquire the system-level lock */
34369: if( lockType==_SHM_UNLCK ){
34370: rc = osUnlockFileEx(pFile->hFile.h, 0, nByte, 0, &ovlp);
34371: }else{
34372: rc = osLockFileEx(pFile->hFile.h, dwFlags, 0, nByte, 0, &ovlp);
34373: }
34374:
34375: if( rc!= 0 ){
34376: rc = SQLITE_OK;
34377: }else{
34378: pFile->lastErrno = osGetLastError();
34379: rc = SQLITE_BUSY;
34380: }
34381:
34382: OSTRACE(("SHM-LOCK %d %s %s 0x%08lx\n",
34383: pFile->hFile.h,
34384: rc==SQLITE_OK ? "ok" : "failed",
34385: lockType==_SHM_UNLCK ? "UnlockFileEx" : "LockFileEx",
34386: pFile->lastErrno));
34387:
34388: return rc;
34389: }
34390:
34391: /* Forward references to VFS methods */
34392: static int winOpen(sqlite3_vfs*,const char*,sqlite3_file*,int,int*);
34393: static int winDelete(sqlite3_vfs *,const char*,int);
34394:
34395: /*
34396: ** Purge the winShmNodeList list of all entries with winShmNode.nRef==0.
34397: **
34398: ** This is not a VFS shared-memory method; it is a utility function called
34399: ** by VFS shared-memory methods.
34400: */
34401: static void winShmPurge(sqlite3_vfs *pVfs, int deleteFlag){
34402: winShmNode **pp;
34403: winShmNode *p;
34404: BOOL bRc;
34405: assert( winShmMutexHeld() );
34406: pp = &winShmNodeList;
34407: while( (p = *pp)!=0 ){
34408: if( p->nRef==0 ){
34409: int i;
34410: if( p->mutex ) sqlite3_mutex_free(p->mutex);
34411: for(i=0; i<p->nRegion; i++){
34412: bRc = osUnmapViewOfFile(p->aRegion[i].pMap);
34413: OSTRACE(("SHM-PURGE pid-%d unmap region=%d %s\n",
34414: (int)osGetCurrentProcessId(), i,
34415: bRc ? "ok" : "failed"));
34416: bRc = osCloseHandle(p->aRegion[i].hMap);
34417: OSTRACE(("SHM-PURGE pid-%d close region=%d %s\n",
34418: (int)osGetCurrentProcessId(), i,
34419: bRc ? "ok" : "failed"));
34420: }
34421: if( p->hFile.h != INVALID_HANDLE_VALUE ){
34422: SimulateIOErrorBenign(1);
34423: winClose((sqlite3_file *)&p->hFile);
34424: SimulateIOErrorBenign(0);
34425: }
34426: if( deleteFlag ){
34427: SimulateIOErrorBenign(1);
34428: sqlite3BeginBenignMalloc();
34429: winDelete(pVfs, p->zFilename, 0);
34430: sqlite3EndBenignMalloc();
34431: SimulateIOErrorBenign(0);
34432: }
34433: *pp = p->pNext;
34434: sqlite3_free(p->aRegion);
34435: sqlite3_free(p);
34436: }else{
34437: pp = &p->pNext;
34438: }
34439: }
34440: }
34441:
34442: /*
34443: ** Open the shared-memory area associated with database file pDbFd.
34444: **
34445: ** When opening a new shared-memory file, if no other instances of that
34446: ** file are currently open, in this process or in other processes, then
34447: ** the file must be truncated to zero length or have its header cleared.
34448: */
34449: static int winOpenSharedMemory(winFile *pDbFd){
34450: struct winShm *p; /* The connection to be opened */
34451: struct winShmNode *pShmNode = 0; /* The underlying mmapped file */
34452: int rc; /* Result code */
34453: struct winShmNode *pNew; /* Newly allocated winShmNode */
34454: int nName; /* Size of zName in bytes */
34455:
34456: assert( pDbFd->pShm==0 ); /* Not previously opened */
34457:
34458: /* Allocate space for the new sqlite3_shm object. Also speculatively
34459: ** allocate space for a new winShmNode and filename.
34460: */
34461: p = sqlite3_malloc( sizeof(*p) );
34462: if( p==0 ) return SQLITE_IOERR_NOMEM;
34463: memset(p, 0, sizeof(*p));
34464: nName = sqlite3Strlen30(pDbFd->zPath);
34465: pNew = sqlite3_malloc( sizeof(*pShmNode) + nName + 17 );
34466: if( pNew==0 ){
34467: sqlite3_free(p);
34468: return SQLITE_IOERR_NOMEM;
34469: }
34470: memset(pNew, 0, sizeof(*pNew) + nName + 17);
34471: pNew->zFilename = (char*)&pNew[1];
34472: sqlite3_snprintf(nName+15, pNew->zFilename, "%s-shm", pDbFd->zPath);
34473: sqlite3FileSuffix3(pDbFd->zPath, pNew->zFilename);
34474:
34475: /* Look to see if there is an existing winShmNode that can be used.
34476: ** If no matching winShmNode currently exists, create a new one.
34477: */
34478: winShmEnterMutex();
34479: for(pShmNode = winShmNodeList; pShmNode; pShmNode=pShmNode->pNext){
34480: /* TBD need to come up with better match here. Perhaps
34481: ** use FILE_ID_BOTH_DIR_INFO Structure.
34482: */
34483: if( sqlite3StrICmp(pShmNode->zFilename, pNew->zFilename)==0 ) break;
34484: }
34485: if( pShmNode ){
34486: sqlite3_free(pNew);
34487: }else{
34488: pShmNode = pNew;
34489: pNew = 0;
34490: ((winFile*)(&pShmNode->hFile))->h = INVALID_HANDLE_VALUE;
34491: pShmNode->pNext = winShmNodeList;
34492: winShmNodeList = pShmNode;
34493:
34494: pShmNode->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
34495: if( pShmNode->mutex==0 ){
34496: rc = SQLITE_IOERR_NOMEM;
34497: goto shm_open_err;
34498: }
34499:
34500: rc = winOpen(pDbFd->pVfs,
34501: pShmNode->zFilename, /* Name of the file (UTF-8) */
34502: (sqlite3_file*)&pShmNode->hFile, /* File handle here */
34503: SQLITE_OPEN_WAL | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, /* Mode flags */
34504: 0);
34505: if( SQLITE_OK!=rc ){
34506: goto shm_open_err;
34507: }
34508:
34509: /* Check to see if another process is holding the dead-man switch.
34510: ** If not, truncate the file to zero length.
34511: */
34512: if( winShmSystemLock(pShmNode, _SHM_WRLCK, WIN_SHM_DMS, 1)==SQLITE_OK ){
34513: rc = winTruncate((sqlite3_file *)&pShmNode->hFile, 0);
34514: if( rc!=SQLITE_OK ){
34515: rc = winLogError(SQLITE_IOERR_SHMOPEN, osGetLastError(),
34516: "winOpenShm", pDbFd->zPath);
34517: }
34518: }
34519: if( rc==SQLITE_OK ){
34520: winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
34521: rc = winShmSystemLock(pShmNode, _SHM_RDLCK, WIN_SHM_DMS, 1);
34522: }
34523: if( rc ) goto shm_open_err;
34524: }
34525:
34526: /* Make the new connection a child of the winShmNode */
34527: p->pShmNode = pShmNode;
34528: #ifdef SQLITE_DEBUG
34529: p->id = pShmNode->nextShmId++;
34530: #endif
34531: pShmNode->nRef++;
34532: pDbFd->pShm = p;
34533: winShmLeaveMutex();
34534:
34535: /* The reference count on pShmNode has already been incremented under
34536: ** the cover of the winShmEnterMutex() mutex and the pointer from the
34537: ** new (struct winShm) object to the pShmNode has been set. All that is
34538: ** left to do is to link the new object into the linked list starting
34539: ** at pShmNode->pFirst. This must be done while holding the pShmNode->mutex
34540: ** mutex.
34541: */
34542: sqlite3_mutex_enter(pShmNode->mutex);
34543: p->pNext = pShmNode->pFirst;
34544: pShmNode->pFirst = p;
34545: sqlite3_mutex_leave(pShmNode->mutex);
34546: return SQLITE_OK;
34547:
34548: /* Jump here on any error */
34549: shm_open_err:
34550: winShmSystemLock(pShmNode, _SHM_UNLCK, WIN_SHM_DMS, 1);
34551: winShmPurge(pDbFd->pVfs, 0); /* This call frees pShmNode if required */
34552: sqlite3_free(p);
34553: sqlite3_free(pNew);
34554: winShmLeaveMutex();
34555: return rc;
34556: }
34557:
34558: /*
34559: ** Close a connection to shared-memory. Delete the underlying
34560: ** storage if deleteFlag is true.
34561: */
34562: static int winShmUnmap(
34563: sqlite3_file *fd, /* Database holding shared memory */
34564: int deleteFlag /* Delete after closing if true */
34565: ){
34566: winFile *pDbFd; /* Database holding shared-memory */
34567: winShm *p; /* The connection to be closed */
34568: winShmNode *pShmNode; /* The underlying shared-memory file */
34569: winShm **pp; /* For looping over sibling connections */
34570:
34571: pDbFd = (winFile*)fd;
34572: p = pDbFd->pShm;
34573: if( p==0 ) return SQLITE_OK;
34574: pShmNode = p->pShmNode;
34575:
34576: /* Remove connection p from the set of connections associated
34577: ** with pShmNode */
34578: sqlite3_mutex_enter(pShmNode->mutex);
34579: for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
34580: *pp = p->pNext;
34581:
34582: /* Free the connection p */
34583: sqlite3_free(p);
34584: pDbFd->pShm = 0;
34585: sqlite3_mutex_leave(pShmNode->mutex);
34586:
34587: /* If pShmNode->nRef has reached 0, then close the underlying
34588: ** shared-memory file, too */
34589: winShmEnterMutex();
34590: assert( pShmNode->nRef>0 );
34591: pShmNode->nRef--;
34592: if( pShmNode->nRef==0 ){
34593: winShmPurge(pDbFd->pVfs, deleteFlag);
34594: }
34595: winShmLeaveMutex();
34596:
34597: return SQLITE_OK;
34598: }
34599:
34600: /*
34601: ** Change the lock state for a shared-memory segment.
34602: */
34603: static int winShmLock(
34604: sqlite3_file *fd, /* Database file holding the shared memory */
34605: int ofst, /* First lock to acquire or release */
34606: int n, /* Number of locks to acquire or release */
34607: int flags /* What to do with the lock */
34608: ){
34609: winFile *pDbFd = (winFile*)fd; /* Connection holding shared memory */
34610: winShm *p = pDbFd->pShm; /* The shared memory being locked */
34611: winShm *pX; /* For looping over all siblings */
34612: winShmNode *pShmNode = p->pShmNode;
34613: int rc = SQLITE_OK; /* Result code */
34614: u16 mask; /* Mask of locks to take or release */
34615:
34616: assert( ofst>=0 && ofst+n<=SQLITE_SHM_NLOCK );
34617: assert( n>=1 );
34618: assert( flags==(SQLITE_SHM_LOCK | SQLITE_SHM_SHARED)
34619: || flags==(SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE)
34620: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
34621: || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
34622: assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
34623:
34624: mask = (u16)((1U<<(ofst+n)) - (1U<<ofst));
34625: assert( n>1 || mask==(1<<ofst) );
34626: sqlite3_mutex_enter(pShmNode->mutex);
34627: if( flags & SQLITE_SHM_UNLOCK ){
34628: u16 allMask = 0; /* Mask of locks held by siblings */
34629:
34630: /* See if any siblings hold this same lock */
34631: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
34632: if( pX==p ) continue;
34633: assert( (pX->exclMask & (p->exclMask|p->sharedMask))==0 );
34634: allMask |= pX->sharedMask;
34635: }
34636:
34637: /* Unlock the system-level locks */
34638: if( (mask & allMask)==0 ){
34639: rc = winShmSystemLock(pShmNode, _SHM_UNLCK, ofst+WIN_SHM_BASE, n);
34640: }else{
34641: rc = SQLITE_OK;
34642: }
34643:
34644: /* Undo the local locks */
34645: if( rc==SQLITE_OK ){
34646: p->exclMask &= ~mask;
34647: p->sharedMask &= ~mask;
34648: }
34649: }else if( flags & SQLITE_SHM_SHARED ){
34650: u16 allShared = 0; /* Union of locks held by connections other than "p" */
34651:
34652: /* Find out which shared locks are already held by sibling connections.
34653: ** If any sibling already holds an exclusive lock, go ahead and return
34654: ** SQLITE_BUSY.
34655: */
34656: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
34657: if( (pX->exclMask & mask)!=0 ){
34658: rc = SQLITE_BUSY;
34659: break;
34660: }
34661: allShared |= pX->sharedMask;
34662: }
34663:
34664: /* Get shared locks at the system level, if necessary */
34665: if( rc==SQLITE_OK ){
34666: if( (allShared & mask)==0 ){
34667: rc = winShmSystemLock(pShmNode, _SHM_RDLCK, ofst+WIN_SHM_BASE, n);
34668: }else{
34669: rc = SQLITE_OK;
34670: }
34671: }
34672:
34673: /* Get the local shared locks */
34674: if( rc==SQLITE_OK ){
34675: p->sharedMask |= mask;
34676: }
34677: }else{
34678: /* Make sure no sibling connections hold locks that will block this
34679: ** lock. If any do, return SQLITE_BUSY right away.
34680: */
34681: for(pX=pShmNode->pFirst; pX; pX=pX->pNext){
34682: if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
34683: rc = SQLITE_BUSY;
34684: break;
34685: }
34686: }
34687:
34688: /* Get the exclusive locks at the system level. Then if successful
34689: ** also mark the local connection as being locked.
34690: */
34691: if( rc==SQLITE_OK ){
34692: rc = winShmSystemLock(pShmNode, _SHM_WRLCK, ofst+WIN_SHM_BASE, n);
34693: if( rc==SQLITE_OK ){
34694: assert( (p->sharedMask & mask)==0 );
34695: p->exclMask |= mask;
34696: }
34697: }
34698: }
34699: sqlite3_mutex_leave(pShmNode->mutex);
34700: OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x %s\n",
34701: p->id, (int)osGetCurrentProcessId(), p->sharedMask, p->exclMask,
34702: rc ? "failed" : "ok"));
34703: return rc;
34704: }
34705:
34706: /*
34707: ** Implement a memory barrier or memory fence on shared memory.
34708: **
34709: ** All loads and stores begun before the barrier must complete before
34710: ** any load or store begun after the barrier.
34711: */
34712: static void winShmBarrier(
34713: sqlite3_file *fd /* Database holding the shared memory */
34714: ){
34715: UNUSED_PARAMETER(fd);
34716: /* MemoryBarrier(); // does not work -- do not know why not */
34717: winShmEnterMutex();
34718: winShmLeaveMutex();
34719: }
34720:
34721: /*
34722: ** This function is called to obtain a pointer to region iRegion of the
34723: ** shared-memory associated with the database file fd. Shared-memory regions
34724: ** are numbered starting from zero. Each shared-memory region is szRegion
34725: ** bytes in size.
34726: **
34727: ** If an error occurs, an error code is returned and *pp is set to NULL.
34728: **
34729: ** Otherwise, if the isWrite parameter is 0 and the requested shared-memory
34730: ** region has not been allocated (by any client, including one running in a
34731: ** separate process), then *pp is set to NULL and SQLITE_OK returned. If
34732: ** isWrite is non-zero and the requested shared-memory region has not yet
34733: ** been allocated, it is allocated by this function.
34734: **
34735: ** If the shared-memory region has already been allocated or is allocated by
34736: ** this call as described above, then it is mapped into this processes
34737: ** address space (if it is not already), *pp is set to point to the mapped
34738: ** memory and SQLITE_OK returned.
34739: */
34740: static int winShmMap(
34741: sqlite3_file *fd, /* Handle open on database file */
34742: int iRegion, /* Region to retrieve */
34743: int szRegion, /* Size of regions */
34744: int isWrite, /* True to extend file if necessary */
34745: void volatile **pp /* OUT: Mapped memory */
34746: ){
34747: winFile *pDbFd = (winFile*)fd;
34748: winShm *p = pDbFd->pShm;
34749: winShmNode *pShmNode;
34750: int rc = SQLITE_OK;
34751:
34752: if( !p ){
34753: rc = winOpenSharedMemory(pDbFd);
34754: if( rc!=SQLITE_OK ) return rc;
34755: p = pDbFd->pShm;
34756: }
34757: pShmNode = p->pShmNode;
34758:
34759: sqlite3_mutex_enter(pShmNode->mutex);
34760: assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
34761:
34762: if( pShmNode->nRegion<=iRegion ){
34763: struct ShmRegion *apNew; /* New aRegion[] array */
34764: int nByte = (iRegion+1)*szRegion; /* Minimum required file size */
34765: sqlite3_int64 sz; /* Current size of wal-index file */
34766:
34767: pShmNode->szRegion = szRegion;
34768:
34769: /* The requested region is not mapped into this processes address space.
34770: ** Check to see if it has been allocated (i.e. if the wal-index file is
34771: ** large enough to contain the requested region).
34772: */
34773: rc = winFileSize((sqlite3_file *)&pShmNode->hFile, &sz);
34774: if( rc!=SQLITE_OK ){
34775: rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(),
34776: "winShmMap1", pDbFd->zPath);
34777: goto shmpage_out;
34778: }
34779:
34780: if( sz<nByte ){
34781: /* The requested memory region does not exist. If isWrite is set to
34782: ** zero, exit early. *pp will be set to NULL and SQLITE_OK returned.
34783: **
34784: ** Alternatively, if isWrite is non-zero, use ftruncate() to allocate
34785: ** the requested memory region.
34786: */
34787: if( !isWrite ) goto shmpage_out;
34788: rc = winTruncate((sqlite3_file *)&pShmNode->hFile, nByte);
34789: if( rc!=SQLITE_OK ){
34790: rc = winLogError(SQLITE_IOERR_SHMSIZE, osGetLastError(),
34791: "winShmMap2", pDbFd->zPath);
34792: goto shmpage_out;
34793: }
34794: }
34795:
34796: /* Map the requested memory region into this processes address space. */
34797: apNew = (struct ShmRegion *)sqlite3_realloc(
34798: pShmNode->aRegion, (iRegion+1)*sizeof(apNew[0])
34799: );
34800: if( !apNew ){
34801: rc = SQLITE_IOERR_NOMEM;
34802: goto shmpage_out;
34803: }
34804: pShmNode->aRegion = apNew;
34805:
34806: while( pShmNode->nRegion<=iRegion ){
34807: HANDLE hMap; /* file-mapping handle */
34808: void *pMap = 0; /* Mapped memory region */
34809:
34810: hMap = osCreateFileMapping(pShmNode->hFile.h,
34811: NULL, PAGE_READWRITE, 0, nByte, NULL
34812: );
34813: OSTRACE(("SHM-MAP pid-%d create region=%d nbyte=%d %s\n",
34814: (int)osGetCurrentProcessId(), pShmNode->nRegion, nByte,
34815: hMap ? "ok" : "failed"));
34816: if( hMap ){
34817: int iOffset = pShmNode->nRegion*szRegion;
34818: int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
34819: pMap = osMapViewOfFile(hMap, FILE_MAP_WRITE | FILE_MAP_READ,
34820: 0, iOffset - iOffsetShift, szRegion + iOffsetShift
34821: );
34822: OSTRACE(("SHM-MAP pid-%d map region=%d offset=%d size=%d %s\n",
34823: (int)osGetCurrentProcessId(), pShmNode->nRegion, iOffset,
34824: szRegion, pMap ? "ok" : "failed"));
34825: }
34826: if( !pMap ){
34827: pShmNode->lastErrno = osGetLastError();
34828: rc = winLogError(SQLITE_IOERR_SHMMAP, pShmNode->lastErrno,
34829: "winShmMap3", pDbFd->zPath);
34830: if( hMap ) osCloseHandle(hMap);
34831: goto shmpage_out;
34832: }
34833:
34834: pShmNode->aRegion[pShmNode->nRegion].pMap = pMap;
34835: pShmNode->aRegion[pShmNode->nRegion].hMap = hMap;
34836: pShmNode->nRegion++;
34837: }
34838: }
34839:
34840: shmpage_out:
34841: if( pShmNode->nRegion>iRegion ){
34842: int iOffset = iRegion*szRegion;
34843: int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
34844: char *p = (char *)pShmNode->aRegion[iRegion].pMap;
34845: *pp = (void *)&p[iOffsetShift];
34846: }else{
34847: *pp = 0;
34848: }
34849: sqlite3_mutex_leave(pShmNode->mutex);
34850: return rc;
34851: }
34852:
34853: #else
34854: # define winShmMap 0
34855: # define winShmLock 0
34856: # define winShmBarrier 0
34857: # define winShmUnmap 0
34858: #endif /* #ifndef SQLITE_OMIT_WAL */
34859:
34860: /*
34861: ** Here ends the implementation of all sqlite3_file methods.
34862: **
34863: ********************** End sqlite3_file Methods *******************************
34864: ******************************************************************************/
34865:
34866: /*
34867: ** This vector defines all the methods that can operate on an
34868: ** sqlite3_file for win32.
34869: */
34870: static const sqlite3_io_methods winIoMethod = {
34871: 2, /* iVersion */
34872: winClose, /* xClose */
34873: winRead, /* xRead */
34874: winWrite, /* xWrite */
34875: winTruncate, /* xTruncate */
34876: winSync, /* xSync */
34877: winFileSize, /* xFileSize */
34878: winLock, /* xLock */
34879: winUnlock, /* xUnlock */
34880: winCheckReservedLock, /* xCheckReservedLock */
34881: winFileControl, /* xFileControl */
34882: winSectorSize, /* xSectorSize */
34883: winDeviceCharacteristics, /* xDeviceCharacteristics */
34884: winShmMap, /* xShmMap */
34885: winShmLock, /* xShmLock */
34886: winShmBarrier, /* xShmBarrier */
34887: winShmUnmap /* xShmUnmap */
34888: };
34889:
34890: /****************************************************************************
34891: **************************** sqlite3_vfs methods ****************************
34892: **
34893: ** This division contains the implementation of methods on the
34894: ** sqlite3_vfs object.
34895: */
34896:
34897: /*
34898: ** Convert a UTF-8 filename into whatever form the underlying
34899: ** operating system wants filenames in. Space to hold the result
34900: ** is obtained from malloc and must be freed by the calling
34901: ** function.
34902: */
34903: static void *convertUtf8Filename(const char *zFilename){
34904: void *zConverted = 0;
34905: if( isNT() ){
34906: zConverted = utf8ToUnicode(zFilename);
34907: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
34908: */
34909: #if SQLITE_OS_WINCE==0
34910: }else{
34911: zConverted = sqlite3_win32_utf8_to_mbcs(zFilename);
34912: #endif
34913: }
34914: /* caller will handle out of memory */
34915: return zConverted;
34916: }
34917:
34918: /*
34919: ** Create a temporary file name in zBuf. zBuf must be big enough to
34920: ** hold at pVfs->mxPathname characters.
34921: */
34922: static int getTempname(int nBuf, char *zBuf){
34923: static char zChars[] =
34924: "abcdefghijklmnopqrstuvwxyz"
34925: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
34926: "0123456789";
34927: size_t i, j;
34928: char zTempPath[MAX_PATH+2];
34929:
34930: /* It's odd to simulate an io-error here, but really this is just
34931: ** using the io-error infrastructure to test that SQLite handles this
34932: ** function failing.
34933: */
34934: SimulateIOError( return SQLITE_IOERR );
34935:
34936: if( sqlite3_temp_directory ){
34937: sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", sqlite3_temp_directory);
34938: }else if( isNT() ){
34939: char *zMulti;
34940: WCHAR zWidePath[MAX_PATH];
34941: osGetTempPathW(MAX_PATH-30, zWidePath);
34942: zMulti = unicodeToUtf8(zWidePath);
34943: if( zMulti ){
34944: sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zMulti);
34945: sqlite3_free(zMulti);
34946: }else{
34947: return SQLITE_IOERR_NOMEM;
34948: }
34949: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
34950: ** Since the ANSI version of these Windows API do not exist for WINCE,
34951: ** it's important to not reference them for WINCE builds.
34952: */
34953: #if SQLITE_OS_WINCE==0
34954: }else{
34955: char *zUtf8;
34956: char zMbcsPath[MAX_PATH];
34957: osGetTempPathA(MAX_PATH-30, zMbcsPath);
34958: zUtf8 = sqlite3_win32_mbcs_to_utf8(zMbcsPath);
34959: if( zUtf8 ){
34960: sqlite3_snprintf(MAX_PATH-30, zTempPath, "%s", zUtf8);
34961: sqlite3_free(zUtf8);
34962: }else{
34963: return SQLITE_IOERR_NOMEM;
34964: }
34965: #endif
34966: }
34967:
34968: /* Check that the output buffer is large enough for the temporary file
34969: ** name. If it is not, return SQLITE_ERROR.
34970: */
34971: if( (sqlite3Strlen30(zTempPath) + sqlite3Strlen30(SQLITE_TEMP_FILE_PREFIX) + 18) >= nBuf ){
34972: return SQLITE_ERROR;
34973: }
34974:
34975: for(i=sqlite3Strlen30(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){}
34976: zTempPath[i] = 0;
34977:
34978: sqlite3_snprintf(nBuf-18, zBuf,
34979: "%s\\"SQLITE_TEMP_FILE_PREFIX, zTempPath);
34980: j = sqlite3Strlen30(zBuf);
34981: sqlite3_randomness(15, &zBuf[j]);
34982: for(i=0; i<15; i++, j++){
34983: zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ];
34984: }
34985: zBuf[j] = 0;
34986: zBuf[j+1] = 0;
34987:
34988: OSTRACE(("TEMP FILENAME: %s\n", zBuf));
34989: return SQLITE_OK;
34990: }
34991:
34992: /*
34993: ** Open a file.
34994: */
34995: static int winOpen(
34996: sqlite3_vfs *pVfs, /* Not used */
34997: const char *zName, /* Name of the file (UTF-8) */
34998: sqlite3_file *id, /* Write the SQLite file handle here */
34999: int flags, /* Open mode flags */
35000: int *pOutFlags /* Status return flags */
35001: ){
35002: HANDLE h;
35003: DWORD lastErrno;
35004: DWORD dwDesiredAccess;
35005: DWORD dwShareMode;
35006: DWORD dwCreationDisposition;
35007: DWORD dwFlagsAndAttributes = 0;
35008: #if SQLITE_OS_WINCE
35009: int isTemp = 0;
35010: #endif
35011: winFile *pFile = (winFile*)id;
35012: void *zConverted; /* Filename in OS encoding */
35013: const char *zUtf8Name = zName; /* Filename in UTF-8 encoding */
35014: int cnt = 0;
35015:
35016: /* If argument zPath is a NULL pointer, this function is required to open
35017: ** a temporary file. Use this buffer to store the file name in.
35018: */
35019: char zTmpname[MAX_PATH+2]; /* Buffer used to create temp filename */
35020:
35021: int rc = SQLITE_OK; /* Function Return Code */
35022: #if !defined(NDEBUG) || SQLITE_OS_WINCE
35023: int eType = flags&0xFFFFFF00; /* Type of file to open */
35024: #endif
35025:
35026: int isExclusive = (flags & SQLITE_OPEN_EXCLUSIVE);
35027: int isDelete = (flags & SQLITE_OPEN_DELETEONCLOSE);
35028: int isCreate = (flags & SQLITE_OPEN_CREATE);
35029: #ifndef NDEBUG
35030: int isReadonly = (flags & SQLITE_OPEN_READONLY);
35031: #endif
35032: int isReadWrite = (flags & SQLITE_OPEN_READWRITE);
35033:
35034: #ifndef NDEBUG
35035: int isOpenJournal = (isCreate && (
35036: eType==SQLITE_OPEN_MASTER_JOURNAL
35037: || eType==SQLITE_OPEN_MAIN_JOURNAL
35038: || eType==SQLITE_OPEN_WAL
35039: ));
35040: #endif
35041:
35042: /* Check the following statements are true:
35043: **
35044: ** (a) Exactly one of the READWRITE and READONLY flags must be set, and
35045: ** (b) if CREATE is set, then READWRITE must also be set, and
35046: ** (c) if EXCLUSIVE is set, then CREATE must also be set.
35047: ** (d) if DELETEONCLOSE is set, then CREATE must also be set.
35048: */
35049: assert((isReadonly==0 || isReadWrite==0) && (isReadWrite || isReadonly));
35050: assert(isCreate==0 || isReadWrite);
35051: assert(isExclusive==0 || isCreate);
35052: assert(isDelete==0 || isCreate);
35053:
35054: /* The main DB, main journal, WAL file and master journal are never
35055: ** automatically deleted. Nor are they ever temporary files. */
35056: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_DB );
35057: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MAIN_JOURNAL );
35058: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_MASTER_JOURNAL );
35059: assert( (!isDelete && zName) || eType!=SQLITE_OPEN_WAL );
35060:
35061: /* Assert that the upper layer has set one of the "file-type" flags. */
35062: assert( eType==SQLITE_OPEN_MAIN_DB || eType==SQLITE_OPEN_TEMP_DB
35063: || eType==SQLITE_OPEN_MAIN_JOURNAL || eType==SQLITE_OPEN_TEMP_JOURNAL
35064: || eType==SQLITE_OPEN_SUBJOURNAL || eType==SQLITE_OPEN_MASTER_JOURNAL
35065: || eType==SQLITE_OPEN_TRANSIENT_DB || eType==SQLITE_OPEN_WAL
35066: );
35067:
35068: assert( id!=0 );
35069: UNUSED_PARAMETER(pVfs);
35070:
35071: pFile->h = INVALID_HANDLE_VALUE;
35072:
35073: /* If the second argument to this function is NULL, generate a
35074: ** temporary file name to use
35075: */
35076: if( !zUtf8Name ){
35077: assert(isDelete && !isOpenJournal);
35078: rc = getTempname(MAX_PATH+2, zTmpname);
35079: if( rc!=SQLITE_OK ){
35080: return rc;
35081: }
35082: zUtf8Name = zTmpname;
35083: }
35084:
35085: /* Database filenames are double-zero terminated if they are not
35086: ** URIs with parameters. Hence, they can always be passed into
35087: ** sqlite3_uri_parameter().
35088: */
35089: assert( (eType!=SQLITE_OPEN_MAIN_DB) || (flags & SQLITE_OPEN_URI) ||
35090: zUtf8Name[strlen(zUtf8Name)+1]==0 );
35091:
35092: /* Convert the filename to the system encoding. */
35093: zConverted = convertUtf8Filename(zUtf8Name);
35094: if( zConverted==0 ){
35095: return SQLITE_IOERR_NOMEM;
35096: }
35097:
35098: if( isReadWrite ){
35099: dwDesiredAccess = GENERIC_READ | GENERIC_WRITE;
35100: }else{
35101: dwDesiredAccess = GENERIC_READ;
35102: }
35103:
35104: /* SQLITE_OPEN_EXCLUSIVE is used to make sure that a new file is
35105: ** created. SQLite doesn't use it to indicate "exclusive access"
35106: ** as it is usually understood.
35107: */
35108: if( isExclusive ){
35109: /* Creates a new file, only if it does not already exist. */
35110: /* If the file exists, it fails. */
35111: dwCreationDisposition = CREATE_NEW;
35112: }else if( isCreate ){
35113: /* Open existing file, or create if it doesn't exist */
35114: dwCreationDisposition = OPEN_ALWAYS;
35115: }else{
35116: /* Opens a file, only if it exists. */
35117: dwCreationDisposition = OPEN_EXISTING;
35118: }
35119:
35120: dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
35121:
35122: if( isDelete ){
35123: #if SQLITE_OS_WINCE
35124: dwFlagsAndAttributes = FILE_ATTRIBUTE_HIDDEN;
35125: isTemp = 1;
35126: #else
35127: dwFlagsAndAttributes = FILE_ATTRIBUTE_TEMPORARY
35128: | FILE_ATTRIBUTE_HIDDEN
35129: | FILE_FLAG_DELETE_ON_CLOSE;
35130: #endif
35131: }else{
35132: dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
35133: }
35134: /* Reports from the internet are that performance is always
35135: ** better if FILE_FLAG_RANDOM_ACCESS is used. Ticket #2699. */
35136: #if SQLITE_OS_WINCE
35137: dwFlagsAndAttributes |= FILE_FLAG_RANDOM_ACCESS;
35138: #endif
35139:
35140: if( isNT() ){
35141: while( (h = osCreateFileW((LPCWSTR)zConverted,
35142: dwDesiredAccess,
35143: dwShareMode, NULL,
35144: dwCreationDisposition,
35145: dwFlagsAndAttributes,
35146: NULL))==INVALID_HANDLE_VALUE &&
35147: retryIoerr(&cnt, &lastErrno) ){}
35148: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
35149: ** Since the ANSI version of these Windows API do not exist for WINCE,
35150: ** it's important to not reference them for WINCE builds.
35151: */
35152: #if SQLITE_OS_WINCE==0
35153: }else{
35154: while( (h = osCreateFileA((LPCSTR)zConverted,
35155: dwDesiredAccess,
35156: dwShareMode, NULL,
35157: dwCreationDisposition,
35158: dwFlagsAndAttributes,
35159: NULL))==INVALID_HANDLE_VALUE &&
35160: retryIoerr(&cnt, &lastErrno) ){}
35161: #endif
35162: }
35163:
35164: logIoerr(cnt);
35165:
35166: OSTRACE(("OPEN %d %s 0x%lx %s\n",
35167: h, zName, dwDesiredAccess,
35168: h==INVALID_HANDLE_VALUE ? "failed" : "ok"));
35169:
35170: if( h==INVALID_HANDLE_VALUE ){
35171: pFile->lastErrno = lastErrno;
35172: winLogError(SQLITE_CANTOPEN, pFile->lastErrno, "winOpen", zUtf8Name);
35173: sqlite3_free(zConverted);
35174: if( isReadWrite && !isExclusive ){
35175: return winOpen(pVfs, zName, id,
35176: ((flags|SQLITE_OPEN_READONLY)&~(SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE)), pOutFlags);
35177: }else{
35178: return SQLITE_CANTOPEN_BKPT;
35179: }
35180: }
35181:
35182: if( pOutFlags ){
35183: if( isReadWrite ){
35184: *pOutFlags = SQLITE_OPEN_READWRITE;
35185: }else{
35186: *pOutFlags = SQLITE_OPEN_READONLY;
35187: }
35188: }
35189:
35190: memset(pFile, 0, sizeof(*pFile));
35191: pFile->pMethod = &winIoMethod;
35192: pFile->h = h;
35193: pFile->lastErrno = NO_ERROR;
35194: pFile->pVfs = pVfs;
35195: pFile->pShm = 0;
35196: pFile->zPath = zName;
35197: if( sqlite3_uri_boolean(zName, "psow", SQLITE_POWERSAFE_OVERWRITE) ){
35198: pFile->ctrlFlags |= WINFILE_PSOW;
35199: }
35200:
35201: #if SQLITE_OS_WINCE
35202: if( isReadWrite && eType==SQLITE_OPEN_MAIN_DB
35203: && !winceCreateLock(zName, pFile)
35204: ){
35205: osCloseHandle(h);
35206: sqlite3_free(zConverted);
35207: return SQLITE_CANTOPEN_BKPT;
35208: }
35209: if( isTemp ){
35210: pFile->zDeleteOnClose = zConverted;
35211: }else
35212: #endif
35213: {
35214: sqlite3_free(zConverted);
35215: }
35216:
35217: OpenCounter(+1);
35218: return rc;
35219: }
35220:
35221: /*
35222: ** Delete the named file.
35223: **
35224: ** Note that Windows does not allow a file to be deleted if some other
35225: ** process has it open. Sometimes a virus scanner or indexing program
35226: ** will open a journal file shortly after it is created in order to do
35227: ** whatever it does. While this other process is holding the
35228: ** file open, we will be unable to delete it. To work around this
35229: ** problem, we delay 100 milliseconds and try to delete again. Up
35230: ** to MX_DELETION_ATTEMPTs deletion attempts are run before giving
35231: ** up and returning an error.
35232: */
35233: static int winDelete(
35234: sqlite3_vfs *pVfs, /* Not used on win32 */
35235: const char *zFilename, /* Name of file to delete */
35236: int syncDir /* Not used on win32 */
35237: ){
35238: int cnt = 0;
35239: int rc;
35240: DWORD lastErrno;
35241: void *zConverted;
35242: UNUSED_PARAMETER(pVfs);
35243: UNUSED_PARAMETER(syncDir);
35244:
35245: SimulateIOError(return SQLITE_IOERR_DELETE);
35246: zConverted = convertUtf8Filename(zFilename);
35247: if( zConverted==0 ){
35248: return SQLITE_IOERR_NOMEM;
35249: }
35250: if( isNT() ){
35251: rc = 1;
35252: while( osGetFileAttributesW(zConverted)!=INVALID_FILE_ATTRIBUTES &&
35253: (rc = osDeleteFileW(zConverted))==0 && retryIoerr(&cnt, &lastErrno) ){}
35254: rc = rc ? SQLITE_OK : SQLITE_ERROR;
35255: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
35256: ** Since the ANSI version of these Windows API do not exist for WINCE,
35257: ** it's important to not reference them for WINCE builds.
35258: */
35259: #if SQLITE_OS_WINCE==0
35260: }else{
35261: rc = 1;
35262: while( osGetFileAttributesA(zConverted)!=INVALID_FILE_ATTRIBUTES &&
35263: (rc = osDeleteFileA(zConverted))==0 && retryIoerr(&cnt, &lastErrno) ){}
35264: rc = rc ? SQLITE_OK : SQLITE_ERROR;
35265: #endif
35266: }
35267: if( rc ){
35268: rc = winLogError(SQLITE_IOERR_DELETE, lastErrno,
35269: "winDelete", zFilename);
35270: }else{
35271: logIoerr(cnt);
35272: }
35273: sqlite3_free(zConverted);
35274: OSTRACE(("DELETE \"%s\" %s\n", zFilename, (rc ? "failed" : "ok" )));
35275: return rc;
35276: }
35277:
35278: /*
35279: ** Check the existance and status of a file.
35280: */
35281: static int winAccess(
35282: sqlite3_vfs *pVfs, /* Not used on win32 */
35283: const char *zFilename, /* Name of file to check */
35284: int flags, /* Type of test to make on this file */
35285: int *pResOut /* OUT: Result */
35286: ){
35287: DWORD attr;
35288: int rc = 0;
35289: DWORD lastErrno;
35290: void *zConverted;
35291: UNUSED_PARAMETER(pVfs);
35292:
35293: SimulateIOError( return SQLITE_IOERR_ACCESS; );
35294: zConverted = convertUtf8Filename(zFilename);
35295: if( zConverted==0 ){
35296: return SQLITE_IOERR_NOMEM;
35297: }
35298: if( isNT() ){
35299: int cnt = 0;
35300: WIN32_FILE_ATTRIBUTE_DATA sAttrData;
35301: memset(&sAttrData, 0, sizeof(sAttrData));
35302: while( !(rc = osGetFileAttributesExW((LPCWSTR)zConverted,
35303: GetFileExInfoStandard,
35304: &sAttrData)) && retryIoerr(&cnt, &lastErrno) ){}
35305: if( rc ){
35306: /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file
35307: ** as if it does not exist.
35308: */
35309: if( flags==SQLITE_ACCESS_EXISTS
35310: && sAttrData.nFileSizeHigh==0
35311: && sAttrData.nFileSizeLow==0 ){
35312: attr = INVALID_FILE_ATTRIBUTES;
35313: }else{
35314: attr = sAttrData.dwFileAttributes;
35315: }
35316: }else{
35317: logIoerr(cnt);
35318: if( lastErrno!=ERROR_FILE_NOT_FOUND ){
35319: winLogError(SQLITE_IOERR_ACCESS, lastErrno, "winAccess", zFilename);
35320: sqlite3_free(zConverted);
35321: return SQLITE_IOERR_ACCESS;
35322: }else{
35323: attr = INVALID_FILE_ATTRIBUTES;
35324: }
35325: }
35326: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
35327: ** Since the ANSI version of these Windows API do not exist for WINCE,
35328: ** it's important to not reference them for WINCE builds.
35329: */
35330: #if SQLITE_OS_WINCE==0
35331: }else{
35332: attr = osGetFileAttributesA((char*)zConverted);
35333: #endif
35334: }
35335: sqlite3_free(zConverted);
35336: switch( flags ){
35337: case SQLITE_ACCESS_READ:
35338: case SQLITE_ACCESS_EXISTS:
35339: rc = attr!=INVALID_FILE_ATTRIBUTES;
35340: break;
35341: case SQLITE_ACCESS_READWRITE:
35342: rc = attr!=INVALID_FILE_ATTRIBUTES &&
35343: (attr & FILE_ATTRIBUTE_READONLY)==0;
35344: break;
35345: default:
35346: assert(!"Invalid flags argument");
35347: }
35348: *pResOut = rc;
35349: return SQLITE_OK;
35350: }
35351:
35352:
35353: /*
35354: ** Turn a relative pathname into a full pathname. Write the full
35355: ** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
35356: ** bytes in size.
35357: */
35358: static int winFullPathname(
35359: sqlite3_vfs *pVfs, /* Pointer to vfs object */
35360: const char *zRelative, /* Possibly relative input path */
35361: int nFull, /* Size of output buffer in bytes */
35362: char *zFull /* Output buffer */
35363: ){
35364:
35365: #if defined(__CYGWIN__)
35366: SimulateIOError( return SQLITE_ERROR );
35367: UNUSED_PARAMETER(nFull);
35368: cygwin_conv_to_full_win32_path(zRelative, zFull);
35369: return SQLITE_OK;
35370: #endif
35371:
35372: #if SQLITE_OS_WINCE
35373: SimulateIOError( return SQLITE_ERROR );
35374: UNUSED_PARAMETER(nFull);
35375: /* WinCE has no concept of a relative pathname, or so I am told. */
35376: sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zRelative);
35377: return SQLITE_OK;
35378: #endif
35379:
35380: #if !SQLITE_OS_WINCE && !defined(__CYGWIN__)
35381: int nByte;
35382: void *zConverted;
35383: char *zOut;
35384:
35385: /* If this path name begins with "/X:", where "X" is any alphabetic
35386: ** character, discard the initial "/" from the pathname.
35387: */
35388: if( zRelative[0]=='/' && sqlite3Isalpha(zRelative[1]) && zRelative[2]==':' ){
35389: zRelative++;
35390: }
35391:
35392: /* It's odd to simulate an io-error here, but really this is just
35393: ** using the io-error infrastructure to test that SQLite handles this
35394: ** function failing. This function could fail if, for example, the
35395: ** current working directory has been unlinked.
35396: */
35397: SimulateIOError( return SQLITE_ERROR );
35398: UNUSED_PARAMETER(nFull);
35399: zConverted = convertUtf8Filename(zRelative);
35400: if( zConverted==0 ){
35401: return SQLITE_IOERR_NOMEM;
35402: }
35403: if( isNT() ){
35404: LPWSTR zTemp;
35405: nByte = osGetFullPathNameW((LPCWSTR)zConverted, 0, 0, 0) + 3;
35406: zTemp = sqlite3_malloc( nByte*sizeof(zTemp[0]) );
35407: if( zTemp==0 ){
35408: sqlite3_free(zConverted);
35409: return SQLITE_IOERR_NOMEM;
35410: }
35411: osGetFullPathNameW((LPCWSTR)zConverted, nByte, zTemp, 0);
35412: sqlite3_free(zConverted);
35413: zOut = unicodeToUtf8(zTemp);
35414: sqlite3_free(zTemp);
35415: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
35416: ** Since the ANSI version of these Windows API do not exist for WINCE,
35417: ** it's important to not reference them for WINCE builds.
35418: */
35419: #if SQLITE_OS_WINCE==0
35420: }else{
35421: char *zTemp;
35422: nByte = osGetFullPathNameA((char*)zConverted, 0, 0, 0) + 3;
35423: zTemp = sqlite3_malloc( nByte*sizeof(zTemp[0]) );
35424: if( zTemp==0 ){
35425: sqlite3_free(zConverted);
35426: return SQLITE_IOERR_NOMEM;
35427: }
35428: osGetFullPathNameA((char*)zConverted, nByte, zTemp, 0);
35429: sqlite3_free(zConverted);
35430: zOut = sqlite3_win32_mbcs_to_utf8(zTemp);
35431: sqlite3_free(zTemp);
35432: #endif
35433: }
35434: if( zOut ){
35435: sqlite3_snprintf(pVfs->mxPathname, zFull, "%s", zOut);
35436: sqlite3_free(zOut);
35437: return SQLITE_OK;
35438: }else{
35439: return SQLITE_IOERR_NOMEM;
35440: }
35441: #endif
35442: }
35443:
35444: #ifndef SQLITE_OMIT_LOAD_EXTENSION
35445: /*
35446: ** Interfaces for opening a shared library, finding entry points
35447: ** within the shared library, and closing the shared library.
35448: */
35449: /*
35450: ** Interfaces for opening a shared library, finding entry points
35451: ** within the shared library, and closing the shared library.
35452: */
35453: static void *winDlOpen(sqlite3_vfs *pVfs, const char *zFilename){
35454: HANDLE h;
35455: void *zConverted = convertUtf8Filename(zFilename);
35456: UNUSED_PARAMETER(pVfs);
35457: if( zConverted==0 ){
35458: return 0;
35459: }
35460: if( isNT() ){
35461: h = osLoadLibraryW((LPCWSTR)zConverted);
35462: /* isNT() is 1 if SQLITE_OS_WINCE==1, so this else is never executed.
35463: ** Since the ANSI version of these Windows API do not exist for WINCE,
35464: ** it's important to not reference them for WINCE builds.
35465: */
35466: #if SQLITE_OS_WINCE==0
35467: }else{
35468: h = osLoadLibraryA((char*)zConverted);
35469: #endif
35470: }
35471: sqlite3_free(zConverted);
35472: return (void*)h;
35473: }
35474: static void winDlError(sqlite3_vfs *pVfs, int nBuf, char *zBufOut){
35475: UNUSED_PARAMETER(pVfs);
35476: getLastErrorMsg(osGetLastError(), nBuf, zBufOut);
35477: }
35478: static void (*winDlSym(sqlite3_vfs *pVfs, void *pHandle, const char *zSymbol))(void){
35479: UNUSED_PARAMETER(pVfs);
35480: return (void(*)(void))osGetProcAddressA((HANDLE)pHandle, zSymbol);
35481: }
35482: static void winDlClose(sqlite3_vfs *pVfs, void *pHandle){
35483: UNUSED_PARAMETER(pVfs);
35484: osFreeLibrary((HANDLE)pHandle);
35485: }
35486: #else /* if SQLITE_OMIT_LOAD_EXTENSION is defined: */
35487: #define winDlOpen 0
35488: #define winDlError 0
35489: #define winDlSym 0
35490: #define winDlClose 0
35491: #endif
35492:
35493:
35494: /*
35495: ** Write up to nBuf bytes of randomness into zBuf.
35496: */
35497: static int winRandomness(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
35498: int n = 0;
35499: UNUSED_PARAMETER(pVfs);
35500: #if defined(SQLITE_TEST)
35501: n = nBuf;
35502: memset(zBuf, 0, nBuf);
35503: #else
35504: if( sizeof(SYSTEMTIME)<=nBuf-n ){
35505: SYSTEMTIME x;
35506: osGetSystemTime(&x);
35507: memcpy(&zBuf[n], &x, sizeof(x));
35508: n += sizeof(x);
35509: }
35510: if( sizeof(DWORD)<=nBuf-n ){
35511: DWORD pid = osGetCurrentProcessId();
35512: memcpy(&zBuf[n], &pid, sizeof(pid));
35513: n += sizeof(pid);
35514: }
35515: if( sizeof(DWORD)<=nBuf-n ){
35516: DWORD cnt = osGetTickCount();
35517: memcpy(&zBuf[n], &cnt, sizeof(cnt));
35518: n += sizeof(cnt);
35519: }
35520: if( sizeof(LARGE_INTEGER)<=nBuf-n ){
35521: LARGE_INTEGER i;
35522: osQueryPerformanceCounter(&i);
35523: memcpy(&zBuf[n], &i, sizeof(i));
35524: n += sizeof(i);
35525: }
35526: #endif
35527: return n;
35528: }
35529:
35530:
35531: /*
35532: ** Sleep for a little while. Return the amount of time slept.
35533: */
35534: static int winSleep(sqlite3_vfs *pVfs, int microsec){
35535: osSleep((microsec+999)/1000);
35536: UNUSED_PARAMETER(pVfs);
35537: return ((microsec+999)/1000)*1000;
35538: }
35539:
35540: /*
35541: ** The following variable, if set to a non-zero value, is interpreted as
35542: ** the number of seconds since 1970 and is used to set the result of
35543: ** sqlite3OsCurrentTime() during testing.
35544: */
35545: #ifdef SQLITE_TEST
35546: SQLITE_API int sqlite3_current_time = 0; /* Fake system time in seconds since 1970. */
35547: #endif
35548:
35549: /*
35550: ** Find the current time (in Universal Coordinated Time). Write into *piNow
35551: ** the current time and date as a Julian Day number times 86_400_000. In
35552: ** other words, write into *piNow the number of milliseconds since the Julian
35553: ** epoch of noon in Greenwich on November 24, 4714 B.C according to the
35554: ** proleptic Gregorian calendar.
35555: **
35556: ** On success, return SQLITE_OK. Return SQLITE_ERROR if the time and date
35557: ** cannot be found.
35558: */
35559: static int winCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *piNow){
35560: /* FILETIME structure is a 64-bit value representing the number of
35561: 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5).
35562: */
35563: FILETIME ft;
35564: static const sqlite3_int64 winFiletimeEpoch = 23058135*(sqlite3_int64)8640000;
35565: #ifdef SQLITE_TEST
35566: static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
35567: #endif
35568: /* 2^32 - to avoid use of LL and warnings in gcc */
35569: static const sqlite3_int64 max32BitValue =
35570: (sqlite3_int64)2000000000 + (sqlite3_int64)2000000000 + (sqlite3_int64)294967296;
35571:
35572: #if SQLITE_OS_WINCE
35573: SYSTEMTIME time;
35574: osGetSystemTime(&time);
35575: /* if SystemTimeToFileTime() fails, it returns zero. */
35576: if (!osSystemTimeToFileTime(&time,&ft)){
35577: return SQLITE_ERROR;
35578: }
35579: #else
35580: osGetSystemTimeAsFileTime( &ft );
35581: #endif
35582:
35583: *piNow = winFiletimeEpoch +
35584: ((((sqlite3_int64)ft.dwHighDateTime)*max32BitValue) +
35585: (sqlite3_int64)ft.dwLowDateTime)/(sqlite3_int64)10000;
35586:
35587: #ifdef SQLITE_TEST
35588: if( sqlite3_current_time ){
35589: *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
35590: }
35591: #endif
35592: UNUSED_PARAMETER(pVfs);
35593: return SQLITE_OK;
35594: }
35595:
35596: /*
35597: ** Find the current time (in Universal Coordinated Time). Write the
35598: ** current time and date as a Julian Day number into *prNow and
35599: ** return 0. Return 1 if the time and date cannot be found.
35600: */
35601: static int winCurrentTime(sqlite3_vfs *pVfs, double *prNow){
35602: int rc;
35603: sqlite3_int64 i;
35604: rc = winCurrentTimeInt64(pVfs, &i);
35605: if( !rc ){
35606: *prNow = i/86400000.0;
35607: }
35608: return rc;
35609: }
35610:
35611: /*
35612: ** The idea is that this function works like a combination of
35613: ** GetLastError() and FormatMessage() on Windows (or errno and
35614: ** strerror_r() on Unix). After an error is returned by an OS
35615: ** function, SQLite calls this function with zBuf pointing to
35616: ** a buffer of nBuf bytes. The OS layer should populate the
35617: ** buffer with a nul-terminated UTF-8 encoded error message
35618: ** describing the last IO error to have occurred within the calling
35619: ** thread.
35620: **
35621: ** If the error message is too large for the supplied buffer,
35622: ** it should be truncated. The return value of xGetLastError
35623: ** is zero if the error message fits in the buffer, or non-zero
35624: ** otherwise (if the message was truncated). If non-zero is returned,
35625: ** then it is not necessary to include the nul-terminator character
35626: ** in the output buffer.
35627: **
35628: ** Not supplying an error message will have no adverse effect
35629: ** on SQLite. It is fine to have an implementation that never
35630: ** returns an error message:
35631: **
35632: ** int xGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
35633: ** assert(zBuf[0]=='\0');
35634: ** return 0;
35635: ** }
35636: **
35637: ** However if an error message is supplied, it will be incorporated
35638: ** by sqlite into the error message available to the user using
35639: ** sqlite3_errmsg(), possibly making IO errors easier to debug.
35640: */
35641: static int winGetLastError(sqlite3_vfs *pVfs, int nBuf, char *zBuf){
35642: UNUSED_PARAMETER(pVfs);
35643: return getLastErrorMsg(osGetLastError(), nBuf, zBuf);
35644: }
35645:
35646: /*
35647: ** Initialize and deinitialize the operating system interface.
35648: */
35649: SQLITE_API int sqlite3_os_init(void){
35650: static sqlite3_vfs winVfs = {
35651: 3, /* iVersion */
35652: sizeof(winFile), /* szOsFile */
35653: MAX_PATH, /* mxPathname */
35654: 0, /* pNext */
35655: "win32", /* zName */
35656: 0, /* pAppData */
35657: winOpen, /* xOpen */
35658: winDelete, /* xDelete */
35659: winAccess, /* xAccess */
35660: winFullPathname, /* xFullPathname */
35661: winDlOpen, /* xDlOpen */
35662: winDlError, /* xDlError */
35663: winDlSym, /* xDlSym */
35664: winDlClose, /* xDlClose */
35665: winRandomness, /* xRandomness */
35666: winSleep, /* xSleep */
35667: winCurrentTime, /* xCurrentTime */
35668: winGetLastError, /* xGetLastError */
35669: winCurrentTimeInt64, /* xCurrentTimeInt64 */
35670: winSetSystemCall, /* xSetSystemCall */
35671: winGetSystemCall, /* xGetSystemCall */
35672: winNextSystemCall, /* xNextSystemCall */
35673: };
35674:
35675: /* Double-check that the aSyscall[] array has been constructed
35676: ** correctly. See ticket [bb3a86e890c8e96ab] */
35677: assert( ArraySize(aSyscall)==60 );
35678:
35679: #ifndef SQLITE_OMIT_WAL
35680: /* get memory map allocation granularity */
35681: memset(&winSysInfo, 0, sizeof(SYSTEM_INFO));
35682: osGetSystemInfo(&winSysInfo);
35683: assert(winSysInfo.dwAllocationGranularity > 0);
35684: #endif
35685:
35686: sqlite3_vfs_register(&winVfs, 1);
35687: return SQLITE_OK;
35688: }
35689:
35690: SQLITE_API int sqlite3_os_end(void){
35691: return SQLITE_OK;
35692: }
35693:
35694: #endif /* SQLITE_OS_WIN */
35695:
35696: /************** End of os_win.c **********************************************/
35697: /************** Begin file bitvec.c ******************************************/
35698: /*
35699: ** 2008 February 16
35700: **
35701: ** The author disclaims copyright to this source code. In place of
35702: ** a legal notice, here is a blessing:
35703: **
35704: ** May you do good and not evil.
35705: ** May you find forgiveness for yourself and forgive others.
35706: ** May you share freely, never taking more than you give.
35707: **
35708: *************************************************************************
35709: ** This file implements an object that represents a fixed-length
35710: ** bitmap. Bits are numbered starting with 1.
35711: **
35712: ** A bitmap is used to record which pages of a database file have been
35713: ** journalled during a transaction, or which pages have the "dont-write"
35714: ** property. Usually only a few pages are meet either condition.
35715: ** So the bitmap is usually sparse and has low cardinality.
35716: ** But sometimes (for example when during a DROP of a large table) most
35717: ** or all of the pages in a database can get journalled. In those cases,
35718: ** the bitmap becomes dense with high cardinality. The algorithm needs
35719: ** to handle both cases well.
35720: **
35721: ** The size of the bitmap is fixed when the object is created.
35722: **
35723: ** All bits are clear when the bitmap is created. Individual bits
35724: ** may be set or cleared one at a time.
35725: **
35726: ** Test operations are about 100 times more common that set operations.
35727: ** Clear operations are exceedingly rare. There are usually between
35728: ** 5 and 500 set operations per Bitvec object, though the number of sets can
35729: ** sometimes grow into tens of thousands or larger. The size of the
35730: ** Bitvec object is the number of pages in the database file at the
35731: ** start of a transaction, and is thus usually less than a few thousand,
35732: ** but can be as large as 2 billion for a really big database.
35733: */
35734:
35735: /* Size of the Bitvec structure in bytes. */
35736: #define BITVEC_SZ 512
35737:
35738: /* Round the union size down to the nearest pointer boundary, since that's how
35739: ** it will be aligned within the Bitvec struct. */
35740: #define BITVEC_USIZE (((BITVEC_SZ-(3*sizeof(u32)))/sizeof(Bitvec*))*sizeof(Bitvec*))
35741:
35742: /* Type of the array "element" for the bitmap representation.
35743: ** Should be a power of 2, and ideally, evenly divide into BITVEC_USIZE.
35744: ** Setting this to the "natural word" size of your CPU may improve
35745: ** performance. */
35746: #define BITVEC_TELEM u8
35747: /* Size, in bits, of the bitmap element. */
35748: #define BITVEC_SZELEM 8
35749: /* Number of elements in a bitmap array. */
35750: #define BITVEC_NELEM (BITVEC_USIZE/sizeof(BITVEC_TELEM))
35751: /* Number of bits in the bitmap array. */
35752: #define BITVEC_NBIT (BITVEC_NELEM*BITVEC_SZELEM)
35753:
35754: /* Number of u32 values in hash table. */
35755: #define BITVEC_NINT (BITVEC_USIZE/sizeof(u32))
35756: /* Maximum number of entries in hash table before
35757: ** sub-dividing and re-hashing. */
35758: #define BITVEC_MXHASH (BITVEC_NINT/2)
35759: /* Hashing function for the aHash representation.
35760: ** Empirical testing showed that the *37 multiplier
35761: ** (an arbitrary prime)in the hash function provided
35762: ** no fewer collisions than the no-op *1. */
35763: #define BITVEC_HASH(X) (((X)*1)%BITVEC_NINT)
35764:
35765: #define BITVEC_NPTR (BITVEC_USIZE/sizeof(Bitvec *))
35766:
35767:
35768: /*
35769: ** A bitmap is an instance of the following structure.
35770: **
35771: ** This bitmap records the existance of zero or more bits
35772: ** with values between 1 and iSize, inclusive.
35773: **
35774: ** There are three possible representations of the bitmap.
35775: ** If iSize<=BITVEC_NBIT, then Bitvec.u.aBitmap[] is a straight
35776: ** bitmap. The least significant bit is bit 1.
35777: **
35778: ** If iSize>BITVEC_NBIT and iDivisor==0 then Bitvec.u.aHash[] is
35779: ** a hash table that will hold up to BITVEC_MXHASH distinct values.
35780: **
35781: ** Otherwise, the value i is redirected into one of BITVEC_NPTR
35782: ** sub-bitmaps pointed to by Bitvec.u.apSub[]. Each subbitmap
35783: ** handles up to iDivisor separate values of i. apSub[0] holds
35784: ** values between 1 and iDivisor. apSub[1] holds values between
35785: ** iDivisor+1 and 2*iDivisor. apSub[N] holds values between
35786: ** N*iDivisor+1 and (N+1)*iDivisor. Each subbitmap is normalized
35787: ** to hold deal with values between 1 and iDivisor.
35788: */
35789: struct Bitvec {
35790: u32 iSize; /* Maximum bit index. Max iSize is 4,294,967,296. */
35791: u32 nSet; /* Number of bits that are set - only valid for aHash
35792: ** element. Max is BITVEC_NINT. For BITVEC_SZ of 512,
35793: ** this would be 125. */
35794: u32 iDivisor; /* Number of bits handled by each apSub[] entry. */
35795: /* Should >=0 for apSub element. */
35796: /* Max iDivisor is max(u32) / BITVEC_NPTR + 1. */
35797: /* For a BITVEC_SZ of 512, this would be 34,359,739. */
35798: union {
35799: BITVEC_TELEM aBitmap[BITVEC_NELEM]; /* Bitmap representation */
35800: u32 aHash[BITVEC_NINT]; /* Hash table representation */
35801: Bitvec *apSub[BITVEC_NPTR]; /* Recursive representation */
35802: } u;
35803: };
35804:
35805: /*
35806: ** Create a new bitmap object able to handle bits between 0 and iSize,
35807: ** inclusive. Return a pointer to the new object. Return NULL if
35808: ** malloc fails.
35809: */
35810: SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32 iSize){
35811: Bitvec *p;
35812: assert( sizeof(*p)==BITVEC_SZ );
35813: p = sqlite3MallocZero( sizeof(*p) );
35814: if( p ){
35815: p->iSize = iSize;
35816: }
35817: return p;
35818: }
35819:
35820: /*
35821: ** Check to see if the i-th bit is set. Return true or false.
35822: ** If p is NULL (if the bitmap has not been created) or if
35823: ** i is out of range, then return false.
35824: */
35825: SQLITE_PRIVATE int sqlite3BitvecTest(Bitvec *p, u32 i){
35826: if( p==0 ) return 0;
35827: if( i>p->iSize || i==0 ) return 0;
35828: i--;
35829: while( p->iDivisor ){
35830: u32 bin = i/p->iDivisor;
35831: i = i%p->iDivisor;
35832: p = p->u.apSub[bin];
35833: if (!p) {
35834: return 0;
35835: }
35836: }
35837: if( p->iSize<=BITVEC_NBIT ){
35838: return (p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))))!=0;
35839: } else{
35840: u32 h = BITVEC_HASH(i++);
35841: while( p->u.aHash[h] ){
35842: if( p->u.aHash[h]==i ) return 1;
35843: h = (h+1) % BITVEC_NINT;
35844: }
35845: return 0;
35846: }
35847: }
35848:
35849: /*
35850: ** Set the i-th bit. Return 0 on success and an error code if
35851: ** anything goes wrong.
35852: **
35853: ** This routine might cause sub-bitmaps to be allocated. Failing
35854: ** to get the memory needed to hold the sub-bitmap is the only
35855: ** that can go wrong with an insert, assuming p and i are valid.
35856: **
35857: ** The calling function must ensure that p is a valid Bitvec object
35858: ** and that the value for "i" is within range of the Bitvec object.
35859: ** Otherwise the behavior is undefined.
35860: */
35861: SQLITE_PRIVATE int sqlite3BitvecSet(Bitvec *p, u32 i){
35862: u32 h;
35863: if( p==0 ) return SQLITE_OK;
35864: assert( i>0 );
35865: assert( i<=p->iSize );
35866: i--;
35867: while((p->iSize > BITVEC_NBIT) && p->iDivisor) {
35868: u32 bin = i/p->iDivisor;
35869: i = i%p->iDivisor;
35870: if( p->u.apSub[bin]==0 ){
35871: p->u.apSub[bin] = sqlite3BitvecCreate( p->iDivisor );
35872: if( p->u.apSub[bin]==0 ) return SQLITE_NOMEM;
35873: }
35874: p = p->u.apSub[bin];
35875: }
35876: if( p->iSize<=BITVEC_NBIT ){
35877: p->u.aBitmap[i/BITVEC_SZELEM] |= 1 << (i&(BITVEC_SZELEM-1));
35878: return SQLITE_OK;
35879: }
35880: h = BITVEC_HASH(i++);
35881: /* if there wasn't a hash collision, and this doesn't */
35882: /* completely fill the hash, then just add it without */
35883: /* worring about sub-dividing and re-hashing. */
35884: if( !p->u.aHash[h] ){
35885: if (p->nSet<(BITVEC_NINT-1)) {
35886: goto bitvec_set_end;
35887: } else {
35888: goto bitvec_set_rehash;
35889: }
35890: }
35891: /* there was a collision, check to see if it's already */
35892: /* in hash, if not, try to find a spot for it */
35893: do {
35894: if( p->u.aHash[h]==i ) return SQLITE_OK;
35895: h++;
35896: if( h>=BITVEC_NINT ) h = 0;
35897: } while( p->u.aHash[h] );
35898: /* we didn't find it in the hash. h points to the first */
35899: /* available free spot. check to see if this is going to */
35900: /* make our hash too "full". */
35901: bitvec_set_rehash:
35902: if( p->nSet>=BITVEC_MXHASH ){
35903: unsigned int j;
35904: int rc;
35905: u32 *aiValues = sqlite3StackAllocRaw(0, sizeof(p->u.aHash));
35906: if( aiValues==0 ){
35907: return SQLITE_NOMEM;
35908: }else{
35909: memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
35910: memset(p->u.apSub, 0, sizeof(p->u.apSub));
35911: p->iDivisor = (p->iSize + BITVEC_NPTR - 1)/BITVEC_NPTR;
35912: rc = sqlite3BitvecSet(p, i);
35913: for(j=0; j<BITVEC_NINT; j++){
35914: if( aiValues[j] ) rc |= sqlite3BitvecSet(p, aiValues[j]);
35915: }
35916: sqlite3StackFree(0, aiValues);
35917: return rc;
35918: }
35919: }
35920: bitvec_set_end:
35921: p->nSet++;
35922: p->u.aHash[h] = i;
35923: return SQLITE_OK;
35924: }
35925:
35926: /*
35927: ** Clear the i-th bit.
35928: **
35929: ** pBuf must be a pointer to at least BITVEC_SZ bytes of temporary storage
35930: ** that BitvecClear can use to rebuilt its hash table.
35931: */
35932: SQLITE_PRIVATE void sqlite3BitvecClear(Bitvec *p, u32 i, void *pBuf){
35933: if( p==0 ) return;
35934: assert( i>0 );
35935: i--;
35936: while( p->iDivisor ){
35937: u32 bin = i/p->iDivisor;
35938: i = i%p->iDivisor;
35939: p = p->u.apSub[bin];
35940: if (!p) {
35941: return;
35942: }
35943: }
35944: if( p->iSize<=BITVEC_NBIT ){
35945: p->u.aBitmap[i/BITVEC_SZELEM] &= ~(1 << (i&(BITVEC_SZELEM-1)));
35946: }else{
35947: unsigned int j;
35948: u32 *aiValues = pBuf;
35949: memcpy(aiValues, p->u.aHash, sizeof(p->u.aHash));
35950: memset(p->u.aHash, 0, sizeof(p->u.aHash));
35951: p->nSet = 0;
35952: for(j=0; j<BITVEC_NINT; j++){
35953: if( aiValues[j] && aiValues[j]!=(i+1) ){
35954: u32 h = BITVEC_HASH(aiValues[j]-1);
35955: p->nSet++;
35956: while( p->u.aHash[h] ){
35957: h++;
35958: if( h>=BITVEC_NINT ) h = 0;
35959: }
35960: p->u.aHash[h] = aiValues[j];
35961: }
35962: }
35963: }
35964: }
35965:
35966: /*
35967: ** Destroy a bitmap object. Reclaim all memory used.
35968: */
35969: SQLITE_PRIVATE void sqlite3BitvecDestroy(Bitvec *p){
35970: if( p==0 ) return;
35971: if( p->iDivisor ){
35972: unsigned int i;
35973: for(i=0; i<BITVEC_NPTR; i++){
35974: sqlite3BitvecDestroy(p->u.apSub[i]);
35975: }
35976: }
35977: sqlite3_free(p);
35978: }
35979:
35980: /*
35981: ** Return the value of the iSize parameter specified when Bitvec *p
35982: ** was created.
35983: */
35984: SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec *p){
35985: return p->iSize;
35986: }
35987:
35988: #ifndef SQLITE_OMIT_BUILTIN_TEST
35989: /*
35990: ** Let V[] be an array of unsigned characters sufficient to hold
35991: ** up to N bits. Let I be an integer between 0 and N. 0<=I<N.
35992: ** Then the following macros can be used to set, clear, or test
35993: ** individual bits within V.
35994: */
35995: #define SETBIT(V,I) V[I>>3] |= (1<<(I&7))
35996: #define CLEARBIT(V,I) V[I>>3] &= ~(1<<(I&7))
35997: #define TESTBIT(V,I) (V[I>>3]&(1<<(I&7)))!=0
35998:
35999: /*
36000: ** This routine runs an extensive test of the Bitvec code.
36001: **
36002: ** The input is an array of integers that acts as a program
36003: ** to test the Bitvec. The integers are opcodes followed
36004: ** by 0, 1, or 3 operands, depending on the opcode. Another
36005: ** opcode follows immediately after the last operand.
36006: **
36007: ** There are 6 opcodes numbered from 0 through 5. 0 is the
36008: ** "halt" opcode and causes the test to end.
36009: **
36010: ** 0 Halt and return the number of errors
36011: ** 1 N S X Set N bits beginning with S and incrementing by X
36012: ** 2 N S X Clear N bits beginning with S and incrementing by X
36013: ** 3 N Set N randomly chosen bits
36014: ** 4 N Clear N randomly chosen bits
36015: ** 5 N S X Set N bits from S increment X in array only, not in bitvec
36016: **
36017: ** The opcodes 1 through 4 perform set and clear operations are performed
36018: ** on both a Bitvec object and on a linear array of bits obtained from malloc.
36019: ** Opcode 5 works on the linear array only, not on the Bitvec.
36020: ** Opcode 5 is used to deliberately induce a fault in order to
36021: ** confirm that error detection works.
36022: **
36023: ** At the conclusion of the test the linear array is compared
36024: ** against the Bitvec object. If there are any differences,
36025: ** an error is returned. If they are the same, zero is returned.
36026: **
36027: ** If a memory allocation error occurs, return -1.
36028: */
36029: SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int sz, int *aOp){
36030: Bitvec *pBitvec = 0;
36031: unsigned char *pV = 0;
36032: int rc = -1;
36033: int i, nx, pc, op;
36034: void *pTmpSpace;
36035:
36036: /* Allocate the Bitvec to be tested and a linear array of
36037: ** bits to act as the reference */
36038: pBitvec = sqlite3BitvecCreate( sz );
36039: pV = sqlite3_malloc( (sz+7)/8 + 1 );
36040: pTmpSpace = sqlite3_malloc(BITVEC_SZ);
36041: if( pBitvec==0 || pV==0 || pTmpSpace==0 ) goto bitvec_end;
36042: memset(pV, 0, (sz+7)/8 + 1);
36043:
36044: /* NULL pBitvec tests */
36045: sqlite3BitvecSet(0, 1);
36046: sqlite3BitvecClear(0, 1, pTmpSpace);
36047:
36048: /* Run the program */
36049: pc = 0;
36050: while( (op = aOp[pc])!=0 ){
36051: switch( op ){
36052: case 1:
36053: case 2:
36054: case 5: {
36055: nx = 4;
36056: i = aOp[pc+2] - 1;
36057: aOp[pc+2] += aOp[pc+3];
36058: break;
36059: }
36060: case 3:
36061: case 4:
36062: default: {
36063: nx = 2;
36064: sqlite3_randomness(sizeof(i), &i);
36065: break;
36066: }
36067: }
36068: if( (--aOp[pc+1]) > 0 ) nx = 0;
36069: pc += nx;
36070: i = (i & 0x7fffffff)%sz;
36071: if( (op & 1)!=0 ){
36072: SETBIT(pV, (i+1));
36073: if( op!=5 ){
36074: if( sqlite3BitvecSet(pBitvec, i+1) ) goto bitvec_end;
36075: }
36076: }else{
36077: CLEARBIT(pV, (i+1));
36078: sqlite3BitvecClear(pBitvec, i+1, pTmpSpace);
36079: }
36080: }
36081:
36082: /* Test to make sure the linear array exactly matches the
36083: ** Bitvec object. Start with the assumption that they do
36084: ** match (rc==0). Change rc to non-zero if a discrepancy
36085: ** is found.
36086: */
36087: rc = sqlite3BitvecTest(0,0) + sqlite3BitvecTest(pBitvec, sz+1)
36088: + sqlite3BitvecTest(pBitvec, 0)
36089: + (sqlite3BitvecSize(pBitvec) - sz);
36090: for(i=1; i<=sz; i++){
36091: if( (TESTBIT(pV,i))!=sqlite3BitvecTest(pBitvec,i) ){
36092: rc = i;
36093: break;
36094: }
36095: }
36096:
36097: /* Free allocated structure */
36098: bitvec_end:
36099: sqlite3_free(pTmpSpace);
36100: sqlite3_free(pV);
36101: sqlite3BitvecDestroy(pBitvec);
36102: return rc;
36103: }
36104: #endif /* SQLITE_OMIT_BUILTIN_TEST */
36105:
36106: /************** End of bitvec.c **********************************************/
36107: /************** Begin file pcache.c ******************************************/
36108: /*
36109: ** 2008 August 05
36110: **
36111: ** The author disclaims copyright to this source code. In place of
36112: ** a legal notice, here is a blessing:
36113: **
36114: ** May you do good and not evil.
36115: ** May you find forgiveness for yourself and forgive others.
36116: ** May you share freely, never taking more than you give.
36117: **
36118: *************************************************************************
36119: ** This file implements that page cache.
36120: */
36121:
36122: /*
36123: ** A complete page cache is an instance of this structure.
36124: */
36125: struct PCache {
36126: PgHdr *pDirty, *pDirtyTail; /* List of dirty pages in LRU order */
36127: PgHdr *pSynced; /* Last synced page in dirty page list */
36128: int nRef; /* Number of referenced pages */
36129: int szCache; /* Configured cache size */
36130: int szPage; /* Size of every page in this cache */
36131: int szExtra; /* Size of extra space for each page */
36132: int bPurgeable; /* True if pages are on backing store */
36133: int (*xStress)(void*,PgHdr*); /* Call to try make a page clean */
36134: void *pStress; /* Argument to xStress */
36135: sqlite3_pcache *pCache; /* Pluggable cache module */
36136: PgHdr *pPage1; /* Reference to page 1 */
36137: };
36138:
36139: /*
36140: ** Some of the assert() macros in this code are too expensive to run
36141: ** even during normal debugging. Use them only rarely on long-running
36142: ** tests. Enable the expensive asserts using the
36143: ** -DSQLITE_ENABLE_EXPENSIVE_ASSERT=1 compile-time option.
36144: */
36145: #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
36146: # define expensive_assert(X) assert(X)
36147: #else
36148: # define expensive_assert(X)
36149: #endif
36150:
36151: /********************************** Linked List Management ********************/
36152:
36153: #if !defined(NDEBUG) && defined(SQLITE_ENABLE_EXPENSIVE_ASSERT)
36154: /*
36155: ** Check that the pCache->pSynced variable is set correctly. If it
36156: ** is not, either fail an assert or return zero. Otherwise, return
36157: ** non-zero. This is only used in debugging builds, as follows:
36158: **
36159: ** expensive_assert( pcacheCheckSynced(pCache) );
36160: */
36161: static int pcacheCheckSynced(PCache *pCache){
36162: PgHdr *p;
36163: for(p=pCache->pDirtyTail; p!=pCache->pSynced; p=p->pDirtyPrev){
36164: assert( p->nRef || (p->flags&PGHDR_NEED_SYNC) );
36165: }
36166: return (p==0 || p->nRef || (p->flags&PGHDR_NEED_SYNC)==0);
36167: }
36168: #endif /* !NDEBUG && SQLITE_ENABLE_EXPENSIVE_ASSERT */
36169:
36170: /*
36171: ** Remove page pPage from the list of dirty pages.
36172: */
36173: static void pcacheRemoveFromDirtyList(PgHdr *pPage){
36174: PCache *p = pPage->pCache;
36175:
36176: assert( pPage->pDirtyNext || pPage==p->pDirtyTail );
36177: assert( pPage->pDirtyPrev || pPage==p->pDirty );
36178:
36179: /* Update the PCache1.pSynced variable if necessary. */
36180: if( p->pSynced==pPage ){
36181: PgHdr *pSynced = pPage->pDirtyPrev;
36182: while( pSynced && (pSynced->flags&PGHDR_NEED_SYNC) ){
36183: pSynced = pSynced->pDirtyPrev;
36184: }
36185: p->pSynced = pSynced;
36186: }
36187:
36188: if( pPage->pDirtyNext ){
36189: pPage->pDirtyNext->pDirtyPrev = pPage->pDirtyPrev;
36190: }else{
36191: assert( pPage==p->pDirtyTail );
36192: p->pDirtyTail = pPage->pDirtyPrev;
36193: }
36194: if( pPage->pDirtyPrev ){
36195: pPage->pDirtyPrev->pDirtyNext = pPage->pDirtyNext;
36196: }else{
36197: assert( pPage==p->pDirty );
36198: p->pDirty = pPage->pDirtyNext;
36199: }
36200: pPage->pDirtyNext = 0;
36201: pPage->pDirtyPrev = 0;
36202:
36203: expensive_assert( pcacheCheckSynced(p) );
36204: }
36205:
36206: /*
36207: ** Add page pPage to the head of the dirty list (PCache1.pDirty is set to
36208: ** pPage).
36209: */
36210: static void pcacheAddToDirtyList(PgHdr *pPage){
36211: PCache *p = pPage->pCache;
36212:
36213: assert( pPage->pDirtyNext==0 && pPage->pDirtyPrev==0 && p->pDirty!=pPage );
36214:
36215: pPage->pDirtyNext = p->pDirty;
36216: if( pPage->pDirtyNext ){
36217: assert( pPage->pDirtyNext->pDirtyPrev==0 );
36218: pPage->pDirtyNext->pDirtyPrev = pPage;
36219: }
36220: p->pDirty = pPage;
36221: if( !p->pDirtyTail ){
36222: p->pDirtyTail = pPage;
36223: }
36224: if( !p->pSynced && 0==(pPage->flags&PGHDR_NEED_SYNC) ){
36225: p->pSynced = pPage;
36226: }
36227: expensive_assert( pcacheCheckSynced(p) );
36228: }
36229:
36230: /*
36231: ** Wrapper around the pluggable caches xUnpin method. If the cache is
36232: ** being used for an in-memory database, this function is a no-op.
36233: */
36234: static void pcacheUnpin(PgHdr *p){
36235: PCache *pCache = p->pCache;
36236: if( pCache->bPurgeable ){
36237: if( p->pgno==1 ){
36238: pCache->pPage1 = 0;
36239: }
36240: sqlite3GlobalConfig.pcache2.xUnpin(pCache->pCache, p->pPage, 0);
36241: }
36242: }
36243:
36244: /*************************************************** General Interfaces ******
36245: **
36246: ** Initialize and shutdown the page cache subsystem. Neither of these
36247: ** functions are threadsafe.
36248: */
36249: SQLITE_PRIVATE int sqlite3PcacheInitialize(void){
36250: if( sqlite3GlobalConfig.pcache2.xInit==0 ){
36251: /* IMPLEMENTATION-OF: R-26801-64137 If the xInit() method is NULL, then the
36252: ** built-in default page cache is used instead of the application defined
36253: ** page cache. */
36254: sqlite3PCacheSetDefault();
36255: }
36256: return sqlite3GlobalConfig.pcache2.xInit(sqlite3GlobalConfig.pcache2.pArg);
36257: }
36258: SQLITE_PRIVATE void sqlite3PcacheShutdown(void){
36259: if( sqlite3GlobalConfig.pcache2.xShutdown ){
36260: /* IMPLEMENTATION-OF: R-26000-56589 The xShutdown() method may be NULL. */
36261: sqlite3GlobalConfig.pcache2.xShutdown(sqlite3GlobalConfig.pcache2.pArg);
36262: }
36263: }
36264:
36265: /*
36266: ** Return the size in bytes of a PCache object.
36267: */
36268: SQLITE_PRIVATE int sqlite3PcacheSize(void){ return sizeof(PCache); }
36269:
36270: /*
36271: ** Create a new PCache object. Storage space to hold the object
36272: ** has already been allocated and is passed in as the p pointer.
36273: ** The caller discovers how much space needs to be allocated by
36274: ** calling sqlite3PcacheSize().
36275: */
36276: SQLITE_PRIVATE void sqlite3PcacheOpen(
36277: int szPage, /* Size of every page */
36278: int szExtra, /* Extra space associated with each page */
36279: int bPurgeable, /* True if pages are on backing store */
36280: int (*xStress)(void*,PgHdr*),/* Call to try to make pages clean */
36281: void *pStress, /* Argument to xStress */
36282: PCache *p /* Preallocated space for the PCache */
36283: ){
36284: memset(p, 0, sizeof(PCache));
36285: p->szPage = szPage;
36286: p->szExtra = szExtra;
36287: p->bPurgeable = bPurgeable;
36288: p->xStress = xStress;
36289: p->pStress = pStress;
36290: p->szCache = 100;
36291: }
36292:
36293: /*
36294: ** Change the page size for PCache object. The caller must ensure that there
36295: ** are no outstanding page references when this function is called.
36296: */
36297: SQLITE_PRIVATE void sqlite3PcacheSetPageSize(PCache *pCache, int szPage){
36298: assert( pCache->nRef==0 && pCache->pDirty==0 );
36299: if( pCache->pCache ){
36300: sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache);
36301: pCache->pCache = 0;
36302: pCache->pPage1 = 0;
36303: }
36304: pCache->szPage = szPage;
36305: }
36306:
36307: /*
36308: ** Compute the number of pages of cache requested.
36309: */
36310: static int numberOfCachePages(PCache *p){
36311: if( p->szCache>=0 ){
36312: return p->szCache;
36313: }else{
36314: return (int)((-1024*(i64)p->szCache)/(p->szPage+p->szExtra));
36315: }
36316: }
36317:
36318: /*
36319: ** Try to obtain a page from the cache.
36320: */
36321: SQLITE_PRIVATE int sqlite3PcacheFetch(
36322: PCache *pCache, /* Obtain the page from this cache */
36323: Pgno pgno, /* Page number to obtain */
36324: int createFlag, /* If true, create page if it does not exist already */
36325: PgHdr **ppPage /* Write the page here */
36326: ){
36327: sqlite3_pcache_page *pPage = 0;
36328: PgHdr *pPgHdr = 0;
36329: int eCreate;
36330:
36331: assert( pCache!=0 );
36332: assert( createFlag==1 || createFlag==0 );
36333: assert( pgno>0 );
36334:
36335: /* If the pluggable cache (sqlite3_pcache*) has not been allocated,
36336: ** allocate it now.
36337: */
36338: if( !pCache->pCache && createFlag ){
36339: sqlite3_pcache *p;
36340: p = sqlite3GlobalConfig.pcache2.xCreate(
36341: pCache->szPage, pCache->szExtra + sizeof(PgHdr), pCache->bPurgeable
36342: );
36343: if( !p ){
36344: return SQLITE_NOMEM;
36345: }
36346: sqlite3GlobalConfig.pcache2.xCachesize(p, numberOfCachePages(pCache));
36347: pCache->pCache = p;
36348: }
36349:
36350: eCreate = createFlag * (1 + (!pCache->bPurgeable || !pCache->pDirty));
36351: if( pCache->pCache ){
36352: pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, eCreate);
36353: }
36354:
36355: if( !pPage && eCreate==1 ){
36356: PgHdr *pPg;
36357:
36358: /* Find a dirty page to write-out and recycle. First try to find a
36359: ** page that does not require a journal-sync (one with PGHDR_NEED_SYNC
36360: ** cleared), but if that is not possible settle for any other
36361: ** unreferenced dirty page.
36362: */
36363: expensive_assert( pcacheCheckSynced(pCache) );
36364: for(pPg=pCache->pSynced;
36365: pPg && (pPg->nRef || (pPg->flags&PGHDR_NEED_SYNC));
36366: pPg=pPg->pDirtyPrev
36367: );
36368: pCache->pSynced = pPg;
36369: if( !pPg ){
36370: for(pPg=pCache->pDirtyTail; pPg && pPg->nRef; pPg=pPg->pDirtyPrev);
36371: }
36372: if( pPg ){
36373: int rc;
36374: #ifdef SQLITE_LOG_CACHE_SPILL
36375: sqlite3_log(SQLITE_FULL,
36376: "spill page %d making room for %d - cache used: %d/%d",
36377: pPg->pgno, pgno,
36378: sqlite3GlobalConfig.pcache.xPagecount(pCache->pCache),
36379: numberOfCachePages(pCache));
36380: #endif
36381: rc = pCache->xStress(pCache->pStress, pPg);
36382: if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
36383: return rc;
36384: }
36385: }
36386:
36387: pPage = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, pgno, 2);
36388: }
36389:
36390: if( pPage ){
36391: pPgHdr = (PgHdr *)pPage->pExtra;
36392:
36393: if( !pPgHdr->pPage ){
36394: memset(pPgHdr, 0, sizeof(PgHdr));
36395: pPgHdr->pPage = pPage;
36396: pPgHdr->pData = pPage->pBuf;
36397: pPgHdr->pExtra = (void *)&pPgHdr[1];
36398: memset(pPgHdr->pExtra, 0, pCache->szExtra);
36399: pPgHdr->pCache = pCache;
36400: pPgHdr->pgno = pgno;
36401: }
36402: assert( pPgHdr->pCache==pCache );
36403: assert( pPgHdr->pgno==pgno );
36404: assert( pPgHdr->pData==pPage->pBuf );
36405: assert( pPgHdr->pExtra==(void *)&pPgHdr[1] );
36406:
36407: if( 0==pPgHdr->nRef ){
36408: pCache->nRef++;
36409: }
36410: pPgHdr->nRef++;
36411: if( pgno==1 ){
36412: pCache->pPage1 = pPgHdr;
36413: }
36414: }
36415: *ppPage = pPgHdr;
36416: return (pPgHdr==0 && eCreate) ? SQLITE_NOMEM : SQLITE_OK;
36417: }
36418:
36419: /*
36420: ** Decrement the reference count on a page. If the page is clean and the
36421: ** reference count drops to 0, then it is made elible for recycling.
36422: */
36423: SQLITE_PRIVATE void sqlite3PcacheRelease(PgHdr *p){
36424: assert( p->nRef>0 );
36425: p->nRef--;
36426: if( p->nRef==0 ){
36427: PCache *pCache = p->pCache;
36428: pCache->nRef--;
36429: if( (p->flags&PGHDR_DIRTY)==0 ){
36430: pcacheUnpin(p);
36431: }else{
36432: /* Move the page to the head of the dirty list. */
36433: pcacheRemoveFromDirtyList(p);
36434: pcacheAddToDirtyList(p);
36435: }
36436: }
36437: }
36438:
36439: /*
36440: ** Increase the reference count of a supplied page by 1.
36441: */
36442: SQLITE_PRIVATE void sqlite3PcacheRef(PgHdr *p){
36443: assert(p->nRef>0);
36444: p->nRef++;
36445: }
36446:
36447: /*
36448: ** Drop a page from the cache. There must be exactly one reference to the
36449: ** page. This function deletes that reference, so after it returns the
36450: ** page pointed to by p is invalid.
36451: */
36452: SQLITE_PRIVATE void sqlite3PcacheDrop(PgHdr *p){
36453: PCache *pCache;
36454: assert( p->nRef==1 );
36455: if( p->flags&PGHDR_DIRTY ){
36456: pcacheRemoveFromDirtyList(p);
36457: }
36458: pCache = p->pCache;
36459: pCache->nRef--;
36460: if( p->pgno==1 ){
36461: pCache->pPage1 = 0;
36462: }
36463: sqlite3GlobalConfig.pcache2.xUnpin(pCache->pCache, p->pPage, 1);
36464: }
36465:
36466: /*
36467: ** Make sure the page is marked as dirty. If it isn't dirty already,
36468: ** make it so.
36469: */
36470: SQLITE_PRIVATE void sqlite3PcacheMakeDirty(PgHdr *p){
36471: p->flags &= ~PGHDR_DONT_WRITE;
36472: assert( p->nRef>0 );
36473: if( 0==(p->flags & PGHDR_DIRTY) ){
36474: p->flags |= PGHDR_DIRTY;
36475: pcacheAddToDirtyList( p);
36476: }
36477: }
36478:
36479: /*
36480: ** Make sure the page is marked as clean. If it isn't clean already,
36481: ** make it so.
36482: */
36483: SQLITE_PRIVATE void sqlite3PcacheMakeClean(PgHdr *p){
36484: if( (p->flags & PGHDR_DIRTY) ){
36485: pcacheRemoveFromDirtyList(p);
36486: p->flags &= ~(PGHDR_DIRTY|PGHDR_NEED_SYNC);
36487: if( p->nRef==0 ){
36488: pcacheUnpin(p);
36489: }
36490: }
36491: }
36492:
36493: /*
36494: ** Make every page in the cache clean.
36495: */
36496: SQLITE_PRIVATE void sqlite3PcacheCleanAll(PCache *pCache){
36497: PgHdr *p;
36498: while( (p = pCache->pDirty)!=0 ){
36499: sqlite3PcacheMakeClean(p);
36500: }
36501: }
36502:
36503: /*
36504: ** Clear the PGHDR_NEED_SYNC flag from all dirty pages.
36505: */
36506: SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *pCache){
36507: PgHdr *p;
36508: for(p=pCache->pDirty; p; p=p->pDirtyNext){
36509: p->flags &= ~PGHDR_NEED_SYNC;
36510: }
36511: pCache->pSynced = pCache->pDirtyTail;
36512: }
36513:
36514: /*
36515: ** Change the page number of page p to newPgno.
36516: */
36517: SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
36518: PCache *pCache = p->pCache;
36519: assert( p->nRef>0 );
36520: assert( newPgno>0 );
36521: sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
36522: p->pgno = newPgno;
36523: if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
36524: pcacheRemoveFromDirtyList(p);
36525: pcacheAddToDirtyList(p);
36526: }
36527: }
36528:
36529: /*
36530: ** Drop every cache entry whose page number is greater than "pgno". The
36531: ** caller must ensure that there are no outstanding references to any pages
36532: ** other than page 1 with a page number greater than pgno.
36533: **
36534: ** If there is a reference to page 1 and the pgno parameter passed to this
36535: ** function is 0, then the data area associated with page 1 is zeroed, but
36536: ** the page object is not dropped.
36537: */
36538: SQLITE_PRIVATE void sqlite3PcacheTruncate(PCache *pCache, Pgno pgno){
36539: if( pCache->pCache ){
36540: PgHdr *p;
36541: PgHdr *pNext;
36542: for(p=pCache->pDirty; p; p=pNext){
36543: pNext = p->pDirtyNext;
36544: /* This routine never gets call with a positive pgno except right
36545: ** after sqlite3PcacheCleanAll(). So if there are dirty pages,
36546: ** it must be that pgno==0.
36547: */
36548: assert( p->pgno>0 );
36549: if( ALWAYS(p->pgno>pgno) ){
36550: assert( p->flags&PGHDR_DIRTY );
36551: sqlite3PcacheMakeClean(p);
36552: }
36553: }
36554: if( pgno==0 && pCache->pPage1 ){
36555: memset(pCache->pPage1->pData, 0, pCache->szPage);
36556: pgno = 1;
36557: }
36558: sqlite3GlobalConfig.pcache2.xTruncate(pCache->pCache, pgno+1);
36559: }
36560: }
36561:
36562: /*
36563: ** Close a cache.
36564: */
36565: SQLITE_PRIVATE void sqlite3PcacheClose(PCache *pCache){
36566: if( pCache->pCache ){
36567: sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache);
36568: }
36569: }
36570:
36571: /*
36572: ** Discard the contents of the cache.
36573: */
36574: SQLITE_PRIVATE void sqlite3PcacheClear(PCache *pCache){
36575: sqlite3PcacheTruncate(pCache, 0);
36576: }
36577:
36578: /*
36579: ** Merge two lists of pages connected by pDirty and in pgno order.
36580: ** Do not both fixing the pDirtyPrev pointers.
36581: */
36582: static PgHdr *pcacheMergeDirtyList(PgHdr *pA, PgHdr *pB){
36583: PgHdr result, *pTail;
36584: pTail = &result;
36585: while( pA && pB ){
36586: if( pA->pgno<pB->pgno ){
36587: pTail->pDirty = pA;
36588: pTail = pA;
36589: pA = pA->pDirty;
36590: }else{
36591: pTail->pDirty = pB;
36592: pTail = pB;
36593: pB = pB->pDirty;
36594: }
36595: }
36596: if( pA ){
36597: pTail->pDirty = pA;
36598: }else if( pB ){
36599: pTail->pDirty = pB;
36600: }else{
36601: pTail->pDirty = 0;
36602: }
36603: return result.pDirty;
36604: }
36605:
36606: /*
36607: ** Sort the list of pages in accending order by pgno. Pages are
36608: ** connected by pDirty pointers. The pDirtyPrev pointers are
36609: ** corrupted by this sort.
36610: **
36611: ** Since there cannot be more than 2^31 distinct pages in a database,
36612: ** there cannot be more than 31 buckets required by the merge sorter.
36613: ** One extra bucket is added to catch overflow in case something
36614: ** ever changes to make the previous sentence incorrect.
36615: */
36616: #define N_SORT_BUCKET 32
36617: static PgHdr *pcacheSortDirtyList(PgHdr *pIn){
36618: PgHdr *a[N_SORT_BUCKET], *p;
36619: int i;
36620: memset(a, 0, sizeof(a));
36621: while( pIn ){
36622: p = pIn;
36623: pIn = p->pDirty;
36624: p->pDirty = 0;
36625: for(i=0; ALWAYS(i<N_SORT_BUCKET-1); i++){
36626: if( a[i]==0 ){
36627: a[i] = p;
36628: break;
36629: }else{
36630: p = pcacheMergeDirtyList(a[i], p);
36631: a[i] = 0;
36632: }
36633: }
36634: if( NEVER(i==N_SORT_BUCKET-1) ){
36635: /* To get here, there need to be 2^(N_SORT_BUCKET) elements in
36636: ** the input list. But that is impossible.
36637: */
36638: a[i] = pcacheMergeDirtyList(a[i], p);
36639: }
36640: }
36641: p = a[0];
36642: for(i=1; i<N_SORT_BUCKET; i++){
36643: p = pcacheMergeDirtyList(p, a[i]);
36644: }
36645: return p;
36646: }
36647:
36648: /*
36649: ** Return a list of all dirty pages in the cache, sorted by page number.
36650: */
36651: SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache *pCache){
36652: PgHdr *p;
36653: for(p=pCache->pDirty; p; p=p->pDirtyNext){
36654: p->pDirty = p->pDirtyNext;
36655: }
36656: return pcacheSortDirtyList(pCache->pDirty);
36657: }
36658:
36659: /*
36660: ** Return the total number of referenced pages held by the cache.
36661: */
36662: SQLITE_PRIVATE int sqlite3PcacheRefCount(PCache *pCache){
36663: return pCache->nRef;
36664: }
36665:
36666: /*
36667: ** Return the number of references to the page supplied as an argument.
36668: */
36669: SQLITE_PRIVATE int sqlite3PcachePageRefcount(PgHdr *p){
36670: return p->nRef;
36671: }
36672:
36673: /*
36674: ** Return the total number of pages in the cache.
36675: */
36676: SQLITE_PRIVATE int sqlite3PcachePagecount(PCache *pCache){
36677: int nPage = 0;
36678: if( pCache->pCache ){
36679: nPage = sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache);
36680: }
36681: return nPage;
36682: }
36683:
36684: #ifdef SQLITE_TEST
36685: /*
36686: ** Get the suggested cache-size value.
36687: */
36688: SQLITE_PRIVATE int sqlite3PcacheGetCachesize(PCache *pCache){
36689: return numberOfCachePages(pCache);
36690: }
36691: #endif
36692:
36693: /*
36694: ** Set the suggested cache-size value.
36695: */
36696: SQLITE_PRIVATE void sqlite3PcacheSetCachesize(PCache *pCache, int mxPage){
36697: pCache->szCache = mxPage;
36698: if( pCache->pCache ){
36699: sqlite3GlobalConfig.pcache2.xCachesize(pCache->pCache,
36700: numberOfCachePages(pCache));
36701: }
36702: }
36703:
36704: /*
36705: ** Free up as much memory as possible from the page cache.
36706: */
36707: SQLITE_PRIVATE void sqlite3PcacheShrink(PCache *pCache){
36708: if( pCache->pCache ){
36709: sqlite3GlobalConfig.pcache2.xShrink(pCache->pCache);
36710: }
36711: }
36712:
36713: #if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG)
36714: /*
36715: ** For all dirty pages currently in the cache, invoke the specified
36716: ** callback. This is only used if the SQLITE_CHECK_PAGES macro is
36717: ** defined.
36718: */
36719: SQLITE_PRIVATE void sqlite3PcacheIterateDirty(PCache *pCache, void (*xIter)(PgHdr *)){
36720: PgHdr *pDirty;
36721: for(pDirty=pCache->pDirty; pDirty; pDirty=pDirty->pDirtyNext){
36722: xIter(pDirty);
36723: }
36724: }
36725: #endif
36726:
36727: /************** End of pcache.c **********************************************/
36728: /************** Begin file pcache1.c *****************************************/
36729: /*
36730: ** 2008 November 05
36731: **
36732: ** The author disclaims copyright to this source code. In place of
36733: ** a legal notice, here is a blessing:
36734: **
36735: ** May you do good and not evil.
36736: ** May you find forgiveness for yourself and forgive others.
36737: ** May you share freely, never taking more than you give.
36738: **
36739: *************************************************************************
36740: **
36741: ** This file implements the default page cache implementation (the
36742: ** sqlite3_pcache interface). It also contains part of the implementation
36743: ** of the SQLITE_CONFIG_PAGECACHE and sqlite3_release_memory() features.
36744: ** If the default page cache implementation is overriden, then neither of
36745: ** these two features are available.
36746: */
36747:
36748:
36749: typedef struct PCache1 PCache1;
36750: typedef struct PgHdr1 PgHdr1;
36751: typedef struct PgFreeslot PgFreeslot;
36752: typedef struct PGroup PGroup;
36753:
36754: /* Each page cache (or PCache) belongs to a PGroup. A PGroup is a set
36755: ** of one or more PCaches that are able to recycle each others unpinned
36756: ** pages when they are under memory pressure. A PGroup is an instance of
36757: ** the following object.
36758: **
36759: ** This page cache implementation works in one of two modes:
36760: **
36761: ** (1) Every PCache is the sole member of its own PGroup. There is
36762: ** one PGroup per PCache.
36763: **
36764: ** (2) There is a single global PGroup that all PCaches are a member
36765: ** of.
36766: **
36767: ** Mode 1 uses more memory (since PCache instances are not able to rob
36768: ** unused pages from other PCaches) but it also operates without a mutex,
36769: ** and is therefore often faster. Mode 2 requires a mutex in order to be
36770: ** threadsafe, but recycles pages more efficiently.
36771: **
36772: ** For mode (1), PGroup.mutex is NULL. For mode (2) there is only a single
36773: ** PGroup which is the pcache1.grp global variable and its mutex is
36774: ** SQLITE_MUTEX_STATIC_LRU.
36775: */
36776: struct PGroup {
36777: sqlite3_mutex *mutex; /* MUTEX_STATIC_LRU or NULL */
36778: unsigned int nMaxPage; /* Sum of nMax for purgeable caches */
36779: unsigned int nMinPage; /* Sum of nMin for purgeable caches */
36780: unsigned int mxPinned; /* nMaxpage + 10 - nMinPage */
36781: unsigned int nCurrentPage; /* Number of purgeable pages allocated */
36782: PgHdr1 *pLruHead, *pLruTail; /* LRU list of unpinned pages */
36783: };
36784:
36785: /* Each page cache is an instance of the following object. Every
36786: ** open database file (including each in-memory database and each
36787: ** temporary or transient database) has a single page cache which
36788: ** is an instance of this object.
36789: **
36790: ** Pointers to structures of this type are cast and returned as
36791: ** opaque sqlite3_pcache* handles.
36792: */
36793: struct PCache1 {
36794: /* Cache configuration parameters. Page size (szPage) and the purgeable
36795: ** flag (bPurgeable) are set when the cache is created. nMax may be
36796: ** modified at any time by a call to the pcache1Cachesize() method.
36797: ** The PGroup mutex must be held when accessing nMax.
36798: */
36799: PGroup *pGroup; /* PGroup this cache belongs to */
36800: int szPage; /* Size of allocated pages in bytes */
36801: int szExtra; /* Size of extra space in bytes */
36802: int bPurgeable; /* True if cache is purgeable */
36803: unsigned int nMin; /* Minimum number of pages reserved */
36804: unsigned int nMax; /* Configured "cache_size" value */
36805: unsigned int n90pct; /* nMax*9/10 */
36806:
36807: /* Hash table of all pages. The following variables may only be accessed
36808: ** when the accessor is holding the PGroup mutex.
36809: */
36810: unsigned int nRecyclable; /* Number of pages in the LRU list */
36811: unsigned int nPage; /* Total number of pages in apHash */
36812: unsigned int nHash; /* Number of slots in apHash[] */
36813: PgHdr1 **apHash; /* Hash table for fast lookup by key */
36814:
36815: unsigned int iMaxKey; /* Largest key seen since xTruncate() */
36816: };
36817:
36818: /*
36819: ** Each cache entry is represented by an instance of the following
36820: ** structure. Unless SQLITE_PCACHE_SEPARATE_HEADER is defined, a buffer of
36821: ** PgHdr1.pCache->szPage bytes is allocated directly before this structure
36822: ** in memory.
36823: */
36824: struct PgHdr1 {
36825: sqlite3_pcache_page page;
36826: unsigned int iKey; /* Key value (page number) */
36827: PgHdr1 *pNext; /* Next in hash table chain */
36828: PCache1 *pCache; /* Cache that currently owns this page */
36829: PgHdr1 *pLruNext; /* Next in LRU list of unpinned pages */
36830: PgHdr1 *pLruPrev; /* Previous in LRU list of unpinned pages */
36831: };
36832:
36833: /*
36834: ** Free slots in the allocator used to divide up the buffer provided using
36835: ** the SQLITE_CONFIG_PAGECACHE mechanism.
36836: */
36837: struct PgFreeslot {
36838: PgFreeslot *pNext; /* Next free slot */
36839: };
36840:
36841: /*
36842: ** Global data used by this cache.
36843: */
36844: static SQLITE_WSD struct PCacheGlobal {
36845: PGroup grp; /* The global PGroup for mode (2) */
36846:
36847: /* Variables related to SQLITE_CONFIG_PAGECACHE settings. The
36848: ** szSlot, nSlot, pStart, pEnd, nReserve, and isInit values are all
36849: ** fixed at sqlite3_initialize() time and do not require mutex protection.
36850: ** The nFreeSlot and pFree values do require mutex protection.
36851: */
36852: int isInit; /* True if initialized */
36853: int szSlot; /* Size of each free slot */
36854: int nSlot; /* The number of pcache slots */
36855: int nReserve; /* Try to keep nFreeSlot above this */
36856: void *pStart, *pEnd; /* Bounds of pagecache malloc range */
36857: /* Above requires no mutex. Use mutex below for variable that follow. */
36858: sqlite3_mutex *mutex; /* Mutex for accessing the following: */
36859: int nFreeSlot; /* Number of unused pcache slots */
36860: PgFreeslot *pFree; /* Free page blocks */
36861: /* The following value requires a mutex to change. We skip the mutex on
36862: ** reading because (1) most platforms read a 32-bit integer atomically and
36863: ** (2) even if an incorrect value is read, no great harm is done since this
36864: ** is really just an optimization. */
36865: int bUnderPressure; /* True if low on PAGECACHE memory */
36866: } pcache1_g;
36867:
36868: /*
36869: ** All code in this file should access the global structure above via the
36870: ** alias "pcache1". This ensures that the WSD emulation is used when
36871: ** compiling for systems that do not support real WSD.
36872: */
36873: #define pcache1 (GLOBAL(struct PCacheGlobal, pcache1_g))
36874:
36875: /*
36876: ** Macros to enter and leave the PCache LRU mutex.
36877: */
36878: #define pcache1EnterMutex(X) sqlite3_mutex_enter((X)->mutex)
36879: #define pcache1LeaveMutex(X) sqlite3_mutex_leave((X)->mutex)
36880:
36881: /******************************************************************************/
36882: /******** Page Allocation/SQLITE_CONFIG_PCACHE Related Functions **************/
36883:
36884: /*
36885: ** This function is called during initialization if a static buffer is
36886: ** supplied to use for the page-cache by passing the SQLITE_CONFIG_PAGECACHE
36887: ** verb to sqlite3_config(). Parameter pBuf points to an allocation large
36888: ** enough to contain 'n' buffers of 'sz' bytes each.
36889: **
36890: ** This routine is called from sqlite3_initialize() and so it is guaranteed
36891: ** to be serialized already. There is no need for further mutexing.
36892: */
36893: SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){
36894: if( pcache1.isInit ){
36895: PgFreeslot *p;
36896: sz = ROUNDDOWN8(sz);
36897: pcache1.szSlot = sz;
36898: pcache1.nSlot = pcache1.nFreeSlot = n;
36899: pcache1.nReserve = n>90 ? 10 : (n/10 + 1);
36900: pcache1.pStart = pBuf;
36901: pcache1.pFree = 0;
36902: pcache1.bUnderPressure = 0;
36903: while( n-- ){
36904: p = (PgFreeslot*)pBuf;
36905: p->pNext = pcache1.pFree;
36906: pcache1.pFree = p;
36907: pBuf = (void*)&((char*)pBuf)[sz];
36908: }
36909: pcache1.pEnd = pBuf;
36910: }
36911: }
36912:
36913: /*
36914: ** Malloc function used within this file to allocate space from the buffer
36915: ** configured using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no
36916: ** such buffer exists or there is no space left in it, this function falls
36917: ** back to sqlite3Malloc().
36918: **
36919: ** Multiple threads can run this routine at the same time. Global variables
36920: ** in pcache1 need to be protected via mutex.
36921: */
36922: static void *pcache1Alloc(int nByte){
36923: void *p = 0;
36924: assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
36925: sqlite3StatusSet(SQLITE_STATUS_PAGECACHE_SIZE, nByte);
36926: if( nByte<=pcache1.szSlot ){
36927: sqlite3_mutex_enter(pcache1.mutex);
36928: p = (PgHdr1 *)pcache1.pFree;
36929: if( p ){
36930: pcache1.pFree = pcache1.pFree->pNext;
36931: pcache1.nFreeSlot--;
36932: pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
36933: assert( pcache1.nFreeSlot>=0 );
36934: sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, 1);
36935: }
36936: sqlite3_mutex_leave(pcache1.mutex);
36937: }
36938: if( p==0 ){
36939: /* Memory is not available in the SQLITE_CONFIG_PAGECACHE pool. Get
36940: ** it from sqlite3Malloc instead.
36941: */
36942: p = sqlite3Malloc(nByte);
36943: if( p ){
36944: int sz = sqlite3MallocSize(p);
36945: sqlite3_mutex_enter(pcache1.mutex);
36946: sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, sz);
36947: sqlite3_mutex_leave(pcache1.mutex);
36948: }
36949: sqlite3MemdebugSetType(p, MEMTYPE_PCACHE);
36950: }
36951: return p;
36952: }
36953:
36954: /*
36955: ** Free an allocated buffer obtained from pcache1Alloc().
36956: */
36957: static int pcache1Free(void *p){
36958: int nFreed = 0;
36959: if( p==0 ) return 0;
36960: if( p>=pcache1.pStart && p<pcache1.pEnd ){
36961: PgFreeslot *pSlot;
36962: sqlite3_mutex_enter(pcache1.mutex);
36963: sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_USED, -1);
36964: pSlot = (PgFreeslot*)p;
36965: pSlot->pNext = pcache1.pFree;
36966: pcache1.pFree = pSlot;
36967: pcache1.nFreeSlot++;
36968: pcache1.bUnderPressure = pcache1.nFreeSlot<pcache1.nReserve;
36969: assert( pcache1.nFreeSlot<=pcache1.nSlot );
36970: sqlite3_mutex_leave(pcache1.mutex);
36971: }else{
36972: assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
36973: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
36974: nFreed = sqlite3MallocSize(p);
36975: sqlite3_mutex_enter(pcache1.mutex);
36976: sqlite3StatusAdd(SQLITE_STATUS_PAGECACHE_OVERFLOW, -nFreed);
36977: sqlite3_mutex_leave(pcache1.mutex);
36978: sqlite3_free(p);
36979: }
36980: return nFreed;
36981: }
36982:
36983: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
36984: /*
36985: ** Return the size of a pcache allocation
36986: */
36987: static int pcache1MemSize(void *p){
36988: if( p>=pcache1.pStart && p<pcache1.pEnd ){
36989: return pcache1.szSlot;
36990: }else{
36991: int iSize;
36992: assert( sqlite3MemdebugHasType(p, MEMTYPE_PCACHE) );
36993: sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
36994: iSize = sqlite3MallocSize(p);
36995: sqlite3MemdebugSetType(p, MEMTYPE_PCACHE);
36996: return iSize;
36997: }
36998: }
36999: #endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
37000:
37001: /*
37002: ** Allocate a new page object initially associated with cache pCache.
37003: */
37004: static PgHdr1 *pcache1AllocPage(PCache1 *pCache){
37005: PgHdr1 *p = 0;
37006: void *pPg;
37007:
37008: /* The group mutex must be released before pcache1Alloc() is called. This
37009: ** is because it may call sqlite3_release_memory(), which assumes that
37010: ** this mutex is not held. */
37011: assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
37012: pcache1LeaveMutex(pCache->pGroup);
37013: #ifdef SQLITE_PCACHE_SEPARATE_HEADER
37014: pPg = pcache1Alloc(pCache->szPage);
37015: p = sqlite3Malloc(sizeof(PgHdr1) + pCache->szExtra);
37016: if( !pPg || !p ){
37017: pcache1Free(pPg);
37018: sqlite3_free(p);
37019: pPg = 0;
37020: }
37021: #else
37022: pPg = pcache1Alloc(sizeof(PgHdr1) + pCache->szPage + pCache->szExtra);
37023: p = (PgHdr1 *)&((u8 *)pPg)[pCache->szPage];
37024: #endif
37025: pcache1EnterMutex(pCache->pGroup);
37026:
37027: if( pPg ){
37028: p->page.pBuf = pPg;
37029: p->page.pExtra = &p[1];
37030: if( pCache->bPurgeable ){
37031: pCache->pGroup->nCurrentPage++;
37032: }
37033: return p;
37034: }
37035: return 0;
37036: }
37037:
37038: /*
37039: ** Free a page object allocated by pcache1AllocPage().
37040: **
37041: ** The pointer is allowed to be NULL, which is prudent. But it turns out
37042: ** that the current implementation happens to never call this routine
37043: ** with a NULL pointer, so we mark the NULL test with ALWAYS().
37044: */
37045: static void pcache1FreePage(PgHdr1 *p){
37046: if( ALWAYS(p) ){
37047: PCache1 *pCache = p->pCache;
37048: assert( sqlite3_mutex_held(p->pCache->pGroup->mutex) );
37049: pcache1Free(p->page.pBuf);
37050: #ifdef SQLITE_PCACHE_SEPARATE_HEADER
37051: sqlite3_free(p);
37052: #endif
37053: if( pCache->bPurgeable ){
37054: pCache->pGroup->nCurrentPage--;
37055: }
37056: }
37057: }
37058:
37059: /*
37060: ** Malloc function used by SQLite to obtain space from the buffer configured
37061: ** using sqlite3_config(SQLITE_CONFIG_PAGECACHE) option. If no such buffer
37062: ** exists, this function falls back to sqlite3Malloc().
37063: */
37064: SQLITE_PRIVATE void *sqlite3PageMalloc(int sz){
37065: return pcache1Alloc(sz);
37066: }
37067:
37068: /*
37069: ** Free an allocated buffer obtained from sqlite3PageMalloc().
37070: */
37071: SQLITE_PRIVATE void sqlite3PageFree(void *p){
37072: pcache1Free(p);
37073: }
37074:
37075:
37076: /*
37077: ** Return true if it desirable to avoid allocating a new page cache
37078: ** entry.
37079: **
37080: ** If memory was allocated specifically to the page cache using
37081: ** SQLITE_CONFIG_PAGECACHE but that memory has all been used, then
37082: ** it is desirable to avoid allocating a new page cache entry because
37083: ** presumably SQLITE_CONFIG_PAGECACHE was suppose to be sufficient
37084: ** for all page cache needs and we should not need to spill the
37085: ** allocation onto the heap.
37086: **
37087: ** Or, the heap is used for all page cache memory but the heap is
37088: ** under memory pressure, then again it is desirable to avoid
37089: ** allocating a new page cache entry in order to avoid stressing
37090: ** the heap even further.
37091: */
37092: static int pcache1UnderMemoryPressure(PCache1 *pCache){
37093: if( pcache1.nSlot && (pCache->szPage+pCache->szExtra)<=pcache1.szSlot ){
37094: return pcache1.bUnderPressure;
37095: }else{
37096: return sqlite3HeapNearlyFull();
37097: }
37098: }
37099:
37100: /******************************************************************************/
37101: /******** General Implementation Functions ************************************/
37102:
37103: /*
37104: ** This function is used to resize the hash table used by the cache passed
37105: ** as the first argument.
37106: **
37107: ** The PCache mutex must be held when this function is called.
37108: */
37109: static int pcache1ResizeHash(PCache1 *p){
37110: PgHdr1 **apNew;
37111: unsigned int nNew;
37112: unsigned int i;
37113:
37114: assert( sqlite3_mutex_held(p->pGroup->mutex) );
37115:
37116: nNew = p->nHash*2;
37117: if( nNew<256 ){
37118: nNew = 256;
37119: }
37120:
37121: pcache1LeaveMutex(p->pGroup);
37122: if( p->nHash ){ sqlite3BeginBenignMalloc(); }
37123: apNew = (PgHdr1 **)sqlite3_malloc(sizeof(PgHdr1 *)*nNew);
37124: if( p->nHash ){ sqlite3EndBenignMalloc(); }
37125: pcache1EnterMutex(p->pGroup);
37126: if( apNew ){
37127: memset(apNew, 0, sizeof(PgHdr1 *)*nNew);
37128: for(i=0; i<p->nHash; i++){
37129: PgHdr1 *pPage;
37130: PgHdr1 *pNext = p->apHash[i];
37131: while( (pPage = pNext)!=0 ){
37132: unsigned int h = pPage->iKey % nNew;
37133: pNext = pPage->pNext;
37134: pPage->pNext = apNew[h];
37135: apNew[h] = pPage;
37136: }
37137: }
37138: sqlite3_free(p->apHash);
37139: p->apHash = apNew;
37140: p->nHash = nNew;
37141: }
37142:
37143: return (p->apHash ? SQLITE_OK : SQLITE_NOMEM);
37144: }
37145:
37146: /*
37147: ** This function is used internally to remove the page pPage from the
37148: ** PGroup LRU list, if is part of it. If pPage is not part of the PGroup
37149: ** LRU list, then this function is a no-op.
37150: **
37151: ** The PGroup mutex must be held when this function is called.
37152: **
37153: ** If pPage is NULL then this routine is a no-op.
37154: */
37155: static void pcache1PinPage(PgHdr1 *pPage){
37156: PCache1 *pCache;
37157: PGroup *pGroup;
37158:
37159: if( pPage==0 ) return;
37160: pCache = pPage->pCache;
37161: pGroup = pCache->pGroup;
37162: assert( sqlite3_mutex_held(pGroup->mutex) );
37163: if( pPage->pLruNext || pPage==pGroup->pLruTail ){
37164: if( pPage->pLruPrev ){
37165: pPage->pLruPrev->pLruNext = pPage->pLruNext;
37166: }
37167: if( pPage->pLruNext ){
37168: pPage->pLruNext->pLruPrev = pPage->pLruPrev;
37169: }
37170: if( pGroup->pLruHead==pPage ){
37171: pGroup->pLruHead = pPage->pLruNext;
37172: }
37173: if( pGroup->pLruTail==pPage ){
37174: pGroup->pLruTail = pPage->pLruPrev;
37175: }
37176: pPage->pLruNext = 0;
37177: pPage->pLruPrev = 0;
37178: pPage->pCache->nRecyclable--;
37179: }
37180: }
37181:
37182:
37183: /*
37184: ** Remove the page supplied as an argument from the hash table
37185: ** (PCache1.apHash structure) that it is currently stored in.
37186: **
37187: ** The PGroup mutex must be held when this function is called.
37188: */
37189: static void pcache1RemoveFromHash(PgHdr1 *pPage){
37190: unsigned int h;
37191: PCache1 *pCache = pPage->pCache;
37192: PgHdr1 **pp;
37193:
37194: assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
37195: h = pPage->iKey % pCache->nHash;
37196: for(pp=&pCache->apHash[h]; (*pp)!=pPage; pp=&(*pp)->pNext);
37197: *pp = (*pp)->pNext;
37198:
37199: pCache->nPage--;
37200: }
37201:
37202: /*
37203: ** If there are currently more than nMaxPage pages allocated, try
37204: ** to recycle pages to reduce the number allocated to nMaxPage.
37205: */
37206: static void pcache1EnforceMaxPage(PGroup *pGroup){
37207: assert( sqlite3_mutex_held(pGroup->mutex) );
37208: while( pGroup->nCurrentPage>pGroup->nMaxPage && pGroup->pLruTail ){
37209: PgHdr1 *p = pGroup->pLruTail;
37210: assert( p->pCache->pGroup==pGroup );
37211: pcache1PinPage(p);
37212: pcache1RemoveFromHash(p);
37213: pcache1FreePage(p);
37214: }
37215: }
37216:
37217: /*
37218: ** Discard all pages from cache pCache with a page number (key value)
37219: ** greater than or equal to iLimit. Any pinned pages that meet this
37220: ** criteria are unpinned before they are discarded.
37221: **
37222: ** The PCache mutex must be held when this function is called.
37223: */
37224: static void pcache1TruncateUnsafe(
37225: PCache1 *pCache, /* The cache to truncate */
37226: unsigned int iLimit /* Drop pages with this pgno or larger */
37227: ){
37228: TESTONLY( unsigned int nPage = 0; ) /* To assert pCache->nPage is correct */
37229: unsigned int h;
37230: assert( sqlite3_mutex_held(pCache->pGroup->mutex) );
37231: for(h=0; h<pCache->nHash; h++){
37232: PgHdr1 **pp = &pCache->apHash[h];
37233: PgHdr1 *pPage;
37234: while( (pPage = *pp)!=0 ){
37235: if( pPage->iKey>=iLimit ){
37236: pCache->nPage--;
37237: *pp = pPage->pNext;
37238: pcache1PinPage(pPage);
37239: pcache1FreePage(pPage);
37240: }else{
37241: pp = &pPage->pNext;
37242: TESTONLY( nPage++; )
37243: }
37244: }
37245: }
37246: assert( pCache->nPage==nPage );
37247: }
37248:
37249: /******************************************************************************/
37250: /******** sqlite3_pcache Methods **********************************************/
37251:
37252: /*
37253: ** Implementation of the sqlite3_pcache.xInit method.
37254: */
37255: static int pcache1Init(void *NotUsed){
37256: UNUSED_PARAMETER(NotUsed);
37257: assert( pcache1.isInit==0 );
37258: memset(&pcache1, 0, sizeof(pcache1));
37259: if( sqlite3GlobalConfig.bCoreMutex ){
37260: pcache1.grp.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU);
37261: pcache1.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PMEM);
37262: }
37263: pcache1.grp.mxPinned = 10;
37264: pcache1.isInit = 1;
37265: return SQLITE_OK;
37266: }
37267:
37268: /*
37269: ** Implementation of the sqlite3_pcache.xShutdown method.
37270: ** Note that the static mutex allocated in xInit does
37271: ** not need to be freed.
37272: */
37273: static void pcache1Shutdown(void *NotUsed){
37274: UNUSED_PARAMETER(NotUsed);
37275: assert( pcache1.isInit!=0 );
37276: memset(&pcache1, 0, sizeof(pcache1));
37277: }
37278:
37279: /*
37280: ** Implementation of the sqlite3_pcache.xCreate method.
37281: **
37282: ** Allocate a new cache.
37283: */
37284: static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){
37285: PCache1 *pCache; /* The newly created page cache */
37286: PGroup *pGroup; /* The group the new page cache will belong to */
37287: int sz; /* Bytes of memory required to allocate the new cache */
37288:
37289: /*
37290: ** The seperateCache variable is true if each PCache has its own private
37291: ** PGroup. In other words, separateCache is true for mode (1) where no
37292: ** mutexing is required.
37293: **
37294: ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT
37295: **
37296: ** * Always use a unified cache in single-threaded applications
37297: **
37298: ** * Otherwise (if multi-threaded and ENABLE_MEMORY_MANAGEMENT is off)
37299: ** use separate caches (mode-1)
37300: */
37301: #if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) || SQLITE_THREADSAFE==0
37302: const int separateCache = 0;
37303: #else
37304: int separateCache = sqlite3GlobalConfig.bCoreMutex>0;
37305: #endif
37306:
37307: assert( (szPage & (szPage-1))==0 && szPage>=512 && szPage<=65536 );
37308: assert( szExtra < 300 );
37309:
37310: sz = sizeof(PCache1) + sizeof(PGroup)*separateCache;
37311: pCache = (PCache1 *)sqlite3_malloc(sz);
37312: if( pCache ){
37313: memset(pCache, 0, sz);
37314: if( separateCache ){
37315: pGroup = (PGroup*)&pCache[1];
37316: pGroup->mxPinned = 10;
37317: }else{
37318: pGroup = &pcache1.grp;
37319: }
37320: pCache->pGroup = pGroup;
37321: pCache->szPage = szPage;
37322: pCache->szExtra = szExtra;
37323: pCache->bPurgeable = (bPurgeable ? 1 : 0);
37324: if( bPurgeable ){
37325: pCache->nMin = 10;
37326: pcache1EnterMutex(pGroup);
37327: pGroup->nMinPage += pCache->nMin;
37328: pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
37329: pcache1LeaveMutex(pGroup);
37330: }
37331: }
37332: return (sqlite3_pcache *)pCache;
37333: }
37334:
37335: /*
37336: ** Implementation of the sqlite3_pcache.xCachesize method.
37337: **
37338: ** Configure the cache_size limit for a cache.
37339: */
37340: static void pcache1Cachesize(sqlite3_pcache *p, int nMax){
37341: PCache1 *pCache = (PCache1 *)p;
37342: if( pCache->bPurgeable ){
37343: PGroup *pGroup = pCache->pGroup;
37344: pcache1EnterMutex(pGroup);
37345: pGroup->nMaxPage += (nMax - pCache->nMax);
37346: pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
37347: pCache->nMax = nMax;
37348: pCache->n90pct = pCache->nMax*9/10;
37349: pcache1EnforceMaxPage(pGroup);
37350: pcache1LeaveMutex(pGroup);
37351: }
37352: }
37353:
37354: /*
37355: ** Implementation of the sqlite3_pcache.xShrink method.
37356: **
37357: ** Free up as much memory as possible.
37358: */
37359: static void pcache1Shrink(sqlite3_pcache *p){
37360: PCache1 *pCache = (PCache1*)p;
37361: if( pCache->bPurgeable ){
37362: PGroup *pGroup = pCache->pGroup;
37363: int savedMaxPage;
37364: pcache1EnterMutex(pGroup);
37365: savedMaxPage = pGroup->nMaxPage;
37366: pGroup->nMaxPage = 0;
37367: pcache1EnforceMaxPage(pGroup);
37368: pGroup->nMaxPage = savedMaxPage;
37369: pcache1LeaveMutex(pGroup);
37370: }
37371: }
37372:
37373: /*
37374: ** Implementation of the sqlite3_pcache.xPagecount method.
37375: */
37376: static int pcache1Pagecount(sqlite3_pcache *p){
37377: int n;
37378: PCache1 *pCache = (PCache1*)p;
37379: pcache1EnterMutex(pCache->pGroup);
37380: n = pCache->nPage;
37381: pcache1LeaveMutex(pCache->pGroup);
37382: return n;
37383: }
37384:
37385: /*
37386: ** Implementation of the sqlite3_pcache.xFetch method.
37387: **
37388: ** Fetch a page by key value.
37389: **
37390: ** Whether or not a new page may be allocated by this function depends on
37391: ** the value of the createFlag argument. 0 means do not allocate a new
37392: ** page. 1 means allocate a new page if space is easily available. 2
37393: ** means to try really hard to allocate a new page.
37394: **
37395: ** For a non-purgeable cache (a cache used as the storage for an in-memory
37396: ** database) there is really no difference between createFlag 1 and 2. So
37397: ** the calling function (pcache.c) will never have a createFlag of 1 on
37398: ** a non-purgeable cache.
37399: **
37400: ** There are three different approaches to obtaining space for a page,
37401: ** depending on the value of parameter createFlag (which may be 0, 1 or 2).
37402: **
37403: ** 1. Regardless of the value of createFlag, the cache is searched for a
37404: ** copy of the requested page. If one is found, it is returned.
37405: **
37406: ** 2. If createFlag==0 and the page is not already in the cache, NULL is
37407: ** returned.
37408: **
37409: ** 3. If createFlag is 1, and the page is not already in the cache, then
37410: ** return NULL (do not allocate a new page) if any of the following
37411: ** conditions are true:
37412: **
37413: ** (a) the number of pages pinned by the cache is greater than
37414: ** PCache1.nMax, or
37415: **
37416: ** (b) the number of pages pinned by the cache is greater than
37417: ** the sum of nMax for all purgeable caches, less the sum of
37418: ** nMin for all other purgeable caches, or
37419: **
37420: ** 4. If none of the first three conditions apply and the cache is marked
37421: ** as purgeable, and if one of the following is true:
37422: **
37423: ** (a) The number of pages allocated for the cache is already
37424: ** PCache1.nMax, or
37425: **
37426: ** (b) The number of pages allocated for all purgeable caches is
37427: ** already equal to or greater than the sum of nMax for all
37428: ** purgeable caches,
37429: **
37430: ** (c) The system is under memory pressure and wants to avoid
37431: ** unnecessary pages cache entry allocations
37432: **
37433: ** then attempt to recycle a page from the LRU list. If it is the right
37434: ** size, return the recycled buffer. Otherwise, free the buffer and
37435: ** proceed to step 5.
37436: **
37437: ** 5. Otherwise, allocate and return a new page buffer.
37438: */
37439: static sqlite3_pcache_page *pcache1Fetch(
37440: sqlite3_pcache *p,
37441: unsigned int iKey,
37442: int createFlag
37443: ){
37444: unsigned int nPinned;
37445: PCache1 *pCache = (PCache1 *)p;
37446: PGroup *pGroup;
37447: PgHdr1 *pPage = 0;
37448:
37449: assert( pCache->bPurgeable || createFlag!=1 );
37450: assert( pCache->bPurgeable || pCache->nMin==0 );
37451: assert( pCache->bPurgeable==0 || pCache->nMin==10 );
37452: assert( pCache->nMin==0 || pCache->bPurgeable );
37453: pcache1EnterMutex(pGroup = pCache->pGroup);
37454:
37455: /* Step 1: Search the hash table for an existing entry. */
37456: if( pCache->nHash>0 ){
37457: unsigned int h = iKey % pCache->nHash;
37458: for(pPage=pCache->apHash[h]; pPage&&pPage->iKey!=iKey; pPage=pPage->pNext);
37459: }
37460:
37461: /* Step 2: Abort if no existing page is found and createFlag is 0 */
37462: if( pPage || createFlag==0 ){
37463: pcache1PinPage(pPage);
37464: goto fetch_out;
37465: }
37466:
37467: /* The pGroup local variable will normally be initialized by the
37468: ** pcache1EnterMutex() macro above. But if SQLITE_MUTEX_OMIT is defined,
37469: ** then pcache1EnterMutex() is a no-op, so we have to initialize the
37470: ** local variable here. Delaying the initialization of pGroup is an
37471: ** optimization: The common case is to exit the module before reaching
37472: ** this point.
37473: */
37474: #ifdef SQLITE_MUTEX_OMIT
37475: pGroup = pCache->pGroup;
37476: #endif
37477:
37478: /* Step 3: Abort if createFlag is 1 but the cache is nearly full */
37479: assert( pCache->nPage >= pCache->nRecyclable );
37480: nPinned = pCache->nPage - pCache->nRecyclable;
37481: assert( pGroup->mxPinned == pGroup->nMaxPage + 10 - pGroup->nMinPage );
37482: assert( pCache->n90pct == pCache->nMax*9/10 );
37483: if( createFlag==1 && (
37484: nPinned>=pGroup->mxPinned
37485: || nPinned>=pCache->n90pct
37486: || pcache1UnderMemoryPressure(pCache)
37487: )){
37488: goto fetch_out;
37489: }
37490:
37491: if( pCache->nPage>=pCache->nHash && pcache1ResizeHash(pCache) ){
37492: goto fetch_out;
37493: }
37494:
37495: /* Step 4. Try to recycle a page. */
37496: if( pCache->bPurgeable && pGroup->pLruTail && (
37497: (pCache->nPage+1>=pCache->nMax)
37498: || pGroup->nCurrentPage>=pGroup->nMaxPage
37499: || pcache1UnderMemoryPressure(pCache)
37500: )){
37501: PCache1 *pOther;
37502: pPage = pGroup->pLruTail;
37503: pcache1RemoveFromHash(pPage);
37504: pcache1PinPage(pPage);
37505: pOther = pPage->pCache;
37506:
37507: /* We want to verify that szPage and szExtra are the same for pOther
37508: ** and pCache. Assert that we can verify this by comparing sums. */
37509: assert( (pCache->szPage & (pCache->szPage-1))==0 && pCache->szPage>=512 );
37510: assert( pCache->szExtra<512 );
37511: assert( (pOther->szPage & (pOther->szPage-1))==0 && pOther->szPage>=512 );
37512: assert( pOther->szExtra<512 );
37513:
37514: if( pOther->szPage+pOther->szExtra != pCache->szPage+pCache->szExtra ){
37515: pcache1FreePage(pPage);
37516: pPage = 0;
37517: }else{
37518: pGroup->nCurrentPage -= (pOther->bPurgeable - pCache->bPurgeable);
37519: }
37520: }
37521:
37522: /* Step 5. If a usable page buffer has still not been found,
37523: ** attempt to allocate a new one.
37524: */
37525: if( !pPage ){
37526: if( createFlag==1 ) sqlite3BeginBenignMalloc();
37527: pPage = pcache1AllocPage(pCache);
37528: if( createFlag==1 ) sqlite3EndBenignMalloc();
37529: }
37530:
37531: if( pPage ){
37532: unsigned int h = iKey % pCache->nHash;
37533: pCache->nPage++;
37534: pPage->iKey = iKey;
37535: pPage->pNext = pCache->apHash[h];
37536: pPage->pCache = pCache;
37537: pPage->pLruPrev = 0;
37538: pPage->pLruNext = 0;
37539: *(void **)pPage->page.pExtra = 0;
37540: pCache->apHash[h] = pPage;
37541: }
37542:
37543: fetch_out:
37544: if( pPage && iKey>pCache->iMaxKey ){
37545: pCache->iMaxKey = iKey;
37546: }
37547: pcache1LeaveMutex(pGroup);
37548: return &pPage->page;
37549: }
37550:
37551:
37552: /*
37553: ** Implementation of the sqlite3_pcache.xUnpin method.
37554: **
37555: ** Mark a page as unpinned (eligible for asynchronous recycling).
37556: */
37557: static void pcache1Unpin(
37558: sqlite3_pcache *p,
37559: sqlite3_pcache_page *pPg,
37560: int reuseUnlikely
37561: ){
37562: PCache1 *pCache = (PCache1 *)p;
37563: PgHdr1 *pPage = (PgHdr1 *)pPg;
37564: PGroup *pGroup = pCache->pGroup;
37565:
37566: assert( pPage->pCache==pCache );
37567: pcache1EnterMutex(pGroup);
37568:
37569: /* It is an error to call this function if the page is already
37570: ** part of the PGroup LRU list.
37571: */
37572: assert( pPage->pLruPrev==0 && pPage->pLruNext==0 );
37573: assert( pGroup->pLruHead!=pPage && pGroup->pLruTail!=pPage );
37574:
37575: if( reuseUnlikely || pGroup->nCurrentPage>pGroup->nMaxPage ){
37576: pcache1RemoveFromHash(pPage);
37577: pcache1FreePage(pPage);
37578: }else{
37579: /* Add the page to the PGroup LRU list. */
37580: if( pGroup->pLruHead ){
37581: pGroup->pLruHead->pLruPrev = pPage;
37582: pPage->pLruNext = pGroup->pLruHead;
37583: pGroup->pLruHead = pPage;
37584: }else{
37585: pGroup->pLruTail = pPage;
37586: pGroup->pLruHead = pPage;
37587: }
37588: pCache->nRecyclable++;
37589: }
37590:
37591: pcache1LeaveMutex(pCache->pGroup);
37592: }
37593:
37594: /*
37595: ** Implementation of the sqlite3_pcache.xRekey method.
37596: */
37597: static void pcache1Rekey(
37598: sqlite3_pcache *p,
37599: sqlite3_pcache_page *pPg,
37600: unsigned int iOld,
37601: unsigned int iNew
37602: ){
37603: PCache1 *pCache = (PCache1 *)p;
37604: PgHdr1 *pPage = (PgHdr1 *)pPg;
37605: PgHdr1 **pp;
37606: unsigned int h;
37607: assert( pPage->iKey==iOld );
37608: assert( pPage->pCache==pCache );
37609:
37610: pcache1EnterMutex(pCache->pGroup);
37611:
37612: h = iOld%pCache->nHash;
37613: pp = &pCache->apHash[h];
37614: while( (*pp)!=pPage ){
37615: pp = &(*pp)->pNext;
37616: }
37617: *pp = pPage->pNext;
37618:
37619: h = iNew%pCache->nHash;
37620: pPage->iKey = iNew;
37621: pPage->pNext = pCache->apHash[h];
37622: pCache->apHash[h] = pPage;
37623: if( iNew>pCache->iMaxKey ){
37624: pCache->iMaxKey = iNew;
37625: }
37626:
37627: pcache1LeaveMutex(pCache->pGroup);
37628: }
37629:
37630: /*
37631: ** Implementation of the sqlite3_pcache.xTruncate method.
37632: **
37633: ** Discard all unpinned pages in the cache with a page number equal to
37634: ** or greater than parameter iLimit. Any pinned pages with a page number
37635: ** equal to or greater than iLimit are implicitly unpinned.
37636: */
37637: static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){
37638: PCache1 *pCache = (PCache1 *)p;
37639: pcache1EnterMutex(pCache->pGroup);
37640: if( iLimit<=pCache->iMaxKey ){
37641: pcache1TruncateUnsafe(pCache, iLimit);
37642: pCache->iMaxKey = iLimit-1;
37643: }
37644: pcache1LeaveMutex(pCache->pGroup);
37645: }
37646:
37647: /*
37648: ** Implementation of the sqlite3_pcache.xDestroy method.
37649: **
37650: ** Destroy a cache allocated using pcache1Create().
37651: */
37652: static void pcache1Destroy(sqlite3_pcache *p){
37653: PCache1 *pCache = (PCache1 *)p;
37654: PGroup *pGroup = pCache->pGroup;
37655: assert( pCache->bPurgeable || (pCache->nMax==0 && pCache->nMin==0) );
37656: pcache1EnterMutex(pGroup);
37657: pcache1TruncateUnsafe(pCache, 0);
37658: assert( pGroup->nMaxPage >= pCache->nMax );
37659: pGroup->nMaxPage -= pCache->nMax;
37660: assert( pGroup->nMinPage >= pCache->nMin );
37661: pGroup->nMinPage -= pCache->nMin;
37662: pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
37663: pcache1EnforceMaxPage(pGroup);
37664: pcache1LeaveMutex(pGroup);
37665: sqlite3_free(pCache->apHash);
37666: sqlite3_free(pCache);
37667: }
37668:
37669: /*
37670: ** This function is called during initialization (sqlite3_initialize()) to
37671: ** install the default pluggable cache module, assuming the user has not
37672: ** already provided an alternative.
37673: */
37674: SQLITE_PRIVATE void sqlite3PCacheSetDefault(void){
37675: static const sqlite3_pcache_methods2 defaultMethods = {
37676: 1, /* iVersion */
37677: 0, /* pArg */
37678: pcache1Init, /* xInit */
37679: pcache1Shutdown, /* xShutdown */
37680: pcache1Create, /* xCreate */
37681: pcache1Cachesize, /* xCachesize */
37682: pcache1Pagecount, /* xPagecount */
37683: pcache1Fetch, /* xFetch */
37684: pcache1Unpin, /* xUnpin */
37685: pcache1Rekey, /* xRekey */
37686: pcache1Truncate, /* xTruncate */
37687: pcache1Destroy, /* xDestroy */
37688: pcache1Shrink /* xShrink */
37689: };
37690: sqlite3_config(SQLITE_CONFIG_PCACHE2, &defaultMethods);
37691: }
37692:
37693: #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
37694: /*
37695: ** This function is called to free superfluous dynamically allocated memory
37696: ** held by the pager system. Memory in use by any SQLite pager allocated
37697: ** by the current thread may be sqlite3_free()ed.
37698: **
37699: ** nReq is the number of bytes of memory required. Once this much has
37700: ** been released, the function returns. The return value is the total number
37701: ** of bytes of memory released.
37702: */
37703: SQLITE_PRIVATE int sqlite3PcacheReleaseMemory(int nReq){
37704: int nFree = 0;
37705: assert( sqlite3_mutex_notheld(pcache1.grp.mutex) );
37706: assert( sqlite3_mutex_notheld(pcache1.mutex) );
37707: if( pcache1.pStart==0 ){
37708: PgHdr1 *p;
37709: pcache1EnterMutex(&pcache1.grp);
37710: while( (nReq<0 || nFree<nReq) && ((p=pcache1.grp.pLruTail)!=0) ){
37711: nFree += pcache1MemSize(p->page.pBuf);
37712: #ifdef SQLITE_PCACHE_SEPARATE_HEADER
37713: nFree += sqlite3MemSize(p);
37714: #endif
37715: pcache1PinPage(p);
37716: pcache1RemoveFromHash(p);
37717: pcache1FreePage(p);
37718: }
37719: pcache1LeaveMutex(&pcache1.grp);
37720: }
37721: return nFree;
37722: }
37723: #endif /* SQLITE_ENABLE_MEMORY_MANAGEMENT */
37724:
37725: #ifdef SQLITE_TEST
37726: /*
37727: ** This function is used by test procedures to inspect the internal state
37728: ** of the global cache.
37729: */
37730: SQLITE_PRIVATE void sqlite3PcacheStats(
37731: int *pnCurrent, /* OUT: Total number of pages cached */
37732: int *pnMax, /* OUT: Global maximum cache size */
37733: int *pnMin, /* OUT: Sum of PCache1.nMin for purgeable caches */
37734: int *pnRecyclable /* OUT: Total number of pages available for recycling */
37735: ){
37736: PgHdr1 *p;
37737: int nRecyclable = 0;
37738: for(p=pcache1.grp.pLruHead; p; p=p->pLruNext){
37739: nRecyclable++;
37740: }
37741: *pnCurrent = pcache1.grp.nCurrentPage;
37742: *pnMax = (int)pcache1.grp.nMaxPage;
37743: *pnMin = (int)pcache1.grp.nMinPage;
37744: *pnRecyclable = nRecyclable;
37745: }
37746: #endif
37747:
37748: /************** End of pcache1.c *********************************************/
37749: /************** Begin file rowset.c ******************************************/
37750: /*
37751: ** 2008 December 3
37752: **
37753: ** The author disclaims copyright to this source code. In place of
37754: ** a legal notice, here is a blessing:
37755: **
37756: ** May you do good and not evil.
37757: ** May you find forgiveness for yourself and forgive others.
37758: ** May you share freely, never taking more than you give.
37759: **
37760: *************************************************************************
37761: **
37762: ** This module implements an object we call a "RowSet".
37763: **
37764: ** The RowSet object is a collection of rowids. Rowids
37765: ** are inserted into the RowSet in an arbitrary order. Inserts
37766: ** can be intermixed with tests to see if a given rowid has been
37767: ** previously inserted into the RowSet.
37768: **
37769: ** After all inserts are finished, it is possible to extract the
37770: ** elements of the RowSet in sorted order. Once this extraction
37771: ** process has started, no new elements may be inserted.
37772: **
37773: ** Hence, the primitive operations for a RowSet are:
37774: **
37775: ** CREATE
37776: ** INSERT
37777: ** TEST
37778: ** SMALLEST
37779: ** DESTROY
37780: **
37781: ** The CREATE and DESTROY primitives are the constructor and destructor,
37782: ** obviously. The INSERT primitive adds a new element to the RowSet.
37783: ** TEST checks to see if an element is already in the RowSet. SMALLEST
37784: ** extracts the least value from the RowSet.
37785: **
37786: ** The INSERT primitive might allocate additional memory. Memory is
37787: ** allocated in chunks so most INSERTs do no allocation. There is an
37788: ** upper bound on the size of allocated memory. No memory is freed
37789: ** until DESTROY.
37790: **
37791: ** The TEST primitive includes a "batch" number. The TEST primitive
37792: ** will only see elements that were inserted before the last change
37793: ** in the batch number. In other words, if an INSERT occurs between
37794: ** two TESTs where the TESTs have the same batch nubmer, then the
37795: ** value added by the INSERT will not be visible to the second TEST.
37796: ** The initial batch number is zero, so if the very first TEST contains
37797: ** a non-zero batch number, it will see all prior INSERTs.
37798: **
37799: ** No INSERTs may occurs after a SMALLEST. An assertion will fail if
37800: ** that is attempted.
37801: **
37802: ** The cost of an INSERT is roughly constant. (Sometime new memory
37803: ** has to be allocated on an INSERT.) The cost of a TEST with a new
37804: ** batch number is O(NlogN) where N is the number of elements in the RowSet.
37805: ** The cost of a TEST using the same batch number is O(logN). The cost
37806: ** of the first SMALLEST is O(NlogN). Second and subsequent SMALLEST
37807: ** primitives are constant time. The cost of DESTROY is O(N).
37808: **
37809: ** There is an added cost of O(N) when switching between TEST and
37810: ** SMALLEST primitives.
37811: */
37812:
37813:
37814: /*
37815: ** Target size for allocation chunks.
37816: */
37817: #define ROWSET_ALLOCATION_SIZE 1024
37818:
37819: /*
37820: ** The number of rowset entries per allocation chunk.
37821: */
37822: #define ROWSET_ENTRY_PER_CHUNK \
37823: ((ROWSET_ALLOCATION_SIZE-8)/sizeof(struct RowSetEntry))
37824:
37825: /*
37826: ** Each entry in a RowSet is an instance of the following object.
37827: */
37828: struct RowSetEntry {
37829: i64 v; /* ROWID value for this entry */
37830: struct RowSetEntry *pRight; /* Right subtree (larger entries) or list */
37831: struct RowSetEntry *pLeft; /* Left subtree (smaller entries) */
37832: };
37833:
37834: /*
37835: ** RowSetEntry objects are allocated in large chunks (instances of the
37836: ** following structure) to reduce memory allocation overhead. The
37837: ** chunks are kept on a linked list so that they can be deallocated
37838: ** when the RowSet is destroyed.
37839: */
37840: struct RowSetChunk {
37841: struct RowSetChunk *pNextChunk; /* Next chunk on list of them all */
37842: struct RowSetEntry aEntry[ROWSET_ENTRY_PER_CHUNK]; /* Allocated entries */
37843: };
37844:
37845: /*
37846: ** A RowSet in an instance of the following structure.
37847: **
37848: ** A typedef of this structure if found in sqliteInt.h.
37849: */
37850: struct RowSet {
37851: struct RowSetChunk *pChunk; /* List of all chunk allocations */
37852: sqlite3 *db; /* The database connection */
37853: struct RowSetEntry *pEntry; /* List of entries using pRight */
37854: struct RowSetEntry *pLast; /* Last entry on the pEntry list */
37855: struct RowSetEntry *pFresh; /* Source of new entry objects */
37856: struct RowSetEntry *pTree; /* Binary tree of entries */
37857: u16 nFresh; /* Number of objects on pFresh */
37858: u8 isSorted; /* True if pEntry is sorted */
37859: u8 iBatch; /* Current insert batch */
37860: };
37861:
37862: /*
37863: ** Turn bulk memory into a RowSet object. N bytes of memory
37864: ** are available at pSpace. The db pointer is used as a memory context
37865: ** for any subsequent allocations that need to occur.
37866: ** Return a pointer to the new RowSet object.
37867: **
37868: ** It must be the case that N is sufficient to make a Rowset. If not
37869: ** an assertion fault occurs.
37870: **
37871: ** If N is larger than the minimum, use the surplus as an initial
37872: ** allocation of entries available to be filled.
37873: */
37874: SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db, void *pSpace, unsigned int N){
37875: RowSet *p;
37876: assert( N >= ROUND8(sizeof(*p)) );
37877: p = pSpace;
37878: p->pChunk = 0;
37879: p->db = db;
37880: p->pEntry = 0;
37881: p->pLast = 0;
37882: p->pTree = 0;
37883: p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p);
37884: p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry));
37885: p->isSorted = 1;
37886: p->iBatch = 0;
37887: return p;
37888: }
37889:
37890: /*
37891: ** Deallocate all chunks from a RowSet. This frees all memory that
37892: ** the RowSet has allocated over its lifetime. This routine is
37893: ** the destructor for the RowSet.
37894: */
37895: SQLITE_PRIVATE void sqlite3RowSetClear(RowSet *p){
37896: struct RowSetChunk *pChunk, *pNextChunk;
37897: for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){
37898: pNextChunk = pChunk->pNextChunk;
37899: sqlite3DbFree(p->db, pChunk);
37900: }
37901: p->pChunk = 0;
37902: p->nFresh = 0;
37903: p->pEntry = 0;
37904: p->pLast = 0;
37905: p->pTree = 0;
37906: p->isSorted = 1;
37907: }
37908:
37909: /*
37910: ** Insert a new value into a RowSet.
37911: **
37912: ** The mallocFailed flag of the database connection is set if a
37913: ** memory allocation fails.
37914: */
37915: SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet *p, i64 rowid){
37916: struct RowSetEntry *pEntry; /* The new entry */
37917: struct RowSetEntry *pLast; /* The last prior entry */
37918: assert( p!=0 );
37919: if( p->nFresh==0 ){
37920: struct RowSetChunk *pNew;
37921: pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
37922: if( pNew==0 ){
37923: return;
37924: }
37925: pNew->pNextChunk = p->pChunk;
37926: p->pChunk = pNew;
37927: p->pFresh = pNew->aEntry;
37928: p->nFresh = ROWSET_ENTRY_PER_CHUNK;
37929: }
37930: pEntry = p->pFresh++;
37931: p->nFresh--;
37932: pEntry->v = rowid;
37933: pEntry->pRight = 0;
37934: pLast = p->pLast;
37935: if( pLast ){
37936: if( p->isSorted && rowid<=pLast->v ){
37937: p->isSorted = 0;
37938: }
37939: pLast->pRight = pEntry;
37940: }else{
37941: assert( p->pEntry==0 ); /* Fires if INSERT after SMALLEST */
37942: p->pEntry = pEntry;
37943: }
37944: p->pLast = pEntry;
37945: }
37946:
37947: /*
37948: ** Merge two lists of RowSetEntry objects. Remove duplicates.
37949: **
37950: ** The input lists are connected via pRight pointers and are
37951: ** assumed to each already be in sorted order.
37952: */
37953: static struct RowSetEntry *rowSetMerge(
37954: struct RowSetEntry *pA, /* First sorted list to be merged */
37955: struct RowSetEntry *pB /* Second sorted list to be merged */
37956: ){
37957: struct RowSetEntry head;
37958: struct RowSetEntry *pTail;
37959:
37960: pTail = &head;
37961: while( pA && pB ){
37962: assert( pA->pRight==0 || pA->v<=pA->pRight->v );
37963: assert( pB->pRight==0 || pB->v<=pB->pRight->v );
37964: if( pA->v<pB->v ){
37965: pTail->pRight = pA;
37966: pA = pA->pRight;
37967: pTail = pTail->pRight;
37968: }else if( pB->v<pA->v ){
37969: pTail->pRight = pB;
37970: pB = pB->pRight;
37971: pTail = pTail->pRight;
37972: }else{
37973: pA = pA->pRight;
37974: }
37975: }
37976: if( pA ){
37977: assert( pA->pRight==0 || pA->v<=pA->pRight->v );
37978: pTail->pRight = pA;
37979: }else{
37980: assert( pB==0 || pB->pRight==0 || pB->v<=pB->pRight->v );
37981: pTail->pRight = pB;
37982: }
37983: return head.pRight;
37984: }
37985:
37986: /*
37987: ** Sort all elements on the pEntry list of the RowSet into ascending order.
37988: */
37989: static void rowSetSort(RowSet *p){
37990: unsigned int i;
37991: struct RowSetEntry *pEntry;
37992: struct RowSetEntry *aBucket[40];
37993:
37994: assert( p->isSorted==0 );
37995: memset(aBucket, 0, sizeof(aBucket));
37996: while( p->pEntry ){
37997: pEntry = p->pEntry;
37998: p->pEntry = pEntry->pRight;
37999: pEntry->pRight = 0;
38000: for(i=0; aBucket[i]; i++){
38001: pEntry = rowSetMerge(aBucket[i], pEntry);
38002: aBucket[i] = 0;
38003: }
38004: aBucket[i] = pEntry;
38005: }
38006: pEntry = 0;
38007: for(i=0; i<sizeof(aBucket)/sizeof(aBucket[0]); i++){
38008: pEntry = rowSetMerge(pEntry, aBucket[i]);
38009: }
38010: p->pEntry = pEntry;
38011: p->pLast = 0;
38012: p->isSorted = 1;
38013: }
38014:
38015:
38016: /*
38017: ** The input, pIn, is a binary tree (or subtree) of RowSetEntry objects.
38018: ** Convert this tree into a linked list connected by the pRight pointers
38019: ** and return pointers to the first and last elements of the new list.
38020: */
38021: static void rowSetTreeToList(
38022: struct RowSetEntry *pIn, /* Root of the input tree */
38023: struct RowSetEntry **ppFirst, /* Write head of the output list here */
38024: struct RowSetEntry **ppLast /* Write tail of the output list here */
38025: ){
38026: assert( pIn!=0 );
38027: if( pIn->pLeft ){
38028: struct RowSetEntry *p;
38029: rowSetTreeToList(pIn->pLeft, ppFirst, &p);
38030: p->pRight = pIn;
38031: }else{
38032: *ppFirst = pIn;
38033: }
38034: if( pIn->pRight ){
38035: rowSetTreeToList(pIn->pRight, &pIn->pRight, ppLast);
38036: }else{
38037: *ppLast = pIn;
38038: }
38039: assert( (*ppLast)->pRight==0 );
38040: }
38041:
38042:
38043: /*
38044: ** Convert a sorted list of elements (connected by pRight) into a binary
38045: ** tree with depth of iDepth. A depth of 1 means the tree contains a single
38046: ** node taken from the head of *ppList. A depth of 2 means a tree with
38047: ** three nodes. And so forth.
38048: **
38049: ** Use as many entries from the input list as required and update the
38050: ** *ppList to point to the unused elements of the list. If the input
38051: ** list contains too few elements, then construct an incomplete tree
38052: ** and leave *ppList set to NULL.
38053: **
38054: ** Return a pointer to the root of the constructed binary tree.
38055: */
38056: static struct RowSetEntry *rowSetNDeepTree(
38057: struct RowSetEntry **ppList,
38058: int iDepth
38059: ){
38060: struct RowSetEntry *p; /* Root of the new tree */
38061: struct RowSetEntry *pLeft; /* Left subtree */
38062: if( *ppList==0 ){
38063: return 0;
38064: }
38065: if( iDepth==1 ){
38066: p = *ppList;
38067: *ppList = p->pRight;
38068: p->pLeft = p->pRight = 0;
38069: return p;
38070: }
38071: pLeft = rowSetNDeepTree(ppList, iDepth-1);
38072: p = *ppList;
38073: if( p==0 ){
38074: return pLeft;
38075: }
38076: p->pLeft = pLeft;
38077: *ppList = p->pRight;
38078: p->pRight = rowSetNDeepTree(ppList, iDepth-1);
38079: return p;
38080: }
38081:
38082: /*
38083: ** Convert a sorted list of elements into a binary tree. Make the tree
38084: ** as deep as it needs to be in order to contain the entire list.
38085: */
38086: static struct RowSetEntry *rowSetListToTree(struct RowSetEntry *pList){
38087: int iDepth; /* Depth of the tree so far */
38088: struct RowSetEntry *p; /* Current tree root */
38089: struct RowSetEntry *pLeft; /* Left subtree */
38090:
38091: assert( pList!=0 );
38092: p = pList;
38093: pList = p->pRight;
38094: p->pLeft = p->pRight = 0;
38095: for(iDepth=1; pList; iDepth++){
38096: pLeft = p;
38097: p = pList;
38098: pList = p->pRight;
38099: p->pLeft = pLeft;
38100: p->pRight = rowSetNDeepTree(&pList, iDepth);
38101: }
38102: return p;
38103: }
38104:
38105: /*
38106: ** Convert the list in p->pEntry into a sorted list if it is not
38107: ** sorted already. If there is a binary tree on p->pTree, then
38108: ** convert it into a list too and merge it into the p->pEntry list.
38109: */
38110: static void rowSetToList(RowSet *p){
38111: if( !p->isSorted ){
38112: rowSetSort(p);
38113: }
38114: if( p->pTree ){
38115: struct RowSetEntry *pHead, *pTail;
38116: rowSetTreeToList(p->pTree, &pHead, &pTail);
38117: p->pTree = 0;
38118: p->pEntry = rowSetMerge(p->pEntry, pHead);
38119: }
38120: }
38121:
38122: /*
38123: ** Extract the smallest element from the RowSet.
38124: ** Write the element into *pRowid. Return 1 on success. Return
38125: ** 0 if the RowSet is already empty.
38126: **
38127: ** After this routine has been called, the sqlite3RowSetInsert()
38128: ** routine may not be called again.
38129: */
38130: SQLITE_PRIVATE int sqlite3RowSetNext(RowSet *p, i64 *pRowid){
38131: rowSetToList(p);
38132: if( p->pEntry ){
38133: *pRowid = p->pEntry->v;
38134: p->pEntry = p->pEntry->pRight;
38135: if( p->pEntry==0 ){
38136: sqlite3RowSetClear(p);
38137: }
38138: return 1;
38139: }else{
38140: return 0;
38141: }
38142: }
38143:
38144: /*
38145: ** Check to see if element iRowid was inserted into the the rowset as
38146: ** part of any insert batch prior to iBatch. Return 1 or 0.
38147: */
38148: SQLITE_PRIVATE int sqlite3RowSetTest(RowSet *pRowSet, u8 iBatch, sqlite3_int64 iRowid){
38149: struct RowSetEntry *p;
38150: if( iBatch!=pRowSet->iBatch ){
38151: if( pRowSet->pEntry ){
38152: rowSetToList(pRowSet);
38153: pRowSet->pTree = rowSetListToTree(pRowSet->pEntry);
38154: pRowSet->pEntry = 0;
38155: pRowSet->pLast = 0;
38156: }
38157: pRowSet->iBatch = iBatch;
38158: }
38159: p = pRowSet->pTree;
38160: while( p ){
38161: if( p->v<iRowid ){
38162: p = p->pRight;
38163: }else if( p->v>iRowid ){
38164: p = p->pLeft;
38165: }else{
38166: return 1;
38167: }
38168: }
38169: return 0;
38170: }
38171:
38172: /************** End of rowset.c **********************************************/
38173: /************** Begin file pager.c *******************************************/
38174: /*
38175: ** 2001 September 15
38176: **
38177: ** The author disclaims copyright to this source code. In place of
38178: ** a legal notice, here is a blessing:
38179: **
38180: ** May you do good and not evil.
38181: ** May you find forgiveness for yourself and forgive others.
38182: ** May you share freely, never taking more than you give.
38183: **
38184: *************************************************************************
38185: ** This is the implementation of the page cache subsystem or "pager".
38186: **
38187: ** The pager is used to access a database disk file. It implements
38188: ** atomic commit and rollback through the use of a journal file that
38189: ** is separate from the database file. The pager also implements file
38190: ** locking to prevent two processes from writing the same database
38191: ** file simultaneously, or one process from reading the database while
38192: ** another is writing.
38193: */
38194: #ifndef SQLITE_OMIT_DISKIO
38195: /************** Include wal.h in the middle of pager.c ***********************/
38196: /************** Begin file wal.h *********************************************/
38197: /*
38198: ** 2010 February 1
38199: **
38200: ** The author disclaims copyright to this source code. In place of
38201: ** a legal notice, here is a blessing:
38202: **
38203: ** May you do good and not evil.
38204: ** May you find forgiveness for yourself and forgive others.
38205: ** May you share freely, never taking more than you give.
38206: **
38207: *************************************************************************
38208: ** This header file defines the interface to the write-ahead logging
38209: ** system. Refer to the comments below and the header comment attached to
38210: ** the implementation of each function in log.c for further details.
38211: */
38212:
38213: #ifndef _WAL_H_
38214: #define _WAL_H_
38215:
38216:
38217: /* Additional values that can be added to the sync_flags argument of
38218: ** sqlite3WalFrames():
38219: */
38220: #define WAL_SYNC_TRANSACTIONS 0x20 /* Sync at the end of each transaction */
38221: #define SQLITE_SYNC_MASK 0x13 /* Mask off the SQLITE_SYNC_* values */
38222:
38223: #ifdef SQLITE_OMIT_WAL
38224: # define sqlite3WalOpen(x,y,z) 0
38225: # define sqlite3WalLimit(x,y)
38226: # define sqlite3WalClose(w,x,y,z) 0
38227: # define sqlite3WalBeginReadTransaction(y,z) 0
38228: # define sqlite3WalEndReadTransaction(z)
38229: # define sqlite3WalRead(v,w,x,y,z) 0
38230: # define sqlite3WalDbsize(y) 0
38231: # define sqlite3WalBeginWriteTransaction(y) 0
38232: # define sqlite3WalEndWriteTransaction(x) 0
38233: # define sqlite3WalUndo(x,y,z) 0
38234: # define sqlite3WalSavepoint(y,z)
38235: # define sqlite3WalSavepointUndo(y,z) 0
38236: # define sqlite3WalFrames(u,v,w,x,y,z) 0
38237: # define sqlite3WalCheckpoint(r,s,t,u,v,w,x,y,z) 0
38238: # define sqlite3WalCallback(z) 0
38239: # define sqlite3WalExclusiveMode(y,z) 0
38240: # define sqlite3WalHeapMemory(z) 0
38241: #else
38242:
38243: #define WAL_SAVEPOINT_NDATA 4
38244:
38245: /* Connection to a write-ahead log (WAL) file.
38246: ** There is one object of this type for each pager.
38247: */
38248: typedef struct Wal Wal;
38249:
38250: /* Open and close a connection to a write-ahead log. */
38251: SQLITE_PRIVATE int sqlite3WalOpen(sqlite3_vfs*, sqlite3_file*, const char *, int, i64, Wal**);
38252: SQLITE_PRIVATE int sqlite3WalClose(Wal *pWal, int sync_flags, int, u8 *);
38253:
38254: /* Set the limiting size of a WAL file. */
38255: SQLITE_PRIVATE void sqlite3WalLimit(Wal*, i64);
38256:
38257: /* Used by readers to open (lock) and close (unlock) a snapshot. A
38258: ** snapshot is like a read-transaction. It is the state of the database
38259: ** at an instant in time. sqlite3WalOpenSnapshot gets a read lock and
38260: ** preserves the current state even if the other threads or processes
38261: ** write to or checkpoint the WAL. sqlite3WalCloseSnapshot() closes the
38262: ** transaction and releases the lock.
38263: */
38264: SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *);
38265: SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal);
38266:
38267: /* Read a page from the write-ahead log, if it is present. */
38268: SQLITE_PRIVATE int sqlite3WalRead(Wal *pWal, Pgno pgno, int *pInWal, int nOut, u8 *pOut);
38269:
38270: /* If the WAL is not empty, return the size of the database. */
38271: SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal);
38272:
38273: /* Obtain or release the WRITER lock. */
38274: SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal);
38275: SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal);
38276:
38277: /* Undo any frames written (but not committed) to the log */
38278: SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx);
38279:
38280: /* Return an integer that records the current (uncommitted) write
38281: ** position in the WAL */
38282: SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData);
38283:
38284: /* Move the write position of the WAL back to iFrame. Called in
38285: ** response to a ROLLBACK TO command. */
38286: SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData);
38287:
38288: /* Write a frame or frames to the log. */
38289: SQLITE_PRIVATE int sqlite3WalFrames(Wal *pWal, int, PgHdr *, Pgno, int, int);
38290:
38291: /* Copy pages from the log to the database file */
38292: SQLITE_PRIVATE int sqlite3WalCheckpoint(
38293: Wal *pWal, /* Write-ahead log connection */
38294: int eMode, /* One of PASSIVE, FULL and RESTART */
38295: int (*xBusy)(void*), /* Function to call when busy */
38296: void *pBusyArg, /* Context argument for xBusyHandler */
38297: int sync_flags, /* Flags to sync db file with (or 0) */
38298: int nBuf, /* Size of buffer nBuf */
38299: u8 *zBuf, /* Temporary buffer to use */
38300: int *pnLog, /* OUT: Number of frames in WAL */
38301: int *pnCkpt /* OUT: Number of backfilled frames in WAL */
38302: );
38303:
38304: /* Return the value to pass to a sqlite3_wal_hook callback, the
38305: ** number of frames in the WAL at the point of the last commit since
38306: ** sqlite3WalCallback() was called. If no commits have occurred since
38307: ** the last call, then return 0.
38308: */
38309: SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal);
38310:
38311: /* Tell the wal layer that an EXCLUSIVE lock has been obtained (or released)
38312: ** by the pager layer on the database file.
38313: */
38314: SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op);
38315:
38316: /* Return true if the argument is non-NULL and the WAL module is using
38317: ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
38318: ** WAL module is using shared-memory, return false.
38319: */
38320: SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal);
38321:
38322: #endif /* ifndef SQLITE_OMIT_WAL */
38323: #endif /* _WAL_H_ */
38324:
38325: /************** End of wal.h *************************************************/
38326: /************** Continuing where we left off in pager.c **********************/
38327:
38328:
38329: /******************* NOTES ON THE DESIGN OF THE PAGER ************************
38330: **
38331: ** This comment block describes invariants that hold when using a rollback
38332: ** journal. These invariants do not apply for journal_mode=WAL,
38333: ** journal_mode=MEMORY, or journal_mode=OFF.
38334: **
38335: ** Within this comment block, a page is deemed to have been synced
38336: ** automatically as soon as it is written when PRAGMA synchronous=OFF.
38337: ** Otherwise, the page is not synced until the xSync method of the VFS
38338: ** is called successfully on the file containing the page.
38339: **
38340: ** Definition: A page of the database file is said to be "overwriteable" if
38341: ** one or more of the following are true about the page:
38342: **
38343: ** (a) The original content of the page as it was at the beginning of
38344: ** the transaction has been written into the rollback journal and
38345: ** synced.
38346: **
38347: ** (b) The page was a freelist leaf page at the start of the transaction.
38348: **
38349: ** (c) The page number is greater than the largest page that existed in
38350: ** the database file at the start of the transaction.
38351: **
38352: ** (1) A page of the database file is never overwritten unless one of the
38353: ** following are true:
38354: **
38355: ** (a) The page and all other pages on the same sector are overwriteable.
38356: **
38357: ** (b) The atomic page write optimization is enabled, and the entire
38358: ** transaction other than the update of the transaction sequence
38359: ** number consists of a single page change.
38360: **
38361: ** (2) The content of a page written into the rollback journal exactly matches
38362: ** both the content in the database when the rollback journal was written
38363: ** and the content in the database at the beginning of the current
38364: ** transaction.
38365: **
38366: ** (3) Writes to the database file are an integer multiple of the page size
38367: ** in length and are aligned on a page boundary.
38368: **
38369: ** (4) Reads from the database file are either aligned on a page boundary and
38370: ** an integer multiple of the page size in length or are taken from the
38371: ** first 100 bytes of the database file.
38372: **
38373: ** (5) All writes to the database file are synced prior to the rollback journal
38374: ** being deleted, truncated, or zeroed.
38375: **
38376: ** (6) If a master journal file is used, then all writes to the database file
38377: ** are synced prior to the master journal being deleted.
38378: **
38379: ** Definition: Two databases (or the same database at two points it time)
38380: ** are said to be "logically equivalent" if they give the same answer to
38381: ** all queries. Note in particular the the content of freelist leaf
38382: ** pages can be changed arbitarily without effecting the logical equivalence
38383: ** of the database.
38384: **
38385: ** (7) At any time, if any subset, including the empty set and the total set,
38386: ** of the unsynced changes to a rollback journal are removed and the
38387: ** journal is rolled back, the resulting database file will be logical
38388: ** equivalent to the database file at the beginning of the transaction.
38389: **
38390: ** (8) When a transaction is rolled back, the xTruncate method of the VFS
38391: ** is called to restore the database file to the same size it was at
38392: ** the beginning of the transaction. (In some VFSes, the xTruncate
38393: ** method is a no-op, but that does not change the fact the SQLite will
38394: ** invoke it.)
38395: **
38396: ** (9) Whenever the database file is modified, at least one bit in the range
38397: ** of bytes from 24 through 39 inclusive will be changed prior to releasing
38398: ** the EXCLUSIVE lock, thus signaling other connections on the same
38399: ** database to flush their caches.
38400: **
38401: ** (10) The pattern of bits in bytes 24 through 39 shall not repeat in less
38402: ** than one billion transactions.
38403: **
38404: ** (11) A database file is well-formed at the beginning and at the conclusion
38405: ** of every transaction.
38406: **
38407: ** (12) An EXCLUSIVE lock is held on the database file when writing to
38408: ** the database file.
38409: **
38410: ** (13) A SHARED lock is held on the database file while reading any
38411: ** content out of the database file.
38412: **
38413: ******************************************************************************/
38414:
38415: /*
38416: ** Macros for troubleshooting. Normally turned off
38417: */
38418: #if 0
38419: int sqlite3PagerTrace=1; /* True to enable tracing */
38420: #define sqlite3DebugPrintf printf
38421: #define PAGERTRACE(X) if( sqlite3PagerTrace ){ sqlite3DebugPrintf X; }
38422: #else
38423: #define PAGERTRACE(X)
38424: #endif
38425:
38426: /*
38427: ** The following two macros are used within the PAGERTRACE() macros above
38428: ** to print out file-descriptors.
38429: **
38430: ** PAGERID() takes a pointer to a Pager struct as its argument. The
38431: ** associated file-descriptor is returned. FILEHANDLEID() takes an sqlite3_file
38432: ** struct as its argument.
38433: */
38434: #define PAGERID(p) ((int)(p->fd))
38435: #define FILEHANDLEID(fd) ((int)fd)
38436:
38437: /*
38438: ** The Pager.eState variable stores the current 'state' of a pager. A
38439: ** pager may be in any one of the seven states shown in the following
38440: ** state diagram.
38441: **
38442: ** OPEN <------+------+
38443: ** | | |
38444: ** V | |
38445: ** +---------> READER-------+ |
38446: ** | | |
38447: ** | V |
38448: ** |<-------WRITER_LOCKED------> ERROR
38449: ** | | ^
38450: ** | V |
38451: ** |<------WRITER_CACHEMOD-------->|
38452: ** | | |
38453: ** | V |
38454: ** |<-------WRITER_DBMOD---------->|
38455: ** | | |
38456: ** | V |
38457: ** +<------WRITER_FINISHED-------->+
38458: **
38459: **
38460: ** List of state transitions and the C [function] that performs each:
38461: **
38462: ** OPEN -> READER [sqlite3PagerSharedLock]
38463: ** READER -> OPEN [pager_unlock]
38464: **
38465: ** READER -> WRITER_LOCKED [sqlite3PagerBegin]
38466: ** WRITER_LOCKED -> WRITER_CACHEMOD [pager_open_journal]
38467: ** WRITER_CACHEMOD -> WRITER_DBMOD [syncJournal]
38468: ** WRITER_DBMOD -> WRITER_FINISHED [sqlite3PagerCommitPhaseOne]
38469: ** WRITER_*** -> READER [pager_end_transaction]
38470: **
38471: ** WRITER_*** -> ERROR [pager_error]
38472: ** ERROR -> OPEN [pager_unlock]
38473: **
38474: **
38475: ** OPEN:
38476: **
38477: ** The pager starts up in this state. Nothing is guaranteed in this
38478: ** state - the file may or may not be locked and the database size is
38479: ** unknown. The database may not be read or written.
38480: **
38481: ** * No read or write transaction is active.
38482: ** * Any lock, or no lock at all, may be held on the database file.
38483: ** * The dbSize, dbOrigSize and dbFileSize variables may not be trusted.
38484: **
38485: ** READER:
38486: **
38487: ** In this state all the requirements for reading the database in
38488: ** rollback (non-WAL) mode are met. Unless the pager is (or recently
38489: ** was) in exclusive-locking mode, a user-level read transaction is
38490: ** open. The database size is known in this state.
38491: **
38492: ** A connection running with locking_mode=normal enters this state when
38493: ** it opens a read-transaction on the database and returns to state
38494: ** OPEN after the read-transaction is completed. However a connection
38495: ** running in locking_mode=exclusive (including temp databases) remains in
38496: ** this state even after the read-transaction is closed. The only way
38497: ** a locking_mode=exclusive connection can transition from READER to OPEN
38498: ** is via the ERROR state (see below).
38499: **
38500: ** * A read transaction may be active (but a write-transaction cannot).
38501: ** * A SHARED or greater lock is held on the database file.
38502: ** * The dbSize variable may be trusted (even if a user-level read
38503: ** transaction is not active). The dbOrigSize and dbFileSize variables
38504: ** may not be trusted at this point.
38505: ** * If the database is a WAL database, then the WAL connection is open.
38506: ** * Even if a read-transaction is not open, it is guaranteed that
38507: ** there is no hot-journal in the file-system.
38508: **
38509: ** WRITER_LOCKED:
38510: **
38511: ** The pager moves to this state from READER when a write-transaction
38512: ** is first opened on the database. In WRITER_LOCKED state, all locks
38513: ** required to start a write-transaction are held, but no actual
38514: ** modifications to the cache or database have taken place.
38515: **
38516: ** In rollback mode, a RESERVED or (if the transaction was opened with
38517: ** BEGIN EXCLUSIVE) EXCLUSIVE lock is obtained on the database file when
38518: ** moving to this state, but the journal file is not written to or opened
38519: ** to in this state. If the transaction is committed or rolled back while
38520: ** in WRITER_LOCKED state, all that is required is to unlock the database
38521: ** file.
38522: **
38523: ** IN WAL mode, WalBeginWriteTransaction() is called to lock the log file.
38524: ** If the connection is running with locking_mode=exclusive, an attempt
38525: ** is made to obtain an EXCLUSIVE lock on the database file.
38526: **
38527: ** * A write transaction is active.
38528: ** * If the connection is open in rollback-mode, a RESERVED or greater
38529: ** lock is held on the database file.
38530: ** * If the connection is open in WAL-mode, a WAL write transaction
38531: ** is open (i.e. sqlite3WalBeginWriteTransaction() has been successfully
38532: ** called).
38533: ** * The dbSize, dbOrigSize and dbFileSize variables are all valid.
38534: ** * The contents of the pager cache have not been modified.
38535: ** * The journal file may or may not be open.
38536: ** * Nothing (not even the first header) has been written to the journal.
38537: **
38538: ** WRITER_CACHEMOD:
38539: **
38540: ** A pager moves from WRITER_LOCKED state to this state when a page is
38541: ** first modified by the upper layer. In rollback mode the journal file
38542: ** is opened (if it is not already open) and a header written to the
38543: ** start of it. The database file on disk has not been modified.
38544: **
38545: ** * A write transaction is active.
38546: ** * A RESERVED or greater lock is held on the database file.
38547: ** * The journal file is open and the first header has been written
38548: ** to it, but the header has not been synced to disk.
38549: ** * The contents of the page cache have been modified.
38550: **
38551: ** WRITER_DBMOD:
38552: **
38553: ** The pager transitions from WRITER_CACHEMOD into WRITER_DBMOD state
38554: ** when it modifies the contents of the database file. WAL connections
38555: ** never enter this state (since they do not modify the database file,
38556: ** just the log file).
38557: **
38558: ** * A write transaction is active.
38559: ** * An EXCLUSIVE or greater lock is held on the database file.
38560: ** * The journal file is open and the first header has been written
38561: ** and synced to disk.
38562: ** * The contents of the page cache have been modified (and possibly
38563: ** written to disk).
38564: **
38565: ** WRITER_FINISHED:
38566: **
38567: ** It is not possible for a WAL connection to enter this state.
38568: **
38569: ** A rollback-mode pager changes to WRITER_FINISHED state from WRITER_DBMOD
38570: ** state after the entire transaction has been successfully written into the
38571: ** database file. In this state the transaction may be committed simply
38572: ** by finalizing the journal file. Once in WRITER_FINISHED state, it is
38573: ** not possible to modify the database further. At this point, the upper
38574: ** layer must either commit or rollback the transaction.
38575: **
38576: ** * A write transaction is active.
38577: ** * An EXCLUSIVE or greater lock is held on the database file.
38578: ** * All writing and syncing of journal and database data has finished.
38579: ** If no error occured, all that remains is to finalize the journal to
38580: ** commit the transaction. If an error did occur, the caller will need
38581: ** to rollback the transaction.
38582: **
38583: ** ERROR:
38584: **
38585: ** The ERROR state is entered when an IO or disk-full error (including
38586: ** SQLITE_IOERR_NOMEM) occurs at a point in the code that makes it
38587: ** difficult to be sure that the in-memory pager state (cache contents,
38588: ** db size etc.) are consistent with the contents of the file-system.
38589: **
38590: ** Temporary pager files may enter the ERROR state, but in-memory pagers
38591: ** cannot.
38592: **
38593: ** For example, if an IO error occurs while performing a rollback,
38594: ** the contents of the page-cache may be left in an inconsistent state.
38595: ** At this point it would be dangerous to change back to READER state
38596: ** (as usually happens after a rollback). Any subsequent readers might
38597: ** report database corruption (due to the inconsistent cache), and if
38598: ** they upgrade to writers, they may inadvertently corrupt the database
38599: ** file. To avoid this hazard, the pager switches into the ERROR state
38600: ** instead of READER following such an error.
38601: **
38602: ** Once it has entered the ERROR state, any attempt to use the pager
38603: ** to read or write data returns an error. Eventually, once all
38604: ** outstanding transactions have been abandoned, the pager is able to
38605: ** transition back to OPEN state, discarding the contents of the
38606: ** page-cache and any other in-memory state at the same time. Everything
38607: ** is reloaded from disk (and, if necessary, hot-journal rollback peformed)
38608: ** when a read-transaction is next opened on the pager (transitioning
38609: ** the pager into READER state). At that point the system has recovered
38610: ** from the error.
38611: **
38612: ** Specifically, the pager jumps into the ERROR state if:
38613: **
38614: ** 1. An error occurs while attempting a rollback. This happens in
38615: ** function sqlite3PagerRollback().
38616: **
38617: ** 2. An error occurs while attempting to finalize a journal file
38618: ** following a commit in function sqlite3PagerCommitPhaseTwo().
38619: **
38620: ** 3. An error occurs while attempting to write to the journal or
38621: ** database file in function pagerStress() in order to free up
38622: ** memory.
38623: **
38624: ** In other cases, the error is returned to the b-tree layer. The b-tree
38625: ** layer then attempts a rollback operation. If the error condition
38626: ** persists, the pager enters the ERROR state via condition (1) above.
38627: **
38628: ** Condition (3) is necessary because it can be triggered by a read-only
38629: ** statement executed within a transaction. In this case, if the error
38630: ** code were simply returned to the user, the b-tree layer would not
38631: ** automatically attempt a rollback, as it assumes that an error in a
38632: ** read-only statement cannot leave the pager in an internally inconsistent
38633: ** state.
38634: **
38635: ** * The Pager.errCode variable is set to something other than SQLITE_OK.
38636: ** * There are one or more outstanding references to pages (after the
38637: ** last reference is dropped the pager should move back to OPEN state).
38638: ** * The pager is not an in-memory pager.
38639: **
38640: **
38641: ** Notes:
38642: **
38643: ** * A pager is never in WRITER_DBMOD or WRITER_FINISHED state if the
38644: ** connection is open in WAL mode. A WAL connection is always in one
38645: ** of the first four states.
38646: **
38647: ** * Normally, a connection open in exclusive mode is never in PAGER_OPEN
38648: ** state. There are two exceptions: immediately after exclusive-mode has
38649: ** been turned on (and before any read or write transactions are
38650: ** executed), and when the pager is leaving the "error state".
38651: **
38652: ** * See also: assert_pager_state().
38653: */
38654: #define PAGER_OPEN 0
38655: #define PAGER_READER 1
38656: #define PAGER_WRITER_LOCKED 2
38657: #define PAGER_WRITER_CACHEMOD 3
38658: #define PAGER_WRITER_DBMOD 4
38659: #define PAGER_WRITER_FINISHED 5
38660: #define PAGER_ERROR 6
38661:
38662: /*
38663: ** The Pager.eLock variable is almost always set to one of the
38664: ** following locking-states, according to the lock currently held on
38665: ** the database file: NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
38666: ** This variable is kept up to date as locks are taken and released by
38667: ** the pagerLockDb() and pagerUnlockDb() wrappers.
38668: **
38669: ** If the VFS xLock() or xUnlock() returns an error other than SQLITE_BUSY
38670: ** (i.e. one of the SQLITE_IOERR subtypes), it is not clear whether or not
38671: ** the operation was successful. In these circumstances pagerLockDb() and
38672: ** pagerUnlockDb() take a conservative approach - eLock is always updated
38673: ** when unlocking the file, and only updated when locking the file if the
38674: ** VFS call is successful. This way, the Pager.eLock variable may be set
38675: ** to a less exclusive (lower) value than the lock that is actually held
38676: ** at the system level, but it is never set to a more exclusive value.
38677: **
38678: ** This is usually safe. If an xUnlock fails or appears to fail, there may
38679: ** be a few redundant xLock() calls or a lock may be held for longer than
38680: ** required, but nothing really goes wrong.
38681: **
38682: ** The exception is when the database file is unlocked as the pager moves
38683: ** from ERROR to OPEN state. At this point there may be a hot-journal file
38684: ** in the file-system that needs to be rolled back (as part of a OPEN->SHARED
38685: ** transition, by the same pager or any other). If the call to xUnlock()
38686: ** fails at this point and the pager is left holding an EXCLUSIVE lock, this
38687: ** can confuse the call to xCheckReservedLock() call made later as part
38688: ** of hot-journal detection.
38689: **
38690: ** xCheckReservedLock() is defined as returning true "if there is a RESERVED
38691: ** lock held by this process or any others". So xCheckReservedLock may
38692: ** return true because the caller itself is holding an EXCLUSIVE lock (but
38693: ** doesn't know it because of a previous error in xUnlock). If this happens
38694: ** a hot-journal may be mistaken for a journal being created by an active
38695: ** transaction in another process, causing SQLite to read from the database
38696: ** without rolling it back.
38697: **
38698: ** To work around this, if a call to xUnlock() fails when unlocking the
38699: ** database in the ERROR state, Pager.eLock is set to UNKNOWN_LOCK. It
38700: ** is only changed back to a real locking state after a successful call
38701: ** to xLock(EXCLUSIVE). Also, the code to do the OPEN->SHARED state transition
38702: ** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK
38703: ** lock. Instead, it assumes a hot-journal exists and obtains an EXCLUSIVE
38704: ** lock on the database file before attempting to roll it back. See function
38705: ** PagerSharedLock() for more detail.
38706: **
38707: ** Pager.eLock may only be set to UNKNOWN_LOCK when the pager is in
38708: ** PAGER_OPEN state.
38709: */
38710: #define UNKNOWN_LOCK (EXCLUSIVE_LOCK+1)
38711:
38712: /*
38713: ** A macro used for invoking the codec if there is one
38714: */
38715: #ifdef SQLITE_HAS_CODEC
38716: # define CODEC1(P,D,N,X,E) \
38717: if( P->xCodec && P->xCodec(P->pCodec,D,N,X)==0 ){ E; }
38718: # define CODEC2(P,D,N,X,E,O) \
38719: if( P->xCodec==0 ){ O=(char*)D; }else \
38720: if( (O=(char*)(P->xCodec(P->pCodec,D,N,X)))==0 ){ E; }
38721: #else
38722: # define CODEC1(P,D,N,X,E) /* NO-OP */
38723: # define CODEC2(P,D,N,X,E,O) O=(char*)D
38724: #endif
38725:
38726: /*
38727: ** The maximum allowed sector size. 64KiB. If the xSectorsize() method
38728: ** returns a value larger than this, then MAX_SECTOR_SIZE is used instead.
38729: ** This could conceivably cause corruption following a power failure on
38730: ** such a system. This is currently an undocumented limit.
38731: */
38732: #define MAX_SECTOR_SIZE 0x10000
38733:
38734: /*
38735: ** An instance of the following structure is allocated for each active
38736: ** savepoint and statement transaction in the system. All such structures
38737: ** are stored in the Pager.aSavepoint[] array, which is allocated and
38738: ** resized using sqlite3Realloc().
38739: **
38740: ** When a savepoint is created, the PagerSavepoint.iHdrOffset field is
38741: ** set to 0. If a journal-header is written into the main journal while
38742: ** the savepoint is active, then iHdrOffset is set to the byte offset
38743: ** immediately following the last journal record written into the main
38744: ** journal before the journal-header. This is required during savepoint
38745: ** rollback (see pagerPlaybackSavepoint()).
38746: */
38747: typedef struct PagerSavepoint PagerSavepoint;
38748: struct PagerSavepoint {
38749: i64 iOffset; /* Starting offset in main journal */
38750: i64 iHdrOffset; /* See above */
38751: Bitvec *pInSavepoint; /* Set of pages in this savepoint */
38752: Pgno nOrig; /* Original number of pages in file */
38753: Pgno iSubRec; /* Index of first record in sub-journal */
38754: #ifndef SQLITE_OMIT_WAL
38755: u32 aWalData[WAL_SAVEPOINT_NDATA]; /* WAL savepoint context */
38756: #endif
38757: };
38758:
38759: /*
38760: ** A open page cache is an instance of struct Pager. A description of
38761: ** some of the more important member variables follows:
38762: **
38763: ** eState
38764: **
38765: ** The current 'state' of the pager object. See the comment and state
38766: ** diagram above for a description of the pager state.
38767: **
38768: ** eLock
38769: **
38770: ** For a real on-disk database, the current lock held on the database file -
38771: ** NO_LOCK, SHARED_LOCK, RESERVED_LOCK or EXCLUSIVE_LOCK.
38772: **
38773: ** For a temporary or in-memory database (neither of which require any
38774: ** locks), this variable is always set to EXCLUSIVE_LOCK. Since such
38775: ** databases always have Pager.exclusiveMode==1, this tricks the pager
38776: ** logic into thinking that it already has all the locks it will ever
38777: ** need (and no reason to release them).
38778: **
38779: ** In some (obscure) circumstances, this variable may also be set to
38780: ** UNKNOWN_LOCK. See the comment above the #define of UNKNOWN_LOCK for
38781: ** details.
38782: **
38783: ** changeCountDone
38784: **
38785: ** This boolean variable is used to make sure that the change-counter
38786: ** (the 4-byte header field at byte offset 24 of the database file) is
38787: ** not updated more often than necessary.
38788: **
38789: ** It is set to true when the change-counter field is updated, which
38790: ** can only happen if an exclusive lock is held on the database file.
38791: ** It is cleared (set to false) whenever an exclusive lock is
38792: ** relinquished on the database file. Each time a transaction is committed,
38793: ** The changeCountDone flag is inspected. If it is true, the work of
38794: ** updating the change-counter is omitted for the current transaction.
38795: **
38796: ** This mechanism means that when running in exclusive mode, a connection
38797: ** need only update the change-counter once, for the first transaction
38798: ** committed.
38799: **
38800: ** setMaster
38801: **
38802: ** When PagerCommitPhaseOne() is called to commit a transaction, it may
38803: ** (or may not) specify a master-journal name to be written into the
38804: ** journal file before it is synced to disk.
38805: **
38806: ** Whether or not a journal file contains a master-journal pointer affects
38807: ** the way in which the journal file is finalized after the transaction is
38808: ** committed or rolled back when running in "journal_mode=PERSIST" mode.
38809: ** If a journal file does not contain a master-journal pointer, it is
38810: ** finalized by overwriting the first journal header with zeroes. If
38811: ** it does contain a master-journal pointer the journal file is finalized
38812: ** by truncating it to zero bytes, just as if the connection were
38813: ** running in "journal_mode=truncate" mode.
38814: **
38815: ** Journal files that contain master journal pointers cannot be finalized
38816: ** simply by overwriting the first journal-header with zeroes, as the
38817: ** master journal pointer could interfere with hot-journal rollback of any
38818: ** subsequently interrupted transaction that reuses the journal file.
38819: **
38820: ** The flag is cleared as soon as the journal file is finalized (either
38821: ** by PagerCommitPhaseTwo or PagerRollback). If an IO error prevents the
38822: ** journal file from being successfully finalized, the setMaster flag
38823: ** is cleared anyway (and the pager will move to ERROR state).
38824: **
38825: ** doNotSpill, doNotSyncSpill
38826: **
38827: ** These two boolean variables control the behaviour of cache-spills
38828: ** (calls made by the pcache module to the pagerStress() routine to
38829: ** write cached data to the file-system in order to free up memory).
38830: **
38831: ** When doNotSpill is non-zero, writing to the database from pagerStress()
38832: ** is disabled altogether. This is done in a very obscure case that
38833: ** comes up during savepoint rollback that requires the pcache module
38834: ** to allocate a new page to prevent the journal file from being written
38835: ** while it is being traversed by code in pager_playback().
38836: **
38837: ** If doNotSyncSpill is non-zero, writing to the database from pagerStress()
38838: ** is permitted, but syncing the journal file is not. This flag is set
38839: ** by sqlite3PagerWrite() when the file-system sector-size is larger than
38840: ** the database page-size in order to prevent a journal sync from happening
38841: ** in between the journalling of two pages on the same sector.
38842: **
38843: ** subjInMemory
38844: **
38845: ** This is a boolean variable. If true, then any required sub-journal
38846: ** is opened as an in-memory journal file. If false, then in-memory
38847: ** sub-journals are only used for in-memory pager files.
38848: **
38849: ** This variable is updated by the upper layer each time a new
38850: ** write-transaction is opened.
38851: **
38852: ** dbSize, dbOrigSize, dbFileSize
38853: **
38854: ** Variable dbSize is set to the number of pages in the database file.
38855: ** It is valid in PAGER_READER and higher states (all states except for
38856: ** OPEN and ERROR).
38857: **
38858: ** dbSize is set based on the size of the database file, which may be
38859: ** larger than the size of the database (the value stored at offset
38860: ** 28 of the database header by the btree). If the size of the file
38861: ** is not an integer multiple of the page-size, the value stored in
38862: ** dbSize is rounded down (i.e. a 5KB file with 2K page-size has dbSize==2).
38863: ** Except, any file that is greater than 0 bytes in size is considered
38864: ** to have at least one page. (i.e. a 1KB file with 2K page-size leads
38865: ** to dbSize==1).
38866: **
38867: ** During a write-transaction, if pages with page-numbers greater than
38868: ** dbSize are modified in the cache, dbSize is updated accordingly.
38869: ** Similarly, if the database is truncated using PagerTruncateImage(),
38870: ** dbSize is updated.
38871: **
38872: ** Variables dbOrigSize and dbFileSize are valid in states
38873: ** PAGER_WRITER_LOCKED and higher. dbOrigSize is a copy of the dbSize
38874: ** variable at the start of the transaction. It is used during rollback,
38875: ** and to determine whether or not pages need to be journalled before
38876: ** being modified.
38877: **
38878: ** Throughout a write-transaction, dbFileSize contains the size of
38879: ** the file on disk in pages. It is set to a copy of dbSize when the
38880: ** write-transaction is first opened, and updated when VFS calls are made
38881: ** to write or truncate the database file on disk.
38882: **
38883: ** The only reason the dbFileSize variable is required is to suppress
38884: ** unnecessary calls to xTruncate() after committing a transaction. If,
38885: ** when a transaction is committed, the dbFileSize variable indicates
38886: ** that the database file is larger than the database image (Pager.dbSize),
38887: ** pager_truncate() is called. The pager_truncate() call uses xFilesize()
38888: ** to measure the database file on disk, and then truncates it if required.
38889: ** dbFileSize is not used when rolling back a transaction. In this case
38890: ** pager_truncate() is called unconditionally (which means there may be
38891: ** a call to xFilesize() that is not strictly required). In either case,
38892: ** pager_truncate() may cause the file to become smaller or larger.
38893: **
38894: ** dbHintSize
38895: **
38896: ** The dbHintSize variable is used to limit the number of calls made to
38897: ** the VFS xFileControl(FCNTL_SIZE_HINT) method.
38898: **
38899: ** dbHintSize is set to a copy of the dbSize variable when a
38900: ** write-transaction is opened (at the same time as dbFileSize and
38901: ** dbOrigSize). If the xFileControl(FCNTL_SIZE_HINT) method is called,
38902: ** dbHintSize is increased to the number of pages that correspond to the
38903: ** size-hint passed to the method call. See pager_write_pagelist() for
38904: ** details.
38905: **
38906: ** errCode
38907: **
38908: ** The Pager.errCode variable is only ever used in PAGER_ERROR state. It
38909: ** is set to zero in all other states. In PAGER_ERROR state, Pager.errCode
38910: ** is always set to SQLITE_FULL, SQLITE_IOERR or one of the SQLITE_IOERR_XXX
38911: ** sub-codes.
38912: */
38913: struct Pager {
38914: sqlite3_vfs *pVfs; /* OS functions to use for IO */
38915: u8 exclusiveMode; /* Boolean. True if locking_mode==EXCLUSIVE */
38916: u8 journalMode; /* One of the PAGER_JOURNALMODE_* values */
38917: u8 useJournal; /* Use a rollback journal on this file */
38918: u8 noReadlock; /* Do not bother to obtain readlocks */
38919: u8 noSync; /* Do not sync the journal if true */
38920: u8 fullSync; /* Do extra syncs of the journal for robustness */
38921: u8 ckptSyncFlags; /* SYNC_NORMAL or SYNC_FULL for checkpoint */
38922: u8 walSyncFlags; /* SYNC_NORMAL or SYNC_FULL for wal writes */
38923: u8 syncFlags; /* SYNC_NORMAL or SYNC_FULL otherwise */
38924: u8 tempFile; /* zFilename is a temporary file */
38925: u8 readOnly; /* True for a read-only database */
38926: u8 memDb; /* True to inhibit all file I/O */
38927:
38928: /**************************************************************************
38929: ** The following block contains those class members that change during
38930: ** routine opertion. Class members not in this block are either fixed
38931: ** when the pager is first created or else only change when there is a
38932: ** significant mode change (such as changing the page_size, locking_mode,
38933: ** or the journal_mode). From another view, these class members describe
38934: ** the "state" of the pager, while other class members describe the
38935: ** "configuration" of the pager.
38936: */
38937: u8 eState; /* Pager state (OPEN, READER, WRITER_LOCKED..) */
38938: u8 eLock; /* Current lock held on database file */
38939: u8 changeCountDone; /* Set after incrementing the change-counter */
38940: u8 setMaster; /* True if a m-j name has been written to jrnl */
38941: u8 doNotSpill; /* Do not spill the cache when non-zero */
38942: u8 doNotSyncSpill; /* Do not do a spill that requires jrnl sync */
38943: u8 subjInMemory; /* True to use in-memory sub-journals */
38944: Pgno dbSize; /* Number of pages in the database */
38945: Pgno dbOrigSize; /* dbSize before the current transaction */
38946: Pgno dbFileSize; /* Number of pages in the database file */
38947: Pgno dbHintSize; /* Value passed to FCNTL_SIZE_HINT call */
38948: int errCode; /* One of several kinds of errors */
38949: int nRec; /* Pages journalled since last j-header written */
38950: u32 cksumInit; /* Quasi-random value added to every checksum */
38951: u32 nSubRec; /* Number of records written to sub-journal */
38952: Bitvec *pInJournal; /* One bit for each page in the database file */
38953: sqlite3_file *fd; /* File descriptor for database */
38954: sqlite3_file *jfd; /* File descriptor for main journal */
38955: sqlite3_file *sjfd; /* File descriptor for sub-journal */
38956: i64 journalOff; /* Current write offset in the journal file */
38957: i64 journalHdr; /* Byte offset to previous journal header */
38958: sqlite3_backup *pBackup; /* Pointer to list of ongoing backup processes */
38959: PagerSavepoint *aSavepoint; /* Array of active savepoints */
38960: int nSavepoint; /* Number of elements in aSavepoint[] */
38961: char dbFileVers[16]; /* Changes whenever database file changes */
38962: /*
38963: ** End of the routinely-changing class members
38964: ***************************************************************************/
38965:
38966: u16 nExtra; /* Add this many bytes to each in-memory page */
38967: i16 nReserve; /* Number of unused bytes at end of each page */
38968: u32 vfsFlags; /* Flags for sqlite3_vfs.xOpen() */
38969: u32 sectorSize; /* Assumed sector size during rollback */
38970: int pageSize; /* Number of bytes in a page */
38971: Pgno mxPgno; /* Maximum allowed size of the database */
38972: i64 journalSizeLimit; /* Size limit for persistent journal files */
38973: char *zFilename; /* Name of the database file */
38974: char *zJournal; /* Name of the journal file */
38975: int (*xBusyHandler)(void*); /* Function to call when busy */
38976: void *pBusyHandlerArg; /* Context argument for xBusyHandler */
38977: int nHit, nMiss; /* Total cache hits and misses */
38978: #ifdef SQLITE_TEST
38979: int nRead, nWrite; /* Database pages read/written */
38980: #endif
38981: void (*xReiniter)(DbPage*); /* Call this routine when reloading pages */
38982: #ifdef SQLITE_HAS_CODEC
38983: void *(*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */
38984: void (*xCodecSizeChng)(void*,int,int); /* Notify of page size changes */
38985: void (*xCodecFree)(void*); /* Destructor for the codec */
38986: void *pCodec; /* First argument to xCodec... methods */
38987: #endif
38988: char *pTmpSpace; /* Pager.pageSize bytes of space for tmp use */
38989: PCache *pPCache; /* Pointer to page cache object */
38990: #ifndef SQLITE_OMIT_WAL
38991: Wal *pWal; /* Write-ahead log used by "journal_mode=wal" */
38992: char *zWal; /* File name for write-ahead log */
38993: #endif
38994: };
38995:
38996: /*
38997: ** The following global variables hold counters used for
38998: ** testing purposes only. These variables do not exist in
38999: ** a non-testing build. These variables are not thread-safe.
39000: */
39001: #ifdef SQLITE_TEST
39002: SQLITE_API int sqlite3_pager_readdb_count = 0; /* Number of full pages read from DB */
39003: SQLITE_API int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */
39004: SQLITE_API int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */
39005: # define PAGER_INCR(v) v++
39006: #else
39007: # define PAGER_INCR(v)
39008: #endif
39009:
39010:
39011:
39012: /*
39013: ** Journal files begin with the following magic string. The data
39014: ** was obtained from /dev/random. It is used only as a sanity check.
39015: **
39016: ** Since version 2.8.0, the journal format contains additional sanity
39017: ** checking information. If the power fails while the journal is being
39018: ** written, semi-random garbage data might appear in the journal
39019: ** file after power is restored. If an attempt is then made
39020: ** to roll the journal back, the database could be corrupted. The additional
39021: ** sanity checking data is an attempt to discover the garbage in the
39022: ** journal and ignore it.
39023: **
39024: ** The sanity checking information for the new journal format consists
39025: ** of a 32-bit checksum on each page of data. The checksum covers both
39026: ** the page number and the pPager->pageSize bytes of data for the page.
39027: ** This cksum is initialized to a 32-bit random value that appears in the
39028: ** journal file right after the header. The random initializer is important,
39029: ** because garbage data that appears at the end of a journal is likely
39030: ** data that was once in other files that have now been deleted. If the
39031: ** garbage data came from an obsolete journal file, the checksums might
39032: ** be correct. But by initializing the checksum to random value which
39033: ** is different for every journal, we minimize that risk.
39034: */
39035: static const unsigned char aJournalMagic[] = {
39036: 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd7,
39037: };
39038:
39039: /*
39040: ** The size of the of each page record in the journal is given by
39041: ** the following macro.
39042: */
39043: #define JOURNAL_PG_SZ(pPager) ((pPager->pageSize) + 8)
39044:
39045: /*
39046: ** The journal header size for this pager. This is usually the same
39047: ** size as a single disk sector. See also setSectorSize().
39048: */
39049: #define JOURNAL_HDR_SZ(pPager) (pPager->sectorSize)
39050:
39051: /*
39052: ** The macro MEMDB is true if we are dealing with an in-memory database.
39053: ** We do this as a macro so that if the SQLITE_OMIT_MEMORYDB macro is set,
39054: ** the value of MEMDB will be a constant and the compiler will optimize
39055: ** out code that would never execute.
39056: */
39057: #ifdef SQLITE_OMIT_MEMORYDB
39058: # define MEMDB 0
39059: #else
39060: # define MEMDB pPager->memDb
39061: #endif
39062:
39063: /*
39064: ** The maximum legal page number is (2^31 - 1).
39065: */
39066: #define PAGER_MAX_PGNO 2147483647
39067:
39068: /*
39069: ** The argument to this macro is a file descriptor (type sqlite3_file*).
39070: ** Return 0 if it is not open, or non-zero (but not 1) if it is.
39071: **
39072: ** This is so that expressions can be written as:
39073: **
39074: ** if( isOpen(pPager->jfd) ){ ...
39075: **
39076: ** instead of
39077: **
39078: ** if( pPager->jfd->pMethods ){ ...
39079: */
39080: #define isOpen(pFd) ((pFd)->pMethods)
39081:
39082: /*
39083: ** Return true if this pager uses a write-ahead log instead of the usual
39084: ** rollback journal. Otherwise false.
39085: */
39086: #ifndef SQLITE_OMIT_WAL
39087: static int pagerUseWal(Pager *pPager){
39088: return (pPager->pWal!=0);
39089: }
39090: #else
39091: # define pagerUseWal(x) 0
39092: # define pagerRollbackWal(x) 0
39093: # define pagerWalFrames(v,w,x,y) 0
39094: # define pagerOpenWalIfPresent(z) SQLITE_OK
39095: # define pagerBeginReadTransaction(z) SQLITE_OK
39096: #endif
39097:
39098: #ifndef NDEBUG
39099: /*
39100: ** Usage:
39101: **
39102: ** assert( assert_pager_state(pPager) );
39103: **
39104: ** This function runs many asserts to try to find inconsistencies in
39105: ** the internal state of the Pager object.
39106: */
39107: static int assert_pager_state(Pager *p){
39108: Pager *pPager = p;
39109:
39110: /* State must be valid. */
39111: assert( p->eState==PAGER_OPEN
39112: || p->eState==PAGER_READER
39113: || p->eState==PAGER_WRITER_LOCKED
39114: || p->eState==PAGER_WRITER_CACHEMOD
39115: || p->eState==PAGER_WRITER_DBMOD
39116: || p->eState==PAGER_WRITER_FINISHED
39117: || p->eState==PAGER_ERROR
39118: );
39119:
39120: /* Regardless of the current state, a temp-file connection always behaves
39121: ** as if it has an exclusive lock on the database file. It never updates
39122: ** the change-counter field, so the changeCountDone flag is always set.
39123: */
39124: assert( p->tempFile==0 || p->eLock==EXCLUSIVE_LOCK );
39125: assert( p->tempFile==0 || pPager->changeCountDone );
39126:
39127: /* If the useJournal flag is clear, the journal-mode must be "OFF".
39128: ** And if the journal-mode is "OFF", the journal file must not be open.
39129: */
39130: assert( p->journalMode==PAGER_JOURNALMODE_OFF || p->useJournal );
39131: assert( p->journalMode!=PAGER_JOURNALMODE_OFF || !isOpen(p->jfd) );
39132:
39133: /* Check that MEMDB implies noSync. And an in-memory journal. Since
39134: ** this means an in-memory pager performs no IO at all, it cannot encounter
39135: ** either SQLITE_IOERR or SQLITE_FULL during rollback or while finalizing
39136: ** a journal file. (although the in-memory journal implementation may
39137: ** return SQLITE_IOERR_NOMEM while the journal file is being written). It
39138: ** is therefore not possible for an in-memory pager to enter the ERROR
39139: ** state.
39140: */
39141: if( MEMDB ){
39142: assert( p->noSync );
39143: assert( p->journalMode==PAGER_JOURNALMODE_OFF
39144: || p->journalMode==PAGER_JOURNALMODE_MEMORY
39145: );
39146: assert( p->eState!=PAGER_ERROR && p->eState!=PAGER_OPEN );
39147: assert( pagerUseWal(p)==0 );
39148: }
39149:
39150: /* If changeCountDone is set, a RESERVED lock or greater must be held
39151: ** on the file.
39152: */
39153: assert( pPager->changeCountDone==0 || pPager->eLock>=RESERVED_LOCK );
39154: assert( p->eLock!=PENDING_LOCK );
39155:
39156: switch( p->eState ){
39157: case PAGER_OPEN:
39158: assert( !MEMDB );
39159: assert( pPager->errCode==SQLITE_OK );
39160: assert( sqlite3PcacheRefCount(pPager->pPCache)==0 || pPager->tempFile );
39161: break;
39162:
39163: case PAGER_READER:
39164: assert( pPager->errCode==SQLITE_OK );
39165: assert( p->eLock!=UNKNOWN_LOCK );
39166: assert( p->eLock>=SHARED_LOCK || p->noReadlock );
39167: break;
39168:
39169: case PAGER_WRITER_LOCKED:
39170: assert( p->eLock!=UNKNOWN_LOCK );
39171: assert( pPager->errCode==SQLITE_OK );
39172: if( !pagerUseWal(pPager) ){
39173: assert( p->eLock>=RESERVED_LOCK );
39174: }
39175: assert( pPager->dbSize==pPager->dbOrigSize );
39176: assert( pPager->dbOrigSize==pPager->dbFileSize );
39177: assert( pPager->dbOrigSize==pPager->dbHintSize );
39178: assert( pPager->setMaster==0 );
39179: break;
39180:
39181: case PAGER_WRITER_CACHEMOD:
39182: assert( p->eLock!=UNKNOWN_LOCK );
39183: assert( pPager->errCode==SQLITE_OK );
39184: if( !pagerUseWal(pPager) ){
39185: /* It is possible that if journal_mode=wal here that neither the
39186: ** journal file nor the WAL file are open. This happens during
39187: ** a rollback transaction that switches from journal_mode=off
39188: ** to journal_mode=wal.
39189: */
39190: assert( p->eLock>=RESERVED_LOCK );
39191: assert( isOpen(p->jfd)
39192: || p->journalMode==PAGER_JOURNALMODE_OFF
39193: || p->journalMode==PAGER_JOURNALMODE_WAL
39194: );
39195: }
39196: assert( pPager->dbOrigSize==pPager->dbFileSize );
39197: assert( pPager->dbOrigSize==pPager->dbHintSize );
39198: break;
39199:
39200: case PAGER_WRITER_DBMOD:
39201: assert( p->eLock==EXCLUSIVE_LOCK );
39202: assert( pPager->errCode==SQLITE_OK );
39203: assert( !pagerUseWal(pPager) );
39204: assert( p->eLock>=EXCLUSIVE_LOCK );
39205: assert( isOpen(p->jfd)
39206: || p->journalMode==PAGER_JOURNALMODE_OFF
39207: || p->journalMode==PAGER_JOURNALMODE_WAL
39208: );
39209: assert( pPager->dbOrigSize<=pPager->dbHintSize );
39210: break;
39211:
39212: case PAGER_WRITER_FINISHED:
39213: assert( p->eLock==EXCLUSIVE_LOCK );
39214: assert( pPager->errCode==SQLITE_OK );
39215: assert( !pagerUseWal(pPager) );
39216: assert( isOpen(p->jfd)
39217: || p->journalMode==PAGER_JOURNALMODE_OFF
39218: || p->journalMode==PAGER_JOURNALMODE_WAL
39219: );
39220: break;
39221:
39222: case PAGER_ERROR:
39223: /* There must be at least one outstanding reference to the pager if
39224: ** in ERROR state. Otherwise the pager should have already dropped
39225: ** back to OPEN state.
39226: */
39227: assert( pPager->errCode!=SQLITE_OK );
39228: assert( sqlite3PcacheRefCount(pPager->pPCache)>0 );
39229: break;
39230: }
39231:
39232: return 1;
39233: }
39234: #endif /* ifndef NDEBUG */
39235:
39236: #ifdef SQLITE_DEBUG
39237: /*
39238: ** Return a pointer to a human readable string in a static buffer
39239: ** containing the state of the Pager object passed as an argument. This
39240: ** is intended to be used within debuggers. For example, as an alternative
39241: ** to "print *pPager" in gdb:
39242: **
39243: ** (gdb) printf "%s", print_pager_state(pPager)
39244: */
39245: static char *print_pager_state(Pager *p){
39246: static char zRet[1024];
39247:
39248: sqlite3_snprintf(1024, zRet,
39249: "Filename: %s\n"
39250: "State: %s errCode=%d\n"
39251: "Lock: %s\n"
39252: "Locking mode: locking_mode=%s\n"
39253: "Journal mode: journal_mode=%s\n"
39254: "Backing store: tempFile=%d memDb=%d useJournal=%d\n"
39255: "Journal: journalOff=%lld journalHdr=%lld\n"
39256: "Size: dbsize=%d dbOrigSize=%d dbFileSize=%d\n"
39257: , p->zFilename
39258: , p->eState==PAGER_OPEN ? "OPEN" :
39259: p->eState==PAGER_READER ? "READER" :
39260: p->eState==PAGER_WRITER_LOCKED ? "WRITER_LOCKED" :
39261: p->eState==PAGER_WRITER_CACHEMOD ? "WRITER_CACHEMOD" :
39262: p->eState==PAGER_WRITER_DBMOD ? "WRITER_DBMOD" :
39263: p->eState==PAGER_WRITER_FINISHED ? "WRITER_FINISHED" :
39264: p->eState==PAGER_ERROR ? "ERROR" : "?error?"
39265: , (int)p->errCode
39266: , p->eLock==NO_LOCK ? "NO_LOCK" :
39267: p->eLock==RESERVED_LOCK ? "RESERVED" :
39268: p->eLock==EXCLUSIVE_LOCK ? "EXCLUSIVE" :
39269: p->eLock==SHARED_LOCK ? "SHARED" :
39270: p->eLock==UNKNOWN_LOCK ? "UNKNOWN" : "?error?"
39271: , p->exclusiveMode ? "exclusive" : "normal"
39272: , p->journalMode==PAGER_JOURNALMODE_MEMORY ? "memory" :
39273: p->journalMode==PAGER_JOURNALMODE_OFF ? "off" :
39274: p->journalMode==PAGER_JOURNALMODE_DELETE ? "delete" :
39275: p->journalMode==PAGER_JOURNALMODE_PERSIST ? "persist" :
39276: p->journalMode==PAGER_JOURNALMODE_TRUNCATE ? "truncate" :
39277: p->journalMode==PAGER_JOURNALMODE_WAL ? "wal" : "?error?"
39278: , (int)p->tempFile, (int)p->memDb, (int)p->useJournal
39279: , p->journalOff, p->journalHdr
39280: , (int)p->dbSize, (int)p->dbOrigSize, (int)p->dbFileSize
39281: );
39282:
39283: return zRet;
39284: }
39285: #endif
39286:
39287: /*
39288: ** Return true if it is necessary to write page *pPg into the sub-journal.
39289: ** A page needs to be written into the sub-journal if there exists one
39290: ** or more open savepoints for which:
39291: **
39292: ** * The page-number is less than or equal to PagerSavepoint.nOrig, and
39293: ** * The bit corresponding to the page-number is not set in
39294: ** PagerSavepoint.pInSavepoint.
39295: */
39296: static int subjRequiresPage(PgHdr *pPg){
39297: Pgno pgno = pPg->pgno;
39298: Pager *pPager = pPg->pPager;
39299: int i;
39300: for(i=0; i<pPager->nSavepoint; i++){
39301: PagerSavepoint *p = &pPager->aSavepoint[i];
39302: if( p->nOrig>=pgno && 0==sqlite3BitvecTest(p->pInSavepoint, pgno) ){
39303: return 1;
39304: }
39305: }
39306: return 0;
39307: }
39308:
39309: /*
39310: ** Return true if the page is already in the journal file.
39311: */
39312: static int pageInJournal(PgHdr *pPg){
39313: return sqlite3BitvecTest(pPg->pPager->pInJournal, pPg->pgno);
39314: }
39315:
39316: /*
39317: ** Read a 32-bit integer from the given file descriptor. Store the integer
39318: ** that is read in *pRes. Return SQLITE_OK if everything worked, or an
39319: ** error code is something goes wrong.
39320: **
39321: ** All values are stored on disk as big-endian.
39322: */
39323: static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
39324: unsigned char ac[4];
39325: int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
39326: if( rc==SQLITE_OK ){
39327: *pRes = sqlite3Get4byte(ac);
39328: }
39329: return rc;
39330: }
39331:
39332: /*
39333: ** Write a 32-bit integer into a string buffer in big-endian byte order.
39334: */
39335: #define put32bits(A,B) sqlite3Put4byte((u8*)A,B)
39336:
39337:
39338: /*
39339: ** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK
39340: ** on success or an error code is something goes wrong.
39341: */
39342: static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
39343: char ac[4];
39344: put32bits(ac, val);
39345: return sqlite3OsWrite(fd, ac, 4, offset);
39346: }
39347:
39348: /*
39349: ** Unlock the database file to level eLock, which must be either NO_LOCK
39350: ** or SHARED_LOCK. Regardless of whether or not the call to xUnlock()
39351: ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
39352: **
39353: ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
39354: ** called, do not modify it. See the comment above the #define of
39355: ** UNKNOWN_LOCK for an explanation of this.
39356: */
39357: static int pagerUnlockDb(Pager *pPager, int eLock){
39358: int rc = SQLITE_OK;
39359:
39360: assert( !pPager->exclusiveMode || pPager->eLock==eLock );
39361: assert( eLock==NO_LOCK || eLock==SHARED_LOCK );
39362: assert( eLock!=NO_LOCK || pagerUseWal(pPager)==0 );
39363: if( isOpen(pPager->fd) ){
39364: assert( pPager->eLock>=eLock );
39365: rc = sqlite3OsUnlock(pPager->fd, eLock);
39366: if( pPager->eLock!=UNKNOWN_LOCK ){
39367: pPager->eLock = (u8)eLock;
39368: }
39369: IOTRACE(("UNLOCK %p %d\n", pPager, eLock))
39370: }
39371: return rc;
39372: }
39373:
39374: /*
39375: ** Lock the database file to level eLock, which must be either SHARED_LOCK,
39376: ** RESERVED_LOCK or EXCLUSIVE_LOCK. If the caller is successful, set the
39377: ** Pager.eLock variable to the new locking state.
39378: **
39379: ** Except, if Pager.eLock is set to UNKNOWN_LOCK when this function is
39380: ** called, do not modify it unless the new locking state is EXCLUSIVE_LOCK.
39381: ** See the comment above the #define of UNKNOWN_LOCK for an explanation
39382: ** of this.
39383: */
39384: static int pagerLockDb(Pager *pPager, int eLock){
39385: int rc = SQLITE_OK;
39386:
39387: assert( eLock==SHARED_LOCK || eLock==RESERVED_LOCK || eLock==EXCLUSIVE_LOCK );
39388: if( pPager->eLock<eLock || pPager->eLock==UNKNOWN_LOCK ){
39389: rc = sqlite3OsLock(pPager->fd, eLock);
39390: if( rc==SQLITE_OK && (pPager->eLock!=UNKNOWN_LOCK||eLock==EXCLUSIVE_LOCK) ){
39391: pPager->eLock = (u8)eLock;
39392: IOTRACE(("LOCK %p %d\n", pPager, eLock))
39393: }
39394: }
39395: return rc;
39396: }
39397:
39398: /*
39399: ** This function determines whether or not the atomic-write optimization
39400: ** can be used with this pager. The optimization can be used if:
39401: **
39402: ** (a) the value returned by OsDeviceCharacteristics() indicates that
39403: ** a database page may be written atomically, and
39404: ** (b) the value returned by OsSectorSize() is less than or equal
39405: ** to the page size.
39406: **
39407: ** The optimization is also always enabled for temporary files. It is
39408: ** an error to call this function if pPager is opened on an in-memory
39409: ** database.
39410: **
39411: ** If the optimization cannot be used, 0 is returned. If it can be used,
39412: ** then the value returned is the size of the journal file when it
39413: ** contains rollback data for exactly one page.
39414: */
39415: #ifdef SQLITE_ENABLE_ATOMIC_WRITE
39416: static int jrnlBufferSize(Pager *pPager){
39417: assert( !MEMDB );
39418: if( !pPager->tempFile ){
39419: int dc; /* Device characteristics */
39420: int nSector; /* Sector size */
39421: int szPage; /* Page size */
39422:
39423: assert( isOpen(pPager->fd) );
39424: dc = sqlite3OsDeviceCharacteristics(pPager->fd);
39425: nSector = pPager->sectorSize;
39426: szPage = pPager->pageSize;
39427:
39428: assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
39429: assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
39430: if( 0==(dc&(SQLITE_IOCAP_ATOMIC|(szPage>>8)) || nSector>szPage) ){
39431: return 0;
39432: }
39433: }
39434:
39435: return JOURNAL_HDR_SZ(pPager) + JOURNAL_PG_SZ(pPager);
39436: }
39437: #endif
39438:
39439: /*
39440: ** If SQLITE_CHECK_PAGES is defined then we do some sanity checking
39441: ** on the cache using a hash function. This is used for testing
39442: ** and debugging only.
39443: */
39444: #ifdef SQLITE_CHECK_PAGES
39445: /*
39446: ** Return a 32-bit hash of the page data for pPage.
39447: */
39448: static u32 pager_datahash(int nByte, unsigned char *pData){
39449: u32 hash = 0;
39450: int i;
39451: for(i=0; i<nByte; i++){
39452: hash = (hash*1039) + pData[i];
39453: }
39454: return hash;
39455: }
39456: static u32 pager_pagehash(PgHdr *pPage){
39457: return pager_datahash(pPage->pPager->pageSize, (unsigned char *)pPage->pData);
39458: }
39459: static void pager_set_pagehash(PgHdr *pPage){
39460: pPage->pageHash = pager_pagehash(pPage);
39461: }
39462:
39463: /*
39464: ** The CHECK_PAGE macro takes a PgHdr* as an argument. If SQLITE_CHECK_PAGES
39465: ** is defined, and NDEBUG is not defined, an assert() statement checks
39466: ** that the page is either dirty or still matches the calculated page-hash.
39467: */
39468: #define CHECK_PAGE(x) checkPage(x)
39469: static void checkPage(PgHdr *pPg){
39470: Pager *pPager = pPg->pPager;
39471: assert( pPager->eState!=PAGER_ERROR );
39472: assert( (pPg->flags&PGHDR_DIRTY) || pPg->pageHash==pager_pagehash(pPg) );
39473: }
39474:
39475: #else
39476: #define pager_datahash(X,Y) 0
39477: #define pager_pagehash(X) 0
39478: #define pager_set_pagehash(X)
39479: #define CHECK_PAGE(x)
39480: #endif /* SQLITE_CHECK_PAGES */
39481:
39482: /*
39483: ** When this is called the journal file for pager pPager must be open.
39484: ** This function attempts to read a master journal file name from the
39485: ** end of the file and, if successful, copies it into memory supplied
39486: ** by the caller. See comments above writeMasterJournal() for the format
39487: ** used to store a master journal file name at the end of a journal file.
39488: **
39489: ** zMaster must point to a buffer of at least nMaster bytes allocated by
39490: ** the caller. This should be sqlite3_vfs.mxPathname+1 (to ensure there is
39491: ** enough space to write the master journal name). If the master journal
39492: ** name in the journal is longer than nMaster bytes (including a
39493: ** nul-terminator), then this is handled as if no master journal name
39494: ** were present in the journal.
39495: **
39496: ** If a master journal file name is present at the end of the journal
39497: ** file, then it is copied into the buffer pointed to by zMaster. A
39498: ** nul-terminator byte is appended to the buffer following the master
39499: ** journal file name.
39500: **
39501: ** If it is determined that no master journal file name is present
39502: ** zMaster[0] is set to 0 and SQLITE_OK returned.
39503: **
39504: ** If an error occurs while reading from the journal file, an SQLite
39505: ** error code is returned.
39506: */
39507: static int readMasterJournal(sqlite3_file *pJrnl, char *zMaster, u32 nMaster){
39508: int rc; /* Return code */
39509: u32 len; /* Length in bytes of master journal name */
39510: i64 szJ; /* Total size in bytes of journal file pJrnl */
39511: u32 cksum; /* MJ checksum value read from journal */
39512: u32 u; /* Unsigned loop counter */
39513: unsigned char aMagic[8]; /* A buffer to hold the magic header */
39514: zMaster[0] = '\0';
39515:
39516: if( SQLITE_OK!=(rc = sqlite3OsFileSize(pJrnl, &szJ))
39517: || szJ<16
39518: || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-16, &len))
39519: || len>=nMaster
39520: || SQLITE_OK!=(rc = read32bits(pJrnl, szJ-12, &cksum))
39521: || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, aMagic, 8, szJ-8))
39522: || memcmp(aMagic, aJournalMagic, 8)
39523: || SQLITE_OK!=(rc = sqlite3OsRead(pJrnl, zMaster, len, szJ-16-len))
39524: ){
39525: return rc;
39526: }
39527:
39528: /* See if the checksum matches the master journal name */
39529: for(u=0; u<len; u++){
39530: cksum -= zMaster[u];
39531: }
39532: if( cksum ){
39533: /* If the checksum doesn't add up, then one or more of the disk sectors
39534: ** containing the master journal filename is corrupted. This means
39535: ** definitely roll back, so just return SQLITE_OK and report a (nul)
39536: ** master-journal filename.
39537: */
39538: len = 0;
39539: }
39540: zMaster[len] = '\0';
39541:
39542: return SQLITE_OK;
39543: }
39544:
39545: /*
39546: ** Return the offset of the sector boundary at or immediately
39547: ** following the value in pPager->journalOff, assuming a sector
39548: ** size of pPager->sectorSize bytes.
39549: **
39550: ** i.e for a sector size of 512:
39551: **
39552: ** Pager.journalOff Return value
39553: ** ---------------------------------------
39554: ** 0 0
39555: ** 512 512
39556: ** 100 512
39557: ** 2000 2048
39558: **
39559: */
39560: static i64 journalHdrOffset(Pager *pPager){
39561: i64 offset = 0;
39562: i64 c = pPager->journalOff;
39563: if( c ){
39564: offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
39565: }
39566: assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
39567: assert( offset>=c );
39568: assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
39569: return offset;
39570: }
39571:
39572: /*
39573: ** The journal file must be open when this function is called.
39574: **
39575: ** This function is a no-op if the journal file has not been written to
39576: ** within the current transaction (i.e. if Pager.journalOff==0).
39577: **
39578: ** If doTruncate is non-zero or the Pager.journalSizeLimit variable is
39579: ** set to 0, then truncate the journal file to zero bytes in size. Otherwise,
39580: ** zero the 28-byte header at the start of the journal file. In either case,
39581: ** if the pager is not in no-sync mode, sync the journal file immediately
39582: ** after writing or truncating it.
39583: **
39584: ** If Pager.journalSizeLimit is set to a positive, non-zero value, and
39585: ** following the truncation or zeroing described above the size of the
39586: ** journal file in bytes is larger than this value, then truncate the
39587: ** journal file to Pager.journalSizeLimit bytes. The journal file does
39588: ** not need to be synced following this operation.
39589: **
39590: ** If an IO error occurs, abandon processing and return the IO error code.
39591: ** Otherwise, return SQLITE_OK.
39592: */
39593: static int zeroJournalHdr(Pager *pPager, int doTruncate){
39594: int rc = SQLITE_OK; /* Return code */
39595: assert( isOpen(pPager->jfd) );
39596: if( pPager->journalOff ){
39597: const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
39598:
39599: IOTRACE(("JZEROHDR %p\n", pPager))
39600: if( doTruncate || iLimit==0 ){
39601: rc = sqlite3OsTruncate(pPager->jfd, 0);
39602: }else{
39603: static const char zeroHdr[28] = {0};
39604: rc = sqlite3OsWrite(pPager->jfd, zeroHdr, sizeof(zeroHdr), 0);
39605: }
39606: if( rc==SQLITE_OK && !pPager->noSync ){
39607: rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_DATAONLY|pPager->syncFlags);
39608: }
39609:
39610: /* At this point the transaction is committed but the write lock
39611: ** is still held on the file. If there is a size limit configured for
39612: ** the persistent journal and the journal file currently consumes more
39613: ** space than that limit allows for, truncate it now. There is no need
39614: ** to sync the file following this operation.
39615: */
39616: if( rc==SQLITE_OK && iLimit>0 ){
39617: i64 sz;
39618: rc = sqlite3OsFileSize(pPager->jfd, &sz);
39619: if( rc==SQLITE_OK && sz>iLimit ){
39620: rc = sqlite3OsTruncate(pPager->jfd, iLimit);
39621: }
39622: }
39623: }
39624: return rc;
39625: }
39626:
39627: /*
39628: ** The journal file must be open when this routine is called. A journal
39629: ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
39630: ** current location.
39631: **
39632: ** The format for the journal header is as follows:
39633: ** - 8 bytes: Magic identifying journal format.
39634: ** - 4 bytes: Number of records in journal, or -1 no-sync mode is on.
39635: ** - 4 bytes: Random number used for page hash.
39636: ** - 4 bytes: Initial database page count.
39637: ** - 4 bytes: Sector size used by the process that wrote this journal.
39638: ** - 4 bytes: Database page size.
39639: **
39640: ** Followed by (JOURNAL_HDR_SZ - 28) bytes of unused space.
39641: */
39642: static int writeJournalHdr(Pager *pPager){
39643: int rc = SQLITE_OK; /* Return code */
39644: char *zHeader = pPager->pTmpSpace; /* Temporary space used to build header */
39645: u32 nHeader = (u32)pPager->pageSize;/* Size of buffer pointed to by zHeader */
39646: u32 nWrite; /* Bytes of header sector written */
39647: int ii; /* Loop counter */
39648:
39649: assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
39650:
39651: if( nHeader>JOURNAL_HDR_SZ(pPager) ){
39652: nHeader = JOURNAL_HDR_SZ(pPager);
39653: }
39654:
39655: /* If there are active savepoints and any of them were created
39656: ** since the most recent journal header was written, update the
39657: ** PagerSavepoint.iHdrOffset fields now.
39658: */
39659: for(ii=0; ii<pPager->nSavepoint; ii++){
39660: if( pPager->aSavepoint[ii].iHdrOffset==0 ){
39661: pPager->aSavepoint[ii].iHdrOffset = pPager->journalOff;
39662: }
39663: }
39664:
39665: pPager->journalHdr = pPager->journalOff = journalHdrOffset(pPager);
39666:
39667: /*
39668: ** Write the nRec Field - the number of page records that follow this
39669: ** journal header. Normally, zero is written to this value at this time.
39670: ** After the records are added to the journal (and the journal synced,
39671: ** if in full-sync mode), the zero is overwritten with the true number
39672: ** of records (see syncJournal()).
39673: **
39674: ** A faster alternative is to write 0xFFFFFFFF to the nRec field. When
39675: ** reading the journal this value tells SQLite to assume that the
39676: ** rest of the journal file contains valid page records. This assumption
39677: ** is dangerous, as if a failure occurred whilst writing to the journal
39678: ** file it may contain some garbage data. There are two scenarios
39679: ** where this risk can be ignored:
39680: **
39681: ** * When the pager is in no-sync mode. Corruption can follow a
39682: ** power failure in this case anyway.
39683: **
39684: ** * When the SQLITE_IOCAP_SAFE_APPEND flag is set. This guarantees
39685: ** that garbage data is never appended to the journal file.
39686: */
39687: assert( isOpen(pPager->fd) || pPager->noSync );
39688: if( pPager->noSync || (pPager->journalMode==PAGER_JOURNALMODE_MEMORY)
39689: || (sqlite3OsDeviceCharacteristics(pPager->fd)&SQLITE_IOCAP_SAFE_APPEND)
39690: ){
39691: memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
39692: put32bits(&zHeader[sizeof(aJournalMagic)], 0xffffffff);
39693: }else{
39694: memset(zHeader, 0, sizeof(aJournalMagic)+4);
39695: }
39696:
39697: /* The random check-hash initialiser */
39698: sqlite3_randomness(sizeof(pPager->cksumInit), &pPager->cksumInit);
39699: put32bits(&zHeader[sizeof(aJournalMagic)+4], pPager->cksumInit);
39700: /* The initial database size */
39701: put32bits(&zHeader[sizeof(aJournalMagic)+8], pPager->dbOrigSize);
39702: /* The assumed sector size for this process */
39703: put32bits(&zHeader[sizeof(aJournalMagic)+12], pPager->sectorSize);
39704:
39705: /* The page size */
39706: put32bits(&zHeader[sizeof(aJournalMagic)+16], pPager->pageSize);
39707:
39708: /* Initializing the tail of the buffer is not necessary. Everything
39709: ** works find if the following memset() is omitted. But initializing
39710: ** the memory prevents valgrind from complaining, so we are willing to
39711: ** take the performance hit.
39712: */
39713: memset(&zHeader[sizeof(aJournalMagic)+20], 0,
39714: nHeader-(sizeof(aJournalMagic)+20));
39715:
39716: /* In theory, it is only necessary to write the 28 bytes that the
39717: ** journal header consumes to the journal file here. Then increment the
39718: ** Pager.journalOff variable by JOURNAL_HDR_SZ so that the next
39719: ** record is written to the following sector (leaving a gap in the file
39720: ** that will be implicitly filled in by the OS).
39721: **
39722: ** However it has been discovered that on some systems this pattern can
39723: ** be significantly slower than contiguously writing data to the file,
39724: ** even if that means explicitly writing data to the block of
39725: ** (JOURNAL_HDR_SZ - 28) bytes that will not be used. So that is what
39726: ** is done.
39727: **
39728: ** The loop is required here in case the sector-size is larger than the
39729: ** database page size. Since the zHeader buffer is only Pager.pageSize
39730: ** bytes in size, more than one call to sqlite3OsWrite() may be required
39731: ** to populate the entire journal header sector.
39732: */
39733: for(nWrite=0; rc==SQLITE_OK&&nWrite<JOURNAL_HDR_SZ(pPager); nWrite+=nHeader){
39734: IOTRACE(("JHDR %p %lld %d\n", pPager, pPager->journalHdr, nHeader))
39735: rc = sqlite3OsWrite(pPager->jfd, zHeader, nHeader, pPager->journalOff);
39736: assert( pPager->journalHdr <= pPager->journalOff );
39737: pPager->journalOff += nHeader;
39738: }
39739:
39740: return rc;
39741: }
39742:
39743: /*
39744: ** The journal file must be open when this is called. A journal header file
39745: ** (JOURNAL_HDR_SZ bytes) is read from the current location in the journal
39746: ** file. The current location in the journal file is given by
39747: ** pPager->journalOff. See comments above function writeJournalHdr() for
39748: ** a description of the journal header format.
39749: **
39750: ** If the header is read successfully, *pNRec is set to the number of
39751: ** page records following this header and *pDbSize is set to the size of the
39752: ** database before the transaction began, in pages. Also, pPager->cksumInit
39753: ** is set to the value read from the journal header. SQLITE_OK is returned
39754: ** in this case.
39755: **
39756: ** If the journal header file appears to be corrupted, SQLITE_DONE is
39757: ** returned and *pNRec and *PDbSize are undefined. If JOURNAL_HDR_SZ bytes
39758: ** cannot be read from the journal file an error code is returned.
39759: */
39760: static int readJournalHdr(
39761: Pager *pPager, /* Pager object */
39762: int isHot,
39763: i64 journalSize, /* Size of the open journal file in bytes */
39764: u32 *pNRec, /* OUT: Value read from the nRec field */
39765: u32 *pDbSize /* OUT: Value of original database size field */
39766: ){
39767: int rc; /* Return code */
39768: unsigned char aMagic[8]; /* A buffer to hold the magic header */
39769: i64 iHdrOff; /* Offset of journal header being read */
39770:
39771: assert( isOpen(pPager->jfd) ); /* Journal file must be open. */
39772:
39773: /* Advance Pager.journalOff to the start of the next sector. If the
39774: ** journal file is too small for there to be a header stored at this
39775: ** point, return SQLITE_DONE.
39776: */
39777: pPager->journalOff = journalHdrOffset(pPager);
39778: if( pPager->journalOff+JOURNAL_HDR_SZ(pPager) > journalSize ){
39779: return SQLITE_DONE;
39780: }
39781: iHdrOff = pPager->journalOff;
39782:
39783: /* Read in the first 8 bytes of the journal header. If they do not match
39784: ** the magic string found at the start of each journal header, return
39785: ** SQLITE_DONE. If an IO error occurs, return an error code. Otherwise,
39786: ** proceed.
39787: */
39788: if( isHot || iHdrOff!=pPager->journalHdr ){
39789: rc = sqlite3OsRead(pPager->jfd, aMagic, sizeof(aMagic), iHdrOff);
39790: if( rc ){
39791: return rc;
39792: }
39793: if( memcmp(aMagic, aJournalMagic, sizeof(aMagic))!=0 ){
39794: return SQLITE_DONE;
39795: }
39796: }
39797:
39798: /* Read the first three 32-bit fields of the journal header: The nRec
39799: ** field, the checksum-initializer and the database size at the start
39800: ** of the transaction. Return an error code if anything goes wrong.
39801: */
39802: if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+8, pNRec))
39803: || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+12, &pPager->cksumInit))
39804: || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+16, pDbSize))
39805: ){
39806: return rc;
39807: }
39808:
39809: if( pPager->journalOff==0 ){
39810: u32 iPageSize; /* Page-size field of journal header */
39811: u32 iSectorSize; /* Sector-size field of journal header */
39812:
39813: /* Read the page-size and sector-size journal header fields. */
39814: if( SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+20, &iSectorSize))
39815: || SQLITE_OK!=(rc = read32bits(pPager->jfd, iHdrOff+24, &iPageSize))
39816: ){
39817: return rc;
39818: }
39819:
39820: /* Versions of SQLite prior to 3.5.8 set the page-size field of the
39821: ** journal header to zero. In this case, assume that the Pager.pageSize
39822: ** variable is already set to the correct page size.
39823: */
39824: if( iPageSize==0 ){
39825: iPageSize = pPager->pageSize;
39826: }
39827:
39828: /* Check that the values read from the page-size and sector-size fields
39829: ** are within range. To be 'in range', both values need to be a power
39830: ** of two greater than or equal to 512 or 32, and not greater than their
39831: ** respective compile time maximum limits.
39832: */
39833: if( iPageSize<512 || iSectorSize<32
39834: || iPageSize>SQLITE_MAX_PAGE_SIZE || iSectorSize>MAX_SECTOR_SIZE
39835: || ((iPageSize-1)&iPageSize)!=0 || ((iSectorSize-1)&iSectorSize)!=0
39836: ){
39837: /* If the either the page-size or sector-size in the journal-header is
39838: ** invalid, then the process that wrote the journal-header must have
39839: ** crashed before the header was synced. In this case stop reading
39840: ** the journal file here.
39841: */
39842: return SQLITE_DONE;
39843: }
39844:
39845: /* Update the page-size to match the value read from the journal.
39846: ** Use a testcase() macro to make sure that malloc failure within
39847: ** PagerSetPagesize() is tested.
39848: */
39849: rc = sqlite3PagerSetPagesize(pPager, &iPageSize, -1);
39850: testcase( rc!=SQLITE_OK );
39851:
39852: /* Update the assumed sector-size to match the value used by
39853: ** the process that created this journal. If this journal was
39854: ** created by a process other than this one, then this routine
39855: ** is being called from within pager_playback(). The local value
39856: ** of Pager.sectorSize is restored at the end of that routine.
39857: */
39858: pPager->sectorSize = iSectorSize;
39859: }
39860:
39861: pPager->journalOff += JOURNAL_HDR_SZ(pPager);
39862: return rc;
39863: }
39864:
39865:
39866: /*
39867: ** Write the supplied master journal name into the journal file for pager
39868: ** pPager at the current location. The master journal name must be the last
39869: ** thing written to a journal file. If the pager is in full-sync mode, the
39870: ** journal file descriptor is advanced to the next sector boundary before
39871: ** anything is written. The format is:
39872: **
39873: ** + 4 bytes: PAGER_MJ_PGNO.
39874: ** + N bytes: Master journal filename in utf-8.
39875: ** + 4 bytes: N (length of master journal name in bytes, no nul-terminator).
39876: ** + 4 bytes: Master journal name checksum.
39877: ** + 8 bytes: aJournalMagic[].
39878: **
39879: ** The master journal page checksum is the sum of the bytes in the master
39880: ** journal name, where each byte is interpreted as a signed 8-bit integer.
39881: **
39882: ** If zMaster is a NULL pointer (occurs for a single database transaction),
39883: ** this call is a no-op.
39884: */
39885: static int writeMasterJournal(Pager *pPager, const char *zMaster){
39886: int rc; /* Return code */
39887: int nMaster; /* Length of string zMaster */
39888: i64 iHdrOff; /* Offset of header in journal file */
39889: i64 jrnlSize; /* Size of journal file on disk */
39890: u32 cksum = 0; /* Checksum of string zMaster */
39891:
39892: assert( pPager->setMaster==0 );
39893: assert( !pagerUseWal(pPager) );
39894:
39895: if( !zMaster
39896: || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
39897: || pPager->journalMode==PAGER_JOURNALMODE_OFF
39898: ){
39899: return SQLITE_OK;
39900: }
39901: pPager->setMaster = 1;
39902: assert( isOpen(pPager->jfd) );
39903: assert( pPager->journalHdr <= pPager->journalOff );
39904:
39905: /* Calculate the length in bytes and the checksum of zMaster */
39906: for(nMaster=0; zMaster[nMaster]; nMaster++){
39907: cksum += zMaster[nMaster];
39908: }
39909:
39910: /* If in full-sync mode, advance to the next disk sector before writing
39911: ** the master journal name. This is in case the previous page written to
39912: ** the journal has already been synced.
39913: */
39914: if( pPager->fullSync ){
39915: pPager->journalOff = journalHdrOffset(pPager);
39916: }
39917: iHdrOff = pPager->journalOff;
39918:
39919: /* Write the master journal data to the end of the journal file. If
39920: ** an error occurs, return the error code to the caller.
39921: */
39922: if( (0 != (rc = write32bits(pPager->jfd, iHdrOff, PAGER_MJ_PGNO(pPager))))
39923: || (0 != (rc = sqlite3OsWrite(pPager->jfd, zMaster, nMaster, iHdrOff+4)))
39924: || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster, nMaster)))
39925: || (0 != (rc = write32bits(pPager->jfd, iHdrOff+4+nMaster+4, cksum)))
39926: || (0 != (rc = sqlite3OsWrite(pPager->jfd, aJournalMagic, 8, iHdrOff+4+nMaster+8)))
39927: ){
39928: return rc;
39929: }
39930: pPager->journalOff += (nMaster+20);
39931:
39932: /* If the pager is in peristent-journal mode, then the physical
39933: ** journal-file may extend past the end of the master-journal name
39934: ** and 8 bytes of magic data just written to the file. This is
39935: ** dangerous because the code to rollback a hot-journal file
39936: ** will not be able to find the master-journal name to determine
39937: ** whether or not the journal is hot.
39938: **
39939: ** Easiest thing to do in this scenario is to truncate the journal
39940: ** file to the required size.
39941: */
39942: if( SQLITE_OK==(rc = sqlite3OsFileSize(pPager->jfd, &jrnlSize))
39943: && jrnlSize>pPager->journalOff
39944: ){
39945: rc = sqlite3OsTruncate(pPager->jfd, pPager->journalOff);
39946: }
39947: return rc;
39948: }
39949:
39950: /*
39951: ** Find a page in the hash table given its page number. Return
39952: ** a pointer to the page or NULL if the requested page is not
39953: ** already in memory.
39954: */
39955: static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){
39956: PgHdr *p; /* Return value */
39957:
39958: /* It is not possible for a call to PcacheFetch() with createFlag==0 to
39959: ** fail, since no attempt to allocate dynamic memory will be made.
39960: */
39961: (void)sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &p);
39962: return p;
39963: }
39964:
39965: /*
39966: ** Discard the entire contents of the in-memory page-cache.
39967: */
39968: static void pager_reset(Pager *pPager){
39969: sqlite3BackupRestart(pPager->pBackup);
39970: sqlite3PcacheClear(pPager->pPCache);
39971: }
39972:
39973: /*
39974: ** Free all structures in the Pager.aSavepoint[] array and set both
39975: ** Pager.aSavepoint and Pager.nSavepoint to zero. Close the sub-journal
39976: ** if it is open and the pager is not in exclusive mode.
39977: */
39978: static void releaseAllSavepoints(Pager *pPager){
39979: int ii; /* Iterator for looping through Pager.aSavepoint */
39980: for(ii=0; ii<pPager->nSavepoint; ii++){
39981: sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
39982: }
39983: if( !pPager->exclusiveMode || sqlite3IsMemJournal(pPager->sjfd) ){
39984: sqlite3OsClose(pPager->sjfd);
39985: }
39986: sqlite3_free(pPager->aSavepoint);
39987: pPager->aSavepoint = 0;
39988: pPager->nSavepoint = 0;
39989: pPager->nSubRec = 0;
39990: }
39991:
39992: /*
39993: ** Set the bit number pgno in the PagerSavepoint.pInSavepoint
39994: ** bitvecs of all open savepoints. Return SQLITE_OK if successful
39995: ** or SQLITE_NOMEM if a malloc failure occurs.
39996: */
39997: static int addToSavepointBitvecs(Pager *pPager, Pgno pgno){
39998: int ii; /* Loop counter */
39999: int rc = SQLITE_OK; /* Result code */
40000:
40001: for(ii=0; ii<pPager->nSavepoint; ii++){
40002: PagerSavepoint *p = &pPager->aSavepoint[ii];
40003: if( pgno<=p->nOrig ){
40004: rc |= sqlite3BitvecSet(p->pInSavepoint, pgno);
40005: testcase( rc==SQLITE_NOMEM );
40006: assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
40007: }
40008: }
40009: return rc;
40010: }
40011:
40012: /*
40013: ** This function is a no-op if the pager is in exclusive mode and not
40014: ** in the ERROR state. Otherwise, it switches the pager to PAGER_OPEN
40015: ** state.
40016: **
40017: ** If the pager is not in exclusive-access mode, the database file is
40018: ** completely unlocked. If the file is unlocked and the file-system does
40019: ** not exhibit the UNDELETABLE_WHEN_OPEN property, the journal file is
40020: ** closed (if it is open).
40021: **
40022: ** If the pager is in ERROR state when this function is called, the
40023: ** contents of the pager cache are discarded before switching back to
40024: ** the OPEN state. Regardless of whether the pager is in exclusive-mode
40025: ** or not, any journal file left in the file-system will be treated
40026: ** as a hot-journal and rolled back the next time a read-transaction
40027: ** is opened (by this or by any other connection).
40028: */
40029: static void pager_unlock(Pager *pPager){
40030:
40031: assert( pPager->eState==PAGER_READER
40032: || pPager->eState==PAGER_OPEN
40033: || pPager->eState==PAGER_ERROR
40034: );
40035:
40036: sqlite3BitvecDestroy(pPager->pInJournal);
40037: pPager->pInJournal = 0;
40038: releaseAllSavepoints(pPager);
40039:
40040: if( pagerUseWal(pPager) ){
40041: assert( !isOpen(pPager->jfd) );
40042: sqlite3WalEndReadTransaction(pPager->pWal);
40043: pPager->eState = PAGER_OPEN;
40044: }else if( !pPager->exclusiveMode ){
40045: int rc; /* Error code returned by pagerUnlockDb() */
40046: int iDc = isOpen(pPager->fd)?sqlite3OsDeviceCharacteristics(pPager->fd):0;
40047:
40048: /* If the operating system support deletion of open files, then
40049: ** close the journal file when dropping the database lock. Otherwise
40050: ** another connection with journal_mode=delete might delete the file
40051: ** out from under us.
40052: */
40053: assert( (PAGER_JOURNALMODE_MEMORY & 5)!=1 );
40054: assert( (PAGER_JOURNALMODE_OFF & 5)!=1 );
40055: assert( (PAGER_JOURNALMODE_WAL & 5)!=1 );
40056: assert( (PAGER_JOURNALMODE_DELETE & 5)!=1 );
40057: assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
40058: assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
40059: if( 0==(iDc & SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN)
40060: || 1!=(pPager->journalMode & 5)
40061: ){
40062: sqlite3OsClose(pPager->jfd);
40063: }
40064:
40065: /* If the pager is in the ERROR state and the call to unlock the database
40066: ** file fails, set the current lock to UNKNOWN_LOCK. See the comment
40067: ** above the #define for UNKNOWN_LOCK for an explanation of why this
40068: ** is necessary.
40069: */
40070: rc = pagerUnlockDb(pPager, NO_LOCK);
40071: if( rc!=SQLITE_OK && pPager->eState==PAGER_ERROR ){
40072: pPager->eLock = UNKNOWN_LOCK;
40073: }
40074:
40075: /* The pager state may be changed from PAGER_ERROR to PAGER_OPEN here
40076: ** without clearing the error code. This is intentional - the error
40077: ** code is cleared and the cache reset in the block below.
40078: */
40079: assert( pPager->errCode || pPager->eState!=PAGER_ERROR );
40080: pPager->changeCountDone = 0;
40081: pPager->eState = PAGER_OPEN;
40082: }
40083:
40084: /* If Pager.errCode is set, the contents of the pager cache cannot be
40085: ** trusted. Now that there are no outstanding references to the pager,
40086: ** it can safely move back to PAGER_OPEN state. This happens in both
40087: ** normal and exclusive-locking mode.
40088: */
40089: if( pPager->errCode ){
40090: assert( !MEMDB );
40091: pager_reset(pPager);
40092: pPager->changeCountDone = pPager->tempFile;
40093: pPager->eState = PAGER_OPEN;
40094: pPager->errCode = SQLITE_OK;
40095: }
40096:
40097: pPager->journalOff = 0;
40098: pPager->journalHdr = 0;
40099: pPager->setMaster = 0;
40100: }
40101:
40102: /*
40103: ** This function is called whenever an IOERR or FULL error that requires
40104: ** the pager to transition into the ERROR state may ahve occurred.
40105: ** The first argument is a pointer to the pager structure, the second
40106: ** the error-code about to be returned by a pager API function. The
40107: ** value returned is a copy of the second argument to this function.
40108: **
40109: ** If the second argument is SQLITE_FULL, SQLITE_IOERR or one of the
40110: ** IOERR sub-codes, the pager enters the ERROR state and the error code
40111: ** is stored in Pager.errCode. While the pager remains in the ERROR state,
40112: ** all major API calls on the Pager will immediately return Pager.errCode.
40113: **
40114: ** The ERROR state indicates that the contents of the pager-cache
40115: ** cannot be trusted. This state can be cleared by completely discarding
40116: ** the contents of the pager-cache. If a transaction was active when
40117: ** the persistent error occurred, then the rollback journal may need
40118: ** to be replayed to restore the contents of the database file (as if
40119: ** it were a hot-journal).
40120: */
40121: static int pager_error(Pager *pPager, int rc){
40122: int rc2 = rc & 0xff;
40123: assert( rc==SQLITE_OK || !MEMDB );
40124: assert(
40125: pPager->errCode==SQLITE_FULL ||
40126: pPager->errCode==SQLITE_OK ||
40127: (pPager->errCode & 0xff)==SQLITE_IOERR
40128: );
40129: if( rc2==SQLITE_FULL || rc2==SQLITE_IOERR ){
40130: pPager->errCode = rc;
40131: pPager->eState = PAGER_ERROR;
40132: }
40133: return rc;
40134: }
40135:
40136: /*
40137: ** This routine ends a transaction. A transaction is usually ended by
40138: ** either a COMMIT or a ROLLBACK operation. This routine may be called
40139: ** after rollback of a hot-journal, or if an error occurs while opening
40140: ** the journal file or writing the very first journal-header of a
40141: ** database transaction.
40142: **
40143: ** This routine is never called in PAGER_ERROR state. If it is called
40144: ** in PAGER_NONE or PAGER_SHARED state and the lock held is less
40145: ** exclusive than a RESERVED lock, it is a no-op.
40146: **
40147: ** Otherwise, any active savepoints are released.
40148: **
40149: ** If the journal file is open, then it is "finalized". Once a journal
40150: ** file has been finalized it is not possible to use it to roll back a
40151: ** transaction. Nor will it be considered to be a hot-journal by this
40152: ** or any other database connection. Exactly how a journal is finalized
40153: ** depends on whether or not the pager is running in exclusive mode and
40154: ** the current journal-mode (Pager.journalMode value), as follows:
40155: **
40156: ** journalMode==MEMORY
40157: ** Journal file descriptor is simply closed. This destroys an
40158: ** in-memory journal.
40159: **
40160: ** journalMode==TRUNCATE
40161: ** Journal file is truncated to zero bytes in size.
40162: **
40163: ** journalMode==PERSIST
40164: ** The first 28 bytes of the journal file are zeroed. This invalidates
40165: ** the first journal header in the file, and hence the entire journal
40166: ** file. An invalid journal file cannot be rolled back.
40167: **
40168: ** journalMode==DELETE
40169: ** The journal file is closed and deleted using sqlite3OsDelete().
40170: **
40171: ** If the pager is running in exclusive mode, this method of finalizing
40172: ** the journal file is never used. Instead, if the journalMode is
40173: ** DELETE and the pager is in exclusive mode, the method described under
40174: ** journalMode==PERSIST is used instead.
40175: **
40176: ** After the journal is finalized, the pager moves to PAGER_READER state.
40177: ** If running in non-exclusive rollback mode, the lock on the file is
40178: ** downgraded to a SHARED_LOCK.
40179: **
40180: ** SQLITE_OK is returned if no error occurs. If an error occurs during
40181: ** any of the IO operations to finalize the journal file or unlock the
40182: ** database then the IO error code is returned to the user. If the
40183: ** operation to finalize the journal file fails, then the code still
40184: ** tries to unlock the database file if not in exclusive mode. If the
40185: ** unlock operation fails as well, then the first error code related
40186: ** to the first error encountered (the journal finalization one) is
40187: ** returned.
40188: */
40189: static int pager_end_transaction(Pager *pPager, int hasMaster){
40190: int rc = SQLITE_OK; /* Error code from journal finalization operation */
40191: int rc2 = SQLITE_OK; /* Error code from db file unlock operation */
40192:
40193: /* Do nothing if the pager does not have an open write transaction
40194: ** or at least a RESERVED lock. This function may be called when there
40195: ** is no write-transaction active but a RESERVED or greater lock is
40196: ** held under two circumstances:
40197: **
40198: ** 1. After a successful hot-journal rollback, it is called with
40199: ** eState==PAGER_NONE and eLock==EXCLUSIVE_LOCK.
40200: **
40201: ** 2. If a connection with locking_mode=exclusive holding an EXCLUSIVE
40202: ** lock switches back to locking_mode=normal and then executes a
40203: ** read-transaction, this function is called with eState==PAGER_READER
40204: ** and eLock==EXCLUSIVE_LOCK when the read-transaction is closed.
40205: */
40206: assert( assert_pager_state(pPager) );
40207: assert( pPager->eState!=PAGER_ERROR );
40208: if( pPager->eState<PAGER_WRITER_LOCKED && pPager->eLock<RESERVED_LOCK ){
40209: return SQLITE_OK;
40210: }
40211:
40212: releaseAllSavepoints(pPager);
40213: assert( isOpen(pPager->jfd) || pPager->pInJournal==0 );
40214: if( isOpen(pPager->jfd) ){
40215: assert( !pagerUseWal(pPager) );
40216:
40217: /* Finalize the journal file. */
40218: if( sqlite3IsMemJournal(pPager->jfd) ){
40219: assert( pPager->journalMode==PAGER_JOURNALMODE_MEMORY );
40220: sqlite3OsClose(pPager->jfd);
40221: }else if( pPager->journalMode==PAGER_JOURNALMODE_TRUNCATE ){
40222: if( pPager->journalOff==0 ){
40223: rc = SQLITE_OK;
40224: }else{
40225: rc = sqlite3OsTruncate(pPager->jfd, 0);
40226: }
40227: pPager->journalOff = 0;
40228: }else if( pPager->journalMode==PAGER_JOURNALMODE_PERSIST
40229: || (pPager->exclusiveMode && pPager->journalMode!=PAGER_JOURNALMODE_WAL)
40230: ){
40231: rc = zeroJournalHdr(pPager, hasMaster);
40232: pPager->journalOff = 0;
40233: }else{
40234: /* This branch may be executed with Pager.journalMode==MEMORY if
40235: ** a hot-journal was just rolled back. In this case the journal
40236: ** file should be closed and deleted. If this connection writes to
40237: ** the database file, it will do so using an in-memory journal.
40238: */
40239: assert( pPager->journalMode==PAGER_JOURNALMODE_DELETE
40240: || pPager->journalMode==PAGER_JOURNALMODE_MEMORY
40241: || pPager->journalMode==PAGER_JOURNALMODE_WAL
40242: );
40243: sqlite3OsClose(pPager->jfd);
40244: if( !pPager->tempFile ){
40245: rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
40246: }
40247: }
40248: }
40249:
40250: #ifdef SQLITE_CHECK_PAGES
40251: sqlite3PcacheIterateDirty(pPager->pPCache, pager_set_pagehash);
40252: if( pPager->dbSize==0 && sqlite3PcacheRefCount(pPager->pPCache)>0 ){
40253: PgHdr *p = pager_lookup(pPager, 1);
40254: if( p ){
40255: p->pageHash = 0;
40256: sqlite3PagerUnref(p);
40257: }
40258: }
40259: #endif
40260:
40261: sqlite3BitvecDestroy(pPager->pInJournal);
40262: pPager->pInJournal = 0;
40263: pPager->nRec = 0;
40264: sqlite3PcacheCleanAll(pPager->pPCache);
40265: sqlite3PcacheTruncate(pPager->pPCache, pPager->dbSize);
40266:
40267: if( pagerUseWal(pPager) ){
40268: /* Drop the WAL write-lock, if any. Also, if the connection was in
40269: ** locking_mode=exclusive mode but is no longer, drop the EXCLUSIVE
40270: ** lock held on the database file.
40271: */
40272: rc2 = sqlite3WalEndWriteTransaction(pPager->pWal);
40273: assert( rc2==SQLITE_OK );
40274: }
40275: if( !pPager->exclusiveMode
40276: && (!pagerUseWal(pPager) || sqlite3WalExclusiveMode(pPager->pWal, 0))
40277: ){
40278: rc2 = pagerUnlockDb(pPager, SHARED_LOCK);
40279: pPager->changeCountDone = 0;
40280: }
40281: pPager->eState = PAGER_READER;
40282: pPager->setMaster = 0;
40283:
40284: return (rc==SQLITE_OK?rc2:rc);
40285: }
40286:
40287: /*
40288: ** Execute a rollback if a transaction is active and unlock the
40289: ** database file.
40290: **
40291: ** If the pager has already entered the ERROR state, do not attempt
40292: ** the rollback at this time. Instead, pager_unlock() is called. The
40293: ** call to pager_unlock() will discard all in-memory pages, unlock
40294: ** the database file and move the pager back to OPEN state. If this
40295: ** means that there is a hot-journal left in the file-system, the next
40296: ** connection to obtain a shared lock on the pager (which may be this one)
40297: ** will roll it back.
40298: **
40299: ** If the pager has not already entered the ERROR state, but an IO or
40300: ** malloc error occurs during a rollback, then this will itself cause
40301: ** the pager to enter the ERROR state. Which will be cleared by the
40302: ** call to pager_unlock(), as described above.
40303: */
40304: static void pagerUnlockAndRollback(Pager *pPager){
40305: if( pPager->eState!=PAGER_ERROR && pPager->eState!=PAGER_OPEN ){
40306: assert( assert_pager_state(pPager) );
40307: if( pPager->eState>=PAGER_WRITER_LOCKED ){
40308: sqlite3BeginBenignMalloc();
40309: sqlite3PagerRollback(pPager);
40310: sqlite3EndBenignMalloc();
40311: }else if( !pPager->exclusiveMode ){
40312: assert( pPager->eState==PAGER_READER );
40313: pager_end_transaction(pPager, 0);
40314: }
40315: }
40316: pager_unlock(pPager);
40317: }
40318:
40319: /*
40320: ** Parameter aData must point to a buffer of pPager->pageSize bytes
40321: ** of data. Compute and return a checksum based ont the contents of the
40322: ** page of data and the current value of pPager->cksumInit.
40323: **
40324: ** This is not a real checksum. It is really just the sum of the
40325: ** random initial value (pPager->cksumInit) and every 200th byte
40326: ** of the page data, starting with byte offset (pPager->pageSize%200).
40327: ** Each byte is interpreted as an 8-bit unsigned integer.
40328: **
40329: ** Changing the formula used to compute this checksum results in an
40330: ** incompatible journal file format.
40331: **
40332: ** If journal corruption occurs due to a power failure, the most likely
40333: ** scenario is that one end or the other of the record will be changed.
40334: ** It is much less likely that the two ends of the journal record will be
40335: ** correct and the middle be corrupt. Thus, this "checksum" scheme,
40336: ** though fast and simple, catches the mostly likely kind of corruption.
40337: */
40338: static u32 pager_cksum(Pager *pPager, const u8 *aData){
40339: u32 cksum = pPager->cksumInit; /* Checksum value to return */
40340: int i = pPager->pageSize-200; /* Loop counter */
40341: while( i>0 ){
40342: cksum += aData[i];
40343: i -= 200;
40344: }
40345: return cksum;
40346: }
40347:
40348: /*
40349: ** Report the current page size and number of reserved bytes back
40350: ** to the codec.
40351: */
40352: #ifdef SQLITE_HAS_CODEC
40353: static void pagerReportSize(Pager *pPager){
40354: if( pPager->xCodecSizeChng ){
40355: pPager->xCodecSizeChng(pPager->pCodec, pPager->pageSize,
40356: (int)pPager->nReserve);
40357: }
40358: }
40359: #else
40360: # define pagerReportSize(X) /* No-op if we do not support a codec */
40361: #endif
40362:
40363: /*
40364: ** Read a single page from either the journal file (if isMainJrnl==1) or
40365: ** from the sub-journal (if isMainJrnl==0) and playback that page.
40366: ** The page begins at offset *pOffset into the file. The *pOffset
40367: ** value is increased to the start of the next page in the journal.
40368: **
40369: ** The main rollback journal uses checksums - the statement journal does
40370: ** not.
40371: **
40372: ** If the page number of the page record read from the (sub-)journal file
40373: ** is greater than the current value of Pager.dbSize, then playback is
40374: ** skipped and SQLITE_OK is returned.
40375: **
40376: ** If pDone is not NULL, then it is a record of pages that have already
40377: ** been played back. If the page at *pOffset has already been played back
40378: ** (if the corresponding pDone bit is set) then skip the playback.
40379: ** Make sure the pDone bit corresponding to the *pOffset page is set
40380: ** prior to returning.
40381: **
40382: ** If the page record is successfully read from the (sub-)journal file
40383: ** and played back, then SQLITE_OK is returned. If an IO error occurs
40384: ** while reading the record from the (sub-)journal file or while writing
40385: ** to the database file, then the IO error code is returned. If data
40386: ** is successfully read from the (sub-)journal file but appears to be
40387: ** corrupted, SQLITE_DONE is returned. Data is considered corrupted in
40388: ** two circumstances:
40389: **
40390: ** * If the record page-number is illegal (0 or PAGER_MJ_PGNO), or
40391: ** * If the record is being rolled back from the main journal file
40392: ** and the checksum field does not match the record content.
40393: **
40394: ** Neither of these two scenarios are possible during a savepoint rollback.
40395: **
40396: ** If this is a savepoint rollback, then memory may have to be dynamically
40397: ** allocated by this function. If this is the case and an allocation fails,
40398: ** SQLITE_NOMEM is returned.
40399: */
40400: static int pager_playback_one_page(
40401: Pager *pPager, /* The pager being played back */
40402: i64 *pOffset, /* Offset of record to playback */
40403: Bitvec *pDone, /* Bitvec of pages already played back */
40404: int isMainJrnl, /* 1 -> main journal. 0 -> sub-journal. */
40405: int isSavepnt /* True for a savepoint rollback */
40406: ){
40407: int rc;
40408: PgHdr *pPg; /* An existing page in the cache */
40409: Pgno pgno; /* The page number of a page in journal */
40410: u32 cksum; /* Checksum used for sanity checking */
40411: char *aData; /* Temporary storage for the page */
40412: sqlite3_file *jfd; /* The file descriptor for the journal file */
40413: int isSynced; /* True if journal page is synced */
40414:
40415: assert( (isMainJrnl&~1)==0 ); /* isMainJrnl is 0 or 1 */
40416: assert( (isSavepnt&~1)==0 ); /* isSavepnt is 0 or 1 */
40417: assert( isMainJrnl || pDone ); /* pDone always used on sub-journals */
40418: assert( isSavepnt || pDone==0 ); /* pDone never used on non-savepoint */
40419:
40420: aData = pPager->pTmpSpace;
40421: assert( aData ); /* Temp storage must have already been allocated */
40422: assert( pagerUseWal(pPager)==0 || (!isMainJrnl && isSavepnt) );
40423:
40424: /* Either the state is greater than PAGER_WRITER_CACHEMOD (a transaction
40425: ** or savepoint rollback done at the request of the caller) or this is
40426: ** a hot-journal rollback. If it is a hot-journal rollback, the pager
40427: ** is in state OPEN and holds an EXCLUSIVE lock. Hot-journal rollback
40428: ** only reads from the main journal, not the sub-journal.
40429: */
40430: assert( pPager->eState>=PAGER_WRITER_CACHEMOD
40431: || (pPager->eState==PAGER_OPEN && pPager->eLock==EXCLUSIVE_LOCK)
40432: );
40433: assert( pPager->eState>=PAGER_WRITER_CACHEMOD || isMainJrnl );
40434:
40435: /* Read the page number and page data from the journal or sub-journal
40436: ** file. Return an error code to the caller if an IO error occurs.
40437: */
40438: jfd = isMainJrnl ? pPager->jfd : pPager->sjfd;
40439: rc = read32bits(jfd, *pOffset, &pgno);
40440: if( rc!=SQLITE_OK ) return rc;
40441: rc = sqlite3OsRead(jfd, (u8*)aData, pPager->pageSize, (*pOffset)+4);
40442: if( rc!=SQLITE_OK ) return rc;
40443: *pOffset += pPager->pageSize + 4 + isMainJrnl*4;
40444:
40445: /* Sanity checking on the page. This is more important that I originally
40446: ** thought. If a power failure occurs while the journal is being written,
40447: ** it could cause invalid data to be written into the journal. We need to
40448: ** detect this invalid data (with high probability) and ignore it.
40449: */
40450: if( pgno==0 || pgno==PAGER_MJ_PGNO(pPager) ){
40451: assert( !isSavepnt );
40452: return SQLITE_DONE;
40453: }
40454: if( pgno>(Pgno)pPager->dbSize || sqlite3BitvecTest(pDone, pgno) ){
40455: return SQLITE_OK;
40456: }
40457: if( isMainJrnl ){
40458: rc = read32bits(jfd, (*pOffset)-4, &cksum);
40459: if( rc ) return rc;
40460: if( !isSavepnt && pager_cksum(pPager, (u8*)aData)!=cksum ){
40461: return SQLITE_DONE;
40462: }
40463: }
40464:
40465: /* If this page has already been played by before during the current
40466: ** rollback, then don't bother to play it back again.
40467: */
40468: if( pDone && (rc = sqlite3BitvecSet(pDone, pgno))!=SQLITE_OK ){
40469: return rc;
40470: }
40471:
40472: /* When playing back page 1, restore the nReserve setting
40473: */
40474: if( pgno==1 && pPager->nReserve!=((u8*)aData)[20] ){
40475: pPager->nReserve = ((u8*)aData)[20];
40476: pagerReportSize(pPager);
40477: }
40478:
40479: /* If the pager is in CACHEMOD state, then there must be a copy of this
40480: ** page in the pager cache. In this case just update the pager cache,
40481: ** not the database file. The page is left marked dirty in this case.
40482: **
40483: ** An exception to the above rule: If the database is in no-sync mode
40484: ** and a page is moved during an incremental vacuum then the page may
40485: ** not be in the pager cache. Later: if a malloc() or IO error occurs
40486: ** during a Movepage() call, then the page may not be in the cache
40487: ** either. So the condition described in the above paragraph is not
40488: ** assert()able.
40489: **
40490: ** If in WRITER_DBMOD, WRITER_FINISHED or OPEN state, then we update the
40491: ** pager cache if it exists and the main file. The page is then marked
40492: ** not dirty. Since this code is only executed in PAGER_OPEN state for
40493: ** a hot-journal rollback, it is guaranteed that the page-cache is empty
40494: ** if the pager is in OPEN state.
40495: **
40496: ** Ticket #1171: The statement journal might contain page content that is
40497: ** different from the page content at the start of the transaction.
40498: ** This occurs when a page is changed prior to the start of a statement
40499: ** then changed again within the statement. When rolling back such a
40500: ** statement we must not write to the original database unless we know
40501: ** for certain that original page contents are synced into the main rollback
40502: ** journal. Otherwise, a power loss might leave modified data in the
40503: ** database file without an entry in the rollback journal that can
40504: ** restore the database to its original form. Two conditions must be
40505: ** met before writing to the database files. (1) the database must be
40506: ** locked. (2) we know that the original page content is fully synced
40507: ** in the main journal either because the page is not in cache or else
40508: ** the page is marked as needSync==0.
40509: **
40510: ** 2008-04-14: When attempting to vacuum a corrupt database file, it
40511: ** is possible to fail a statement on a database that does not yet exist.
40512: ** Do not attempt to write if database file has never been opened.
40513: */
40514: if( pagerUseWal(pPager) ){
40515: pPg = 0;
40516: }else{
40517: pPg = pager_lookup(pPager, pgno);
40518: }
40519: assert( pPg || !MEMDB );
40520: assert( pPager->eState!=PAGER_OPEN || pPg==0 );
40521: PAGERTRACE(("PLAYBACK %d page %d hash(%08x) %s\n",
40522: PAGERID(pPager), pgno, pager_datahash(pPager->pageSize, (u8*)aData),
40523: (isMainJrnl?"main-journal":"sub-journal")
40524: ));
40525: if( isMainJrnl ){
40526: isSynced = pPager->noSync || (*pOffset <= pPager->journalHdr);
40527: }else{
40528: isSynced = (pPg==0 || 0==(pPg->flags & PGHDR_NEED_SYNC));
40529: }
40530: if( isOpen(pPager->fd)
40531: && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
40532: && isSynced
40533: ){
40534: i64 ofst = (pgno-1)*(i64)pPager->pageSize;
40535: testcase( !isSavepnt && pPg!=0 && (pPg->flags&PGHDR_NEED_SYNC)!=0 );
40536: assert( !pagerUseWal(pPager) );
40537: rc = sqlite3OsWrite(pPager->fd, (u8*)aData, pPager->pageSize, ofst);
40538: if( pgno>pPager->dbFileSize ){
40539: pPager->dbFileSize = pgno;
40540: }
40541: if( pPager->pBackup ){
40542: CODEC1(pPager, aData, pgno, 3, rc=SQLITE_NOMEM);
40543: sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)aData);
40544: CODEC2(pPager, aData, pgno, 7, rc=SQLITE_NOMEM, aData);
40545: }
40546: }else if( !isMainJrnl && pPg==0 ){
40547: /* If this is a rollback of a savepoint and data was not written to
40548: ** the database and the page is not in-memory, there is a potential
40549: ** problem. When the page is next fetched by the b-tree layer, it
40550: ** will be read from the database file, which may or may not be
40551: ** current.
40552: **
40553: ** There are a couple of different ways this can happen. All are quite
40554: ** obscure. When running in synchronous mode, this can only happen
40555: ** if the page is on the free-list at the start of the transaction, then
40556: ** populated, then moved using sqlite3PagerMovepage().
40557: **
40558: ** The solution is to add an in-memory page to the cache containing
40559: ** the data just read from the sub-journal. Mark the page as dirty
40560: ** and if the pager requires a journal-sync, then mark the page as
40561: ** requiring a journal-sync before it is written.
40562: */
40563: assert( isSavepnt );
40564: assert( pPager->doNotSpill==0 );
40565: pPager->doNotSpill++;
40566: rc = sqlite3PagerAcquire(pPager, pgno, &pPg, 1);
40567: assert( pPager->doNotSpill==1 );
40568: pPager->doNotSpill--;
40569: if( rc!=SQLITE_OK ) return rc;
40570: pPg->flags &= ~PGHDR_NEED_READ;
40571: sqlite3PcacheMakeDirty(pPg);
40572: }
40573: if( pPg ){
40574: /* No page should ever be explicitly rolled back that is in use, except
40575: ** for page 1 which is held in use in order to keep the lock on the
40576: ** database active. However such a page may be rolled back as a result
40577: ** of an internal error resulting in an automatic call to
40578: ** sqlite3PagerRollback().
40579: */
40580: void *pData;
40581: pData = pPg->pData;
40582: memcpy(pData, (u8*)aData, pPager->pageSize);
40583: pPager->xReiniter(pPg);
40584: if( isMainJrnl && (!isSavepnt || *pOffset<=pPager->journalHdr) ){
40585: /* If the contents of this page were just restored from the main
40586: ** journal file, then its content must be as they were when the
40587: ** transaction was first opened. In this case we can mark the page
40588: ** as clean, since there will be no need to write it out to the
40589: ** database.
40590: **
40591: ** There is one exception to this rule. If the page is being rolled
40592: ** back as part of a savepoint (or statement) rollback from an
40593: ** unsynced portion of the main journal file, then it is not safe
40594: ** to mark the page as clean. This is because marking the page as
40595: ** clean will clear the PGHDR_NEED_SYNC flag. Since the page is
40596: ** already in the journal file (recorded in Pager.pInJournal) and
40597: ** the PGHDR_NEED_SYNC flag is cleared, if the page is written to
40598: ** again within this transaction, it will be marked as dirty but
40599: ** the PGHDR_NEED_SYNC flag will not be set. It could then potentially
40600: ** be written out into the database file before its journal file
40601: ** segment is synced. If a crash occurs during or following this,
40602: ** database corruption may ensue.
40603: */
40604: assert( !pagerUseWal(pPager) );
40605: sqlite3PcacheMakeClean(pPg);
40606: }
40607: pager_set_pagehash(pPg);
40608:
40609: /* If this was page 1, then restore the value of Pager.dbFileVers.
40610: ** Do this before any decoding. */
40611: if( pgno==1 ){
40612: memcpy(&pPager->dbFileVers, &((u8*)pData)[24],sizeof(pPager->dbFileVers));
40613: }
40614:
40615: /* Decode the page just read from disk */
40616: CODEC1(pPager, pData, pPg->pgno, 3, rc=SQLITE_NOMEM);
40617: sqlite3PcacheRelease(pPg);
40618: }
40619: return rc;
40620: }
40621:
40622: /*
40623: ** Parameter zMaster is the name of a master journal file. A single journal
40624: ** file that referred to the master journal file has just been rolled back.
40625: ** This routine checks if it is possible to delete the master journal file,
40626: ** and does so if it is.
40627: **
40628: ** Argument zMaster may point to Pager.pTmpSpace. So that buffer is not
40629: ** available for use within this function.
40630: **
40631: ** When a master journal file is created, it is populated with the names
40632: ** of all of its child journals, one after another, formatted as utf-8
40633: ** encoded text. The end of each child journal file is marked with a
40634: ** nul-terminator byte (0x00). i.e. the entire contents of a master journal
40635: ** file for a transaction involving two databases might be:
40636: **
40637: ** "/home/bill/a.db-journal\x00/home/bill/b.db-journal\x00"
40638: **
40639: ** A master journal file may only be deleted once all of its child
40640: ** journals have been rolled back.
40641: **
40642: ** This function reads the contents of the master-journal file into
40643: ** memory and loops through each of the child journal names. For
40644: ** each child journal, it checks if:
40645: **
40646: ** * if the child journal exists, and if so
40647: ** * if the child journal contains a reference to master journal
40648: ** file zMaster
40649: **
40650: ** If a child journal can be found that matches both of the criteria
40651: ** above, this function returns without doing anything. Otherwise, if
40652: ** no such child journal can be found, file zMaster is deleted from
40653: ** the file-system using sqlite3OsDelete().
40654: **
40655: ** If an IO error within this function, an error code is returned. This
40656: ** function allocates memory by calling sqlite3Malloc(). If an allocation
40657: ** fails, SQLITE_NOMEM is returned. Otherwise, if no IO or malloc errors
40658: ** occur, SQLITE_OK is returned.
40659: **
40660: ** TODO: This function allocates a single block of memory to load
40661: ** the entire contents of the master journal file. This could be
40662: ** a couple of kilobytes or so - potentially larger than the page
40663: ** size.
40664: */
40665: static int pager_delmaster(Pager *pPager, const char *zMaster){
40666: sqlite3_vfs *pVfs = pPager->pVfs;
40667: int rc; /* Return code */
40668: sqlite3_file *pMaster; /* Malloc'd master-journal file descriptor */
40669: sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */
40670: char *zMasterJournal = 0; /* Contents of master journal file */
40671: i64 nMasterJournal; /* Size of master journal file */
40672: char *zJournal; /* Pointer to one journal within MJ file */
40673: char *zMasterPtr; /* Space to hold MJ filename from a journal file */
40674: int nMasterPtr; /* Amount of space allocated to zMasterPtr[] */
40675:
40676: /* Allocate space for both the pJournal and pMaster file descriptors.
40677: ** If successful, open the master journal file for reading.
40678: */
40679: pMaster = (sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile * 2);
40680: pJournal = (sqlite3_file *)(((u8 *)pMaster) + pVfs->szOsFile);
40681: if( !pMaster ){
40682: rc = SQLITE_NOMEM;
40683: }else{
40684: const int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MASTER_JOURNAL);
40685: rc = sqlite3OsOpen(pVfs, zMaster, pMaster, flags, 0);
40686: }
40687: if( rc!=SQLITE_OK ) goto delmaster_out;
40688:
40689: /* Load the entire master journal file into space obtained from
40690: ** sqlite3_malloc() and pointed to by zMasterJournal. Also obtain
40691: ** sufficient space (in zMasterPtr) to hold the names of master
40692: ** journal files extracted from regular rollback-journals.
40693: */
40694: rc = sqlite3OsFileSize(pMaster, &nMasterJournal);
40695: if( rc!=SQLITE_OK ) goto delmaster_out;
40696: nMasterPtr = pVfs->mxPathname+1;
40697: zMasterJournal = sqlite3Malloc((int)nMasterJournal + nMasterPtr + 1);
40698: if( !zMasterJournal ){
40699: rc = SQLITE_NOMEM;
40700: goto delmaster_out;
40701: }
40702: zMasterPtr = &zMasterJournal[nMasterJournal+1];
40703: rc = sqlite3OsRead(pMaster, zMasterJournal, (int)nMasterJournal, 0);
40704: if( rc!=SQLITE_OK ) goto delmaster_out;
40705: zMasterJournal[nMasterJournal] = 0;
40706:
40707: zJournal = zMasterJournal;
40708: while( (zJournal-zMasterJournal)<nMasterJournal ){
40709: int exists;
40710: rc = sqlite3OsAccess(pVfs, zJournal, SQLITE_ACCESS_EXISTS, &exists);
40711: if( rc!=SQLITE_OK ){
40712: goto delmaster_out;
40713: }
40714: if( exists ){
40715: /* One of the journals pointed to by the master journal exists.
40716: ** Open it and check if it points at the master journal. If
40717: ** so, return without deleting the master journal file.
40718: */
40719: int c;
40720: int flags = (SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL);
40721: rc = sqlite3OsOpen(pVfs, zJournal, pJournal, flags, 0);
40722: if( rc!=SQLITE_OK ){
40723: goto delmaster_out;
40724: }
40725:
40726: rc = readMasterJournal(pJournal, zMasterPtr, nMasterPtr);
40727: sqlite3OsClose(pJournal);
40728: if( rc!=SQLITE_OK ){
40729: goto delmaster_out;
40730: }
40731:
40732: c = zMasterPtr[0]!=0 && strcmp(zMasterPtr, zMaster)==0;
40733: if( c ){
40734: /* We have a match. Do not delete the master journal file. */
40735: goto delmaster_out;
40736: }
40737: }
40738: zJournal += (sqlite3Strlen30(zJournal)+1);
40739: }
40740:
40741: sqlite3OsClose(pMaster);
40742: rc = sqlite3OsDelete(pVfs, zMaster, 0);
40743:
40744: delmaster_out:
40745: sqlite3_free(zMasterJournal);
40746: if( pMaster ){
40747: sqlite3OsClose(pMaster);
40748: assert( !isOpen(pJournal) );
40749: sqlite3_free(pMaster);
40750: }
40751: return rc;
40752: }
40753:
40754:
40755: /*
40756: ** This function is used to change the actual size of the database
40757: ** file in the file-system. This only happens when committing a transaction,
40758: ** or rolling back a transaction (including rolling back a hot-journal).
40759: **
40760: ** If the main database file is not open, or the pager is not in either
40761: ** DBMOD or OPEN state, this function is a no-op. Otherwise, the size
40762: ** of the file is changed to nPage pages (nPage*pPager->pageSize bytes).
40763: ** If the file on disk is currently larger than nPage pages, then use the VFS
40764: ** xTruncate() method to truncate it.
40765: **
40766: ** Or, it might might be the case that the file on disk is smaller than
40767: ** nPage pages. Some operating system implementations can get confused if
40768: ** you try to truncate a file to some size that is larger than it
40769: ** currently is, so detect this case and write a single zero byte to
40770: ** the end of the new file instead.
40771: **
40772: ** If successful, return SQLITE_OK. If an IO error occurs while modifying
40773: ** the database file, return the error code to the caller.
40774: */
40775: static int pager_truncate(Pager *pPager, Pgno nPage){
40776: int rc = SQLITE_OK;
40777: assert( pPager->eState!=PAGER_ERROR );
40778: assert( pPager->eState!=PAGER_READER );
40779:
40780: if( isOpen(pPager->fd)
40781: && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
40782: ){
40783: i64 currentSize, newSize;
40784: int szPage = pPager->pageSize;
40785: assert( pPager->eLock==EXCLUSIVE_LOCK );
40786: /* TODO: Is it safe to use Pager.dbFileSize here? */
40787: rc = sqlite3OsFileSize(pPager->fd, ¤tSize);
40788: newSize = szPage*(i64)nPage;
40789: if( rc==SQLITE_OK && currentSize!=newSize ){
40790: if( currentSize>newSize ){
40791: rc = sqlite3OsTruncate(pPager->fd, newSize);
40792: }else if( (currentSize+szPage)<=newSize ){
40793: char *pTmp = pPager->pTmpSpace;
40794: memset(pTmp, 0, szPage);
40795: testcase( (newSize-szPage) == currentSize );
40796: testcase( (newSize-szPage) > currentSize );
40797: rc = sqlite3OsWrite(pPager->fd, pTmp, szPage, newSize-szPage);
40798: }
40799: if( rc==SQLITE_OK ){
40800: pPager->dbFileSize = nPage;
40801: }
40802: }
40803: }
40804: return rc;
40805: }
40806:
40807: /*
40808: ** Set the value of the Pager.sectorSize variable for the given
40809: ** pager based on the value returned by the xSectorSize method
40810: ** of the open database file. The sector size will be used used
40811: ** to determine the size and alignment of journal header and
40812: ** master journal pointers within created journal files.
40813: **
40814: ** For temporary files the effective sector size is always 512 bytes.
40815: **
40816: ** Otherwise, for non-temporary files, the effective sector size is
40817: ** the value returned by the xSectorSize() method rounded up to 32 if
40818: ** it is less than 32, or rounded down to MAX_SECTOR_SIZE if it
40819: ** is greater than MAX_SECTOR_SIZE.
40820: **
40821: ** If the file has the SQLITE_IOCAP_POWERSAFE_OVERWRITE property, then set
40822: ** the effective sector size to its minimum value (512). The purpose of
40823: ** pPager->sectorSize is to define the "blast radius" of bytes that
40824: ** might change if a crash occurs while writing to a single byte in
40825: ** that range. But with POWERSAFE_OVERWRITE, the blast radius is zero
40826: ** (that is what POWERSAFE_OVERWRITE means), so we minimize the sector
40827: ** size. For backwards compatibility of the rollback journal file format,
40828: ** we cannot reduce the effective sector size below 512.
40829: */
40830: static void setSectorSize(Pager *pPager){
40831: assert( isOpen(pPager->fd) || pPager->tempFile );
40832:
40833: if( pPager->tempFile
40834: || (sqlite3OsDeviceCharacteristics(pPager->fd) &
40835: SQLITE_IOCAP_POWERSAFE_OVERWRITE)!=0
40836: ){
40837: /* Sector size doesn't matter for temporary files. Also, the file
40838: ** may not have been opened yet, in which case the OsSectorSize()
40839: ** call will segfault. */
40840: pPager->sectorSize = 512;
40841: }else{
40842: pPager->sectorSize = sqlite3OsSectorSize(pPager->fd);
40843: if( pPager->sectorSize<32 ){
40844: pPager->sectorSize = 512;
40845: }
40846: if( pPager->sectorSize>MAX_SECTOR_SIZE ){
40847: assert( MAX_SECTOR_SIZE>=512 );
40848: pPager->sectorSize = MAX_SECTOR_SIZE;
40849: }
40850: }
40851: }
40852:
40853: /*
40854: ** Playback the journal and thus restore the database file to
40855: ** the state it was in before we started making changes.
40856: **
40857: ** The journal file format is as follows:
40858: **
40859: ** (1) 8 byte prefix. A copy of aJournalMagic[].
40860: ** (2) 4 byte big-endian integer which is the number of valid page records
40861: ** in the journal. If this value is 0xffffffff, then compute the
40862: ** number of page records from the journal size.
40863: ** (3) 4 byte big-endian integer which is the initial value for the
40864: ** sanity checksum.
40865: ** (4) 4 byte integer which is the number of pages to truncate the
40866: ** database to during a rollback.
40867: ** (5) 4 byte big-endian integer which is the sector size. The header
40868: ** is this many bytes in size.
40869: ** (6) 4 byte big-endian integer which is the page size.
40870: ** (7) zero padding out to the next sector size.
40871: ** (8) Zero or more pages instances, each as follows:
40872: ** + 4 byte page number.
40873: ** + pPager->pageSize bytes of data.
40874: ** + 4 byte checksum
40875: **
40876: ** When we speak of the journal header, we mean the first 7 items above.
40877: ** Each entry in the journal is an instance of the 8th item.
40878: **
40879: ** Call the value from the second bullet "nRec". nRec is the number of
40880: ** valid page entries in the journal. In most cases, you can compute the
40881: ** value of nRec from the size of the journal file. But if a power
40882: ** failure occurred while the journal was being written, it could be the
40883: ** case that the size of the journal file had already been increased but
40884: ** the extra entries had not yet made it safely to disk. In such a case,
40885: ** the value of nRec computed from the file size would be too large. For
40886: ** that reason, we always use the nRec value in the header.
40887: **
40888: ** If the nRec value is 0xffffffff it means that nRec should be computed
40889: ** from the file size. This value is used when the user selects the
40890: ** no-sync option for the journal. A power failure could lead to corruption
40891: ** in this case. But for things like temporary table (which will be
40892: ** deleted when the power is restored) we don't care.
40893: **
40894: ** If the file opened as the journal file is not a well-formed
40895: ** journal file then all pages up to the first corrupted page are rolled
40896: ** back (or no pages if the journal header is corrupted). The journal file
40897: ** is then deleted and SQLITE_OK returned, just as if no corruption had
40898: ** been encountered.
40899: **
40900: ** If an I/O or malloc() error occurs, the journal-file is not deleted
40901: ** and an error code is returned.
40902: **
40903: ** The isHot parameter indicates that we are trying to rollback a journal
40904: ** that might be a hot journal. Or, it could be that the journal is
40905: ** preserved because of JOURNALMODE_PERSIST or JOURNALMODE_TRUNCATE.
40906: ** If the journal really is hot, reset the pager cache prior rolling
40907: ** back any content. If the journal is merely persistent, no reset is
40908: ** needed.
40909: */
40910: static int pager_playback(Pager *pPager, int isHot){
40911: sqlite3_vfs *pVfs = pPager->pVfs;
40912: i64 szJ; /* Size of the journal file in bytes */
40913: u32 nRec; /* Number of Records in the journal */
40914: u32 u; /* Unsigned loop counter */
40915: Pgno mxPg = 0; /* Size of the original file in pages */
40916: int rc; /* Result code of a subroutine */
40917: int res = 1; /* Value returned by sqlite3OsAccess() */
40918: char *zMaster = 0; /* Name of master journal file if any */
40919: int needPagerReset; /* True to reset page prior to first page rollback */
40920:
40921: /* Figure out how many records are in the journal. Abort early if
40922: ** the journal is empty.
40923: */
40924: assert( isOpen(pPager->jfd) );
40925: rc = sqlite3OsFileSize(pPager->jfd, &szJ);
40926: if( rc!=SQLITE_OK ){
40927: goto end_playback;
40928: }
40929:
40930: /* Read the master journal name from the journal, if it is present.
40931: ** If a master journal file name is specified, but the file is not
40932: ** present on disk, then the journal is not hot and does not need to be
40933: ** played back.
40934: **
40935: ** TODO: Technically the following is an error because it assumes that
40936: ** buffer Pager.pTmpSpace is (mxPathname+1) bytes or larger. i.e. that
40937: ** (pPager->pageSize >= pPager->pVfs->mxPathname+1). Using os_unix.c,
40938: ** mxPathname is 512, which is the same as the minimum allowable value
40939: ** for pageSize.
40940: */
40941: zMaster = pPager->pTmpSpace;
40942: rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
40943: if( rc==SQLITE_OK && zMaster[0] ){
40944: rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res);
40945: }
40946: zMaster = 0;
40947: if( rc!=SQLITE_OK || !res ){
40948: goto end_playback;
40949: }
40950: pPager->journalOff = 0;
40951: needPagerReset = isHot;
40952:
40953: /* This loop terminates either when a readJournalHdr() or
40954: ** pager_playback_one_page() call returns SQLITE_DONE or an IO error
40955: ** occurs.
40956: */
40957: while( 1 ){
40958: /* Read the next journal header from the journal file. If there are
40959: ** not enough bytes left in the journal file for a complete header, or
40960: ** it is corrupted, then a process must have failed while writing it.
40961: ** This indicates nothing more needs to be rolled back.
40962: */
40963: rc = readJournalHdr(pPager, isHot, szJ, &nRec, &mxPg);
40964: if( rc!=SQLITE_OK ){
40965: if( rc==SQLITE_DONE ){
40966: rc = SQLITE_OK;
40967: }
40968: goto end_playback;
40969: }
40970:
40971: /* If nRec is 0xffffffff, then this journal was created by a process
40972: ** working in no-sync mode. This means that the rest of the journal
40973: ** file consists of pages, there are no more journal headers. Compute
40974: ** the value of nRec based on this assumption.
40975: */
40976: if( nRec==0xffffffff ){
40977: assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) );
40978: nRec = (int)((szJ - JOURNAL_HDR_SZ(pPager))/JOURNAL_PG_SZ(pPager));
40979: }
40980:
40981: /* If nRec is 0 and this rollback is of a transaction created by this
40982: ** process and if this is the final header in the journal, then it means
40983: ** that this part of the journal was being filled but has not yet been
40984: ** synced to disk. Compute the number of pages based on the remaining
40985: ** size of the file.
40986: **
40987: ** The third term of the test was added to fix ticket #2565.
40988: ** When rolling back a hot journal, nRec==0 always means that the next
40989: ** chunk of the journal contains zero pages to be rolled back. But
40990: ** when doing a ROLLBACK and the nRec==0 chunk is the last chunk in
40991: ** the journal, it means that the journal might contain additional
40992: ** pages that need to be rolled back and that the number of pages
40993: ** should be computed based on the journal file size.
40994: */
40995: if( nRec==0 && !isHot &&
40996: pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff ){
40997: nRec = (int)((szJ - pPager->journalOff) / JOURNAL_PG_SZ(pPager));
40998: }
40999:
41000: /* If this is the first header read from the journal, truncate the
41001: ** database file back to its original size.
41002: */
41003: if( pPager->journalOff==JOURNAL_HDR_SZ(pPager) ){
41004: rc = pager_truncate(pPager, mxPg);
41005: if( rc!=SQLITE_OK ){
41006: goto end_playback;
41007: }
41008: pPager->dbSize = mxPg;
41009: }
41010:
41011: /* Copy original pages out of the journal and back into the
41012: ** database file and/or page cache.
41013: */
41014: for(u=0; u<nRec; u++){
41015: if( needPagerReset ){
41016: pager_reset(pPager);
41017: needPagerReset = 0;
41018: }
41019: rc = pager_playback_one_page(pPager,&pPager->journalOff,0,1,0);
41020: if( rc!=SQLITE_OK ){
41021: if( rc==SQLITE_DONE ){
41022: pPager->journalOff = szJ;
41023: break;
41024: }else if( rc==SQLITE_IOERR_SHORT_READ ){
41025: /* If the journal has been truncated, simply stop reading and
41026: ** processing the journal. This might happen if the journal was
41027: ** not completely written and synced prior to a crash. In that
41028: ** case, the database should have never been written in the
41029: ** first place so it is OK to simply abandon the rollback. */
41030: rc = SQLITE_OK;
41031: goto end_playback;
41032: }else{
41033: /* If we are unable to rollback, quit and return the error
41034: ** code. This will cause the pager to enter the error state
41035: ** so that no further harm will be done. Perhaps the next
41036: ** process to come along will be able to rollback the database.
41037: */
41038: goto end_playback;
41039: }
41040: }
41041: }
41042: }
41043: /*NOTREACHED*/
41044: assert( 0 );
41045:
41046: end_playback:
41047: /* Following a rollback, the database file should be back in its original
41048: ** state prior to the start of the transaction, so invoke the
41049: ** SQLITE_FCNTL_DB_UNCHANGED file-control method to disable the
41050: ** assertion that the transaction counter was modified.
41051: */
41052: #ifdef SQLITE_DEBUG
41053: if( pPager->fd->pMethods ){
41054: sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
41055: }
41056: #endif
41057:
41058: /* If this playback is happening automatically as a result of an IO or
41059: ** malloc error that occurred after the change-counter was updated but
41060: ** before the transaction was committed, then the change-counter
41061: ** modification may just have been reverted. If this happens in exclusive
41062: ** mode, then subsequent transactions performed by the connection will not
41063: ** update the change-counter at all. This may lead to cache inconsistency
41064: ** problems for other processes at some point in the future. So, just
41065: ** in case this has happened, clear the changeCountDone flag now.
41066: */
41067: pPager->changeCountDone = pPager->tempFile;
41068:
41069: if( rc==SQLITE_OK ){
41070: zMaster = pPager->pTmpSpace;
41071: rc = readMasterJournal(pPager->jfd, zMaster, pPager->pVfs->mxPathname+1);
41072: testcase( rc!=SQLITE_OK );
41073: }
41074: if( rc==SQLITE_OK
41075: && (pPager->eState>=PAGER_WRITER_DBMOD || pPager->eState==PAGER_OPEN)
41076: ){
41077: rc = sqlite3PagerSync(pPager);
41078: }
41079: if( rc==SQLITE_OK ){
41080: rc = pager_end_transaction(pPager, zMaster[0]!='\0');
41081: testcase( rc!=SQLITE_OK );
41082: }
41083: if( rc==SQLITE_OK && zMaster[0] && res ){
41084: /* If there was a master journal and this routine will return success,
41085: ** see if it is possible to delete the master journal.
41086: */
41087: rc = pager_delmaster(pPager, zMaster);
41088: testcase( rc!=SQLITE_OK );
41089: }
41090:
41091: /* The Pager.sectorSize variable may have been updated while rolling
41092: ** back a journal created by a process with a different sector size
41093: ** value. Reset it to the correct value for this process.
41094: */
41095: setSectorSize(pPager);
41096: return rc;
41097: }
41098:
41099:
41100: /*
41101: ** Read the content for page pPg out of the database file and into
41102: ** pPg->pData. A shared lock or greater must be held on the database
41103: ** file before this function is called.
41104: **
41105: ** If page 1 is read, then the value of Pager.dbFileVers[] is set to
41106: ** the value read from the database file.
41107: **
41108: ** If an IO error occurs, then the IO error is returned to the caller.
41109: ** Otherwise, SQLITE_OK is returned.
41110: */
41111: static int readDbPage(PgHdr *pPg){
41112: Pager *pPager = pPg->pPager; /* Pager object associated with page pPg */
41113: Pgno pgno = pPg->pgno; /* Page number to read */
41114: int rc = SQLITE_OK; /* Return code */
41115: int isInWal = 0; /* True if page is in log file */
41116: int pgsz = pPager->pageSize; /* Number of bytes to read */
41117:
41118: assert( pPager->eState>=PAGER_READER && !MEMDB );
41119: assert( isOpen(pPager->fd) );
41120:
41121: if( NEVER(!isOpen(pPager->fd)) ){
41122: assert( pPager->tempFile );
41123: memset(pPg->pData, 0, pPager->pageSize);
41124: return SQLITE_OK;
41125: }
41126:
41127: if( pagerUseWal(pPager) ){
41128: /* Try to pull the page from the write-ahead log. */
41129: rc = sqlite3WalRead(pPager->pWal, pgno, &isInWal, pgsz, pPg->pData);
41130: }
41131: if( rc==SQLITE_OK && !isInWal ){
41132: i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
41133: rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
41134: if( rc==SQLITE_IOERR_SHORT_READ ){
41135: rc = SQLITE_OK;
41136: }
41137: }
41138:
41139: if( pgno==1 ){
41140: if( rc ){
41141: /* If the read is unsuccessful, set the dbFileVers[] to something
41142: ** that will never be a valid file version. dbFileVers[] is a copy
41143: ** of bytes 24..39 of the database. Bytes 28..31 should always be
41144: ** zero or the size of the database in page. Bytes 32..35 and 35..39
41145: ** should be page numbers which are never 0xffffffff. So filling
41146: ** pPager->dbFileVers[] with all 0xff bytes should suffice.
41147: **
41148: ** For an encrypted database, the situation is more complex: bytes
41149: ** 24..39 of the database are white noise. But the probability of
41150: ** white noising equaling 16 bytes of 0xff is vanishingly small so
41151: ** we should still be ok.
41152: */
41153: memset(pPager->dbFileVers, 0xff, sizeof(pPager->dbFileVers));
41154: }else{
41155: u8 *dbFileVers = &((u8*)pPg->pData)[24];
41156: memcpy(&pPager->dbFileVers, dbFileVers, sizeof(pPager->dbFileVers));
41157: }
41158: }
41159: CODEC1(pPager, pPg->pData, pgno, 3, rc = SQLITE_NOMEM);
41160:
41161: PAGER_INCR(sqlite3_pager_readdb_count);
41162: PAGER_INCR(pPager->nRead);
41163: IOTRACE(("PGIN %p %d\n", pPager, pgno));
41164: PAGERTRACE(("FETCH %d page %d hash(%08x)\n",
41165: PAGERID(pPager), pgno, pager_pagehash(pPg)));
41166:
41167: return rc;
41168: }
41169:
41170: /*
41171: ** Update the value of the change-counter at offsets 24 and 92 in
41172: ** the header and the sqlite version number at offset 96.
41173: **
41174: ** This is an unconditional update. See also the pager_incr_changecounter()
41175: ** routine which only updates the change-counter if the update is actually
41176: ** needed, as determined by the pPager->changeCountDone state variable.
41177: */
41178: static void pager_write_changecounter(PgHdr *pPg){
41179: u32 change_counter;
41180:
41181: /* Increment the value just read and write it back to byte 24. */
41182: change_counter = sqlite3Get4byte((u8*)pPg->pPager->dbFileVers)+1;
41183: put32bits(((char*)pPg->pData)+24, change_counter);
41184:
41185: /* Also store the SQLite version number in bytes 96..99 and in
41186: ** bytes 92..95 store the change counter for which the version number
41187: ** is valid. */
41188: put32bits(((char*)pPg->pData)+92, change_counter);
41189: put32bits(((char*)pPg->pData)+96, SQLITE_VERSION_NUMBER);
41190: }
41191:
41192: #ifndef SQLITE_OMIT_WAL
41193: /*
41194: ** This function is invoked once for each page that has already been
41195: ** written into the log file when a WAL transaction is rolled back.
41196: ** Parameter iPg is the page number of said page. The pCtx argument
41197: ** is actually a pointer to the Pager structure.
41198: **
41199: ** If page iPg is present in the cache, and has no outstanding references,
41200: ** it is discarded. Otherwise, if there are one or more outstanding
41201: ** references, the page content is reloaded from the database. If the
41202: ** attempt to reload content from the database is required and fails,
41203: ** return an SQLite error code. Otherwise, SQLITE_OK.
41204: */
41205: static int pagerUndoCallback(void *pCtx, Pgno iPg){
41206: int rc = SQLITE_OK;
41207: Pager *pPager = (Pager *)pCtx;
41208: PgHdr *pPg;
41209:
41210: pPg = sqlite3PagerLookup(pPager, iPg);
41211: if( pPg ){
41212: if( sqlite3PcachePageRefcount(pPg)==1 ){
41213: sqlite3PcacheDrop(pPg);
41214: }else{
41215: rc = readDbPage(pPg);
41216: if( rc==SQLITE_OK ){
41217: pPager->xReiniter(pPg);
41218: }
41219: sqlite3PagerUnref(pPg);
41220: }
41221: }
41222:
41223: /* Normally, if a transaction is rolled back, any backup processes are
41224: ** updated as data is copied out of the rollback journal and into the
41225: ** database. This is not generally possible with a WAL database, as
41226: ** rollback involves simply truncating the log file. Therefore, if one
41227: ** or more frames have already been written to the log (and therefore
41228: ** also copied into the backup databases) as part of this transaction,
41229: ** the backups must be restarted.
41230: */
41231: sqlite3BackupRestart(pPager->pBackup);
41232:
41233: return rc;
41234: }
41235:
41236: /*
41237: ** This function is called to rollback a transaction on a WAL database.
41238: */
41239: static int pagerRollbackWal(Pager *pPager){
41240: int rc; /* Return Code */
41241: PgHdr *pList; /* List of dirty pages to revert */
41242:
41243: /* For all pages in the cache that are currently dirty or have already
41244: ** been written (but not committed) to the log file, do one of the
41245: ** following:
41246: **
41247: ** + Discard the cached page (if refcount==0), or
41248: ** + Reload page content from the database (if refcount>0).
41249: */
41250: pPager->dbSize = pPager->dbOrigSize;
41251: rc = sqlite3WalUndo(pPager->pWal, pagerUndoCallback, (void *)pPager);
41252: pList = sqlite3PcacheDirtyList(pPager->pPCache);
41253: while( pList && rc==SQLITE_OK ){
41254: PgHdr *pNext = pList->pDirty;
41255: rc = pagerUndoCallback((void *)pPager, pList->pgno);
41256: pList = pNext;
41257: }
41258:
41259: return rc;
41260: }
41261:
41262: /*
41263: ** This function is a wrapper around sqlite3WalFrames(). As well as logging
41264: ** the contents of the list of pages headed by pList (connected by pDirty),
41265: ** this function notifies any active backup processes that the pages have
41266: ** changed.
41267: **
41268: ** The list of pages passed into this routine is always sorted by page number.
41269: ** Hence, if page 1 appears anywhere on the list, it will be the first page.
41270: */
41271: static int pagerWalFrames(
41272: Pager *pPager, /* Pager object */
41273: PgHdr *pList, /* List of frames to log */
41274: Pgno nTruncate, /* Database size after this commit */
41275: int isCommit /* True if this is a commit */
41276: ){
41277: int rc; /* Return code */
41278: #if defined(SQLITE_DEBUG) || defined(SQLITE_CHECK_PAGES)
41279: PgHdr *p; /* For looping over pages */
41280: #endif
41281:
41282: assert( pPager->pWal );
41283: assert( pList );
41284: #ifdef SQLITE_DEBUG
41285: /* Verify that the page list is in accending order */
41286: for(p=pList; p && p->pDirty; p=p->pDirty){
41287: assert( p->pgno < p->pDirty->pgno );
41288: }
41289: #endif
41290:
41291: if( isCommit ){
41292: /* If a WAL transaction is being committed, there is no point in writing
41293: ** any pages with page numbers greater than nTruncate into the WAL file.
41294: ** They will never be read by any client. So remove them from the pDirty
41295: ** list here. */
41296: PgHdr *p;
41297: PgHdr **ppNext = &pList;
41298: for(p=pList; (*ppNext = p); p=p->pDirty){
41299: if( p->pgno<=nTruncate ) ppNext = &p->pDirty;
41300: }
41301: assert( pList );
41302: }
41303:
41304: if( pList->pgno==1 ) pager_write_changecounter(pList);
41305: rc = sqlite3WalFrames(pPager->pWal,
41306: pPager->pageSize, pList, nTruncate, isCommit, pPager->walSyncFlags
41307: );
41308: if( rc==SQLITE_OK && pPager->pBackup ){
41309: PgHdr *p;
41310: for(p=pList; p; p=p->pDirty){
41311: sqlite3BackupUpdate(pPager->pBackup, p->pgno, (u8 *)p->pData);
41312: }
41313: }
41314:
41315: #ifdef SQLITE_CHECK_PAGES
41316: pList = sqlite3PcacheDirtyList(pPager->pPCache);
41317: for(p=pList; p; p=p->pDirty){
41318: pager_set_pagehash(p);
41319: }
41320: #endif
41321:
41322: return rc;
41323: }
41324:
41325: /*
41326: ** Begin a read transaction on the WAL.
41327: **
41328: ** This routine used to be called "pagerOpenSnapshot()" because it essentially
41329: ** makes a snapshot of the database at the current point in time and preserves
41330: ** that snapshot for use by the reader in spite of concurrently changes by
41331: ** other writers or checkpointers.
41332: */
41333: static int pagerBeginReadTransaction(Pager *pPager){
41334: int rc; /* Return code */
41335: int changed = 0; /* True if cache must be reset */
41336:
41337: assert( pagerUseWal(pPager) );
41338: assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
41339:
41340: /* sqlite3WalEndReadTransaction() was not called for the previous
41341: ** transaction in locking_mode=EXCLUSIVE. So call it now. If we
41342: ** are in locking_mode=NORMAL and EndRead() was previously called,
41343: ** the duplicate call is harmless.
41344: */
41345: sqlite3WalEndReadTransaction(pPager->pWal);
41346:
41347: rc = sqlite3WalBeginReadTransaction(pPager->pWal, &changed);
41348: if( rc!=SQLITE_OK || changed ){
41349: pager_reset(pPager);
41350: }
41351:
41352: return rc;
41353: }
41354: #endif
41355:
41356: /*
41357: ** This function is called as part of the transition from PAGER_OPEN
41358: ** to PAGER_READER state to determine the size of the database file
41359: ** in pages (assuming the page size currently stored in Pager.pageSize).
41360: **
41361: ** If no error occurs, SQLITE_OK is returned and the size of the database
41362: ** in pages is stored in *pnPage. Otherwise, an error code (perhaps
41363: ** SQLITE_IOERR_FSTAT) is returned and *pnPage is left unmodified.
41364: */
41365: static int pagerPagecount(Pager *pPager, Pgno *pnPage){
41366: Pgno nPage; /* Value to return via *pnPage */
41367:
41368: /* Query the WAL sub-system for the database size. The WalDbsize()
41369: ** function returns zero if the WAL is not open (i.e. Pager.pWal==0), or
41370: ** if the database size is not available. The database size is not
41371: ** available from the WAL sub-system if the log file is empty or
41372: ** contains no valid committed transactions.
41373: */
41374: assert( pPager->eState==PAGER_OPEN );
41375: assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
41376: nPage = sqlite3WalDbsize(pPager->pWal);
41377:
41378: /* If the database size was not available from the WAL sub-system,
41379: ** determine it based on the size of the database file. If the size
41380: ** of the database file is not an integer multiple of the page-size,
41381: ** round down to the nearest page. Except, any file larger than 0
41382: ** bytes in size is considered to contain at least one page.
41383: */
41384: if( nPage==0 ){
41385: i64 n = 0; /* Size of db file in bytes */
41386: assert( isOpen(pPager->fd) || pPager->tempFile );
41387: if( isOpen(pPager->fd) ){
41388: int rc = sqlite3OsFileSize(pPager->fd, &n);
41389: if( rc!=SQLITE_OK ){
41390: return rc;
41391: }
41392: }
41393: nPage = (Pgno)((n+pPager->pageSize-1) / pPager->pageSize);
41394: }
41395:
41396: /* If the current number of pages in the file is greater than the
41397: ** configured maximum pager number, increase the allowed limit so
41398: ** that the file can be read.
41399: */
41400: if( nPage>pPager->mxPgno ){
41401: pPager->mxPgno = (Pgno)nPage;
41402: }
41403:
41404: *pnPage = nPage;
41405: return SQLITE_OK;
41406: }
41407:
41408: #ifndef SQLITE_OMIT_WAL
41409: /*
41410: ** Check if the *-wal file that corresponds to the database opened by pPager
41411: ** exists if the database is not empy, or verify that the *-wal file does
41412: ** not exist (by deleting it) if the database file is empty.
41413: **
41414: ** If the database is not empty and the *-wal file exists, open the pager
41415: ** in WAL mode. If the database is empty or if no *-wal file exists and
41416: ** if no error occurs, make sure Pager.journalMode is not set to
41417: ** PAGER_JOURNALMODE_WAL.
41418: **
41419: ** Return SQLITE_OK or an error code.
41420: **
41421: ** The caller must hold a SHARED lock on the database file to call this
41422: ** function. Because an EXCLUSIVE lock on the db file is required to delete
41423: ** a WAL on a none-empty database, this ensures there is no race condition
41424: ** between the xAccess() below and an xDelete() being executed by some
41425: ** other connection.
41426: */
41427: static int pagerOpenWalIfPresent(Pager *pPager){
41428: int rc = SQLITE_OK;
41429: assert( pPager->eState==PAGER_OPEN );
41430: assert( pPager->eLock>=SHARED_LOCK || pPager->noReadlock );
41431:
41432: if( !pPager->tempFile ){
41433: int isWal; /* True if WAL file exists */
41434: Pgno nPage; /* Size of the database file */
41435:
41436: rc = pagerPagecount(pPager, &nPage);
41437: if( rc ) return rc;
41438: if( nPage==0 ){
41439: rc = sqlite3OsDelete(pPager->pVfs, pPager->zWal, 0);
41440: isWal = 0;
41441: }else{
41442: rc = sqlite3OsAccess(
41443: pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &isWal
41444: );
41445: }
41446: if( rc==SQLITE_OK ){
41447: if( isWal ){
41448: testcase( sqlite3PcachePagecount(pPager->pPCache)==0 );
41449: rc = sqlite3PagerOpenWal(pPager, 0);
41450: }else if( pPager->journalMode==PAGER_JOURNALMODE_WAL ){
41451: pPager->journalMode = PAGER_JOURNALMODE_DELETE;
41452: }
41453: }
41454: }
41455: return rc;
41456: }
41457: #endif
41458:
41459: /*
41460: ** Playback savepoint pSavepoint. Or, if pSavepoint==NULL, then playback
41461: ** the entire master journal file. The case pSavepoint==NULL occurs when
41462: ** a ROLLBACK TO command is invoked on a SAVEPOINT that is a transaction
41463: ** savepoint.
41464: **
41465: ** When pSavepoint is not NULL (meaning a non-transaction savepoint is
41466: ** being rolled back), then the rollback consists of up to three stages,
41467: ** performed in the order specified:
41468: **
41469: ** * Pages are played back from the main journal starting at byte
41470: ** offset PagerSavepoint.iOffset and continuing to
41471: ** PagerSavepoint.iHdrOffset, or to the end of the main journal
41472: ** file if PagerSavepoint.iHdrOffset is zero.
41473: **
41474: ** * If PagerSavepoint.iHdrOffset is not zero, then pages are played
41475: ** back starting from the journal header immediately following
41476: ** PagerSavepoint.iHdrOffset to the end of the main journal file.
41477: **
41478: ** * Pages are then played back from the sub-journal file, starting
41479: ** with the PagerSavepoint.iSubRec and continuing to the end of
41480: ** the journal file.
41481: **
41482: ** Throughout the rollback process, each time a page is rolled back, the
41483: ** corresponding bit is set in a bitvec structure (variable pDone in the
41484: ** implementation below). This is used to ensure that a page is only
41485: ** rolled back the first time it is encountered in either journal.
41486: **
41487: ** If pSavepoint is NULL, then pages are only played back from the main
41488: ** journal file. There is no need for a bitvec in this case.
41489: **
41490: ** In either case, before playback commences the Pager.dbSize variable
41491: ** is reset to the value that it held at the start of the savepoint
41492: ** (or transaction). No page with a page-number greater than this value
41493: ** is played back. If one is encountered it is simply skipped.
41494: */
41495: static int pagerPlaybackSavepoint(Pager *pPager, PagerSavepoint *pSavepoint){
41496: i64 szJ; /* Effective size of the main journal */
41497: i64 iHdrOff; /* End of first segment of main-journal records */
41498: int rc = SQLITE_OK; /* Return code */
41499: Bitvec *pDone = 0; /* Bitvec to ensure pages played back only once */
41500:
41501: assert( pPager->eState!=PAGER_ERROR );
41502: assert( pPager->eState>=PAGER_WRITER_LOCKED );
41503:
41504: /* Allocate a bitvec to use to store the set of pages rolled back */
41505: if( pSavepoint ){
41506: pDone = sqlite3BitvecCreate(pSavepoint->nOrig);
41507: if( !pDone ){
41508: return SQLITE_NOMEM;
41509: }
41510: }
41511:
41512: /* Set the database size back to the value it was before the savepoint
41513: ** being reverted was opened.
41514: */
41515: pPager->dbSize = pSavepoint ? pSavepoint->nOrig : pPager->dbOrigSize;
41516: pPager->changeCountDone = pPager->tempFile;
41517:
41518: if( !pSavepoint && pagerUseWal(pPager) ){
41519: return pagerRollbackWal(pPager);
41520: }
41521:
41522: /* Use pPager->journalOff as the effective size of the main rollback
41523: ** journal. The actual file might be larger than this in
41524: ** PAGER_JOURNALMODE_TRUNCATE or PAGER_JOURNALMODE_PERSIST. But anything
41525: ** past pPager->journalOff is off-limits to us.
41526: */
41527: szJ = pPager->journalOff;
41528: assert( pagerUseWal(pPager)==0 || szJ==0 );
41529:
41530: /* Begin by rolling back records from the main journal starting at
41531: ** PagerSavepoint.iOffset and continuing to the next journal header.
41532: ** There might be records in the main journal that have a page number
41533: ** greater than the current database size (pPager->dbSize) but those
41534: ** will be skipped automatically. Pages are added to pDone as they
41535: ** are played back.
41536: */
41537: if( pSavepoint && !pagerUseWal(pPager) ){
41538: iHdrOff = pSavepoint->iHdrOffset ? pSavepoint->iHdrOffset : szJ;
41539: pPager->journalOff = pSavepoint->iOffset;
41540: while( rc==SQLITE_OK && pPager->journalOff<iHdrOff ){
41541: rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
41542: }
41543: assert( rc!=SQLITE_DONE );
41544: }else{
41545: pPager->journalOff = 0;
41546: }
41547:
41548: /* Continue rolling back records out of the main journal starting at
41549: ** the first journal header seen and continuing until the effective end
41550: ** of the main journal file. Continue to skip out-of-range pages and
41551: ** continue adding pages rolled back to pDone.
41552: */
41553: while( rc==SQLITE_OK && pPager->journalOff<szJ ){
41554: u32 ii; /* Loop counter */
41555: u32 nJRec = 0; /* Number of Journal Records */
41556: u32 dummy;
41557: rc = readJournalHdr(pPager, 0, szJ, &nJRec, &dummy);
41558: assert( rc!=SQLITE_DONE );
41559:
41560: /*
41561: ** The "pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff"
41562: ** test is related to ticket #2565. See the discussion in the
41563: ** pager_playback() function for additional information.
41564: */
41565: if( nJRec==0
41566: && pPager->journalHdr+JOURNAL_HDR_SZ(pPager)==pPager->journalOff
41567: ){
41568: nJRec = (u32)((szJ - pPager->journalOff)/JOURNAL_PG_SZ(pPager));
41569: }
41570: for(ii=0; rc==SQLITE_OK && ii<nJRec && pPager->journalOff<szJ; ii++){
41571: rc = pager_playback_one_page(pPager, &pPager->journalOff, pDone, 1, 1);
41572: }
41573: assert( rc!=SQLITE_DONE );
41574: }
41575: assert( rc!=SQLITE_OK || pPager->journalOff>=szJ );
41576:
41577: /* Finally, rollback pages from the sub-journal. Page that were
41578: ** previously rolled back out of the main journal (and are hence in pDone)
41579: ** will be skipped. Out-of-range pages are also skipped.
41580: */
41581: if( pSavepoint ){
41582: u32 ii; /* Loop counter */
41583: i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
41584:
41585: if( pagerUseWal(pPager) ){
41586: rc = sqlite3WalSavepointUndo(pPager->pWal, pSavepoint->aWalData);
41587: }
41588: for(ii=pSavepoint->iSubRec; rc==SQLITE_OK && ii<pPager->nSubRec; ii++){
41589: assert( offset==(i64)ii*(4+pPager->pageSize) );
41590: rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
41591: }
41592: assert( rc!=SQLITE_DONE );
41593: }
41594:
41595: sqlite3BitvecDestroy(pDone);
41596: if( rc==SQLITE_OK ){
41597: pPager->journalOff = szJ;
41598: }
41599:
41600: return rc;
41601: }
41602:
41603: /*
41604: ** Change the maximum number of in-memory pages that are allowed.
41605: */
41606: SQLITE_PRIVATE void sqlite3PagerSetCachesize(Pager *pPager, int mxPage){
41607: sqlite3PcacheSetCachesize(pPager->pPCache, mxPage);
41608: }
41609:
41610: /*
41611: ** Free as much memory as possible from the pager.
41612: */
41613: SQLITE_PRIVATE void sqlite3PagerShrink(Pager *pPager){
41614: sqlite3PcacheShrink(pPager->pPCache);
41615: }
41616:
41617: /*
41618: ** Adjust the robustness of the database to damage due to OS crashes
41619: ** or power failures by changing the number of syncs()s when writing
41620: ** the rollback journal. There are three levels:
41621: **
41622: ** OFF sqlite3OsSync() is never called. This is the default
41623: ** for temporary and transient files.
41624: **
41625: ** NORMAL The journal is synced once before writes begin on the
41626: ** database. This is normally adequate protection, but
41627: ** it is theoretically possible, though very unlikely,
41628: ** that an inopertune power failure could leave the journal
41629: ** in a state which would cause damage to the database
41630: ** when it is rolled back.
41631: **
41632: ** FULL The journal is synced twice before writes begin on the
41633: ** database (with some additional information - the nRec field
41634: ** of the journal header - being written in between the two
41635: ** syncs). If we assume that writing a
41636: ** single disk sector is atomic, then this mode provides
41637: ** assurance that the journal will not be corrupted to the
41638: ** point of causing damage to the database during rollback.
41639: **
41640: ** The above is for a rollback-journal mode. For WAL mode, OFF continues
41641: ** to mean that no syncs ever occur. NORMAL means that the WAL is synced
41642: ** prior to the start of checkpoint and that the database file is synced
41643: ** at the conclusion of the checkpoint if the entire content of the WAL
41644: ** was written back into the database. But no sync operations occur for
41645: ** an ordinary commit in NORMAL mode with WAL. FULL means that the WAL
41646: ** file is synced following each commit operation, in addition to the
41647: ** syncs associated with NORMAL.
41648: **
41649: ** Do not confuse synchronous=FULL with SQLITE_SYNC_FULL. The
41650: ** SQLITE_SYNC_FULL macro means to use the MacOSX-style full-fsync
41651: ** using fcntl(F_FULLFSYNC). SQLITE_SYNC_NORMAL means to do an
41652: ** ordinary fsync() call. There is no difference between SQLITE_SYNC_FULL
41653: ** and SQLITE_SYNC_NORMAL on platforms other than MacOSX. But the
41654: ** synchronous=FULL versus synchronous=NORMAL setting determines when
41655: ** the xSync primitive is called and is relevant to all platforms.
41656: **
41657: ** Numeric values associated with these states are OFF==1, NORMAL=2,
41658: ** and FULL=3.
41659: */
41660: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
41661: SQLITE_PRIVATE void sqlite3PagerSetSafetyLevel(
41662: Pager *pPager, /* The pager to set safety level for */
41663: int level, /* PRAGMA synchronous. 1=OFF, 2=NORMAL, 3=FULL */
41664: int bFullFsync, /* PRAGMA fullfsync */
41665: int bCkptFullFsync /* PRAGMA checkpoint_fullfsync */
41666: ){
41667: assert( level>=1 && level<=3 );
41668: pPager->noSync = (level==1 || pPager->tempFile) ?1:0;
41669: pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0;
41670: if( pPager->noSync ){
41671: pPager->syncFlags = 0;
41672: pPager->ckptSyncFlags = 0;
41673: }else if( bFullFsync ){
41674: pPager->syncFlags = SQLITE_SYNC_FULL;
41675: pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
41676: }else if( bCkptFullFsync ){
41677: pPager->syncFlags = SQLITE_SYNC_NORMAL;
41678: pPager->ckptSyncFlags = SQLITE_SYNC_FULL;
41679: }else{
41680: pPager->syncFlags = SQLITE_SYNC_NORMAL;
41681: pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
41682: }
41683: pPager->walSyncFlags = pPager->syncFlags;
41684: if( pPager->fullSync ){
41685: pPager->walSyncFlags |= WAL_SYNC_TRANSACTIONS;
41686: }
41687: }
41688: #endif
41689:
41690: /*
41691: ** The following global variable is incremented whenever the library
41692: ** attempts to open a temporary file. This information is used for
41693: ** testing and analysis only.
41694: */
41695: #ifdef SQLITE_TEST
41696: SQLITE_API int sqlite3_opentemp_count = 0;
41697: #endif
41698:
41699: /*
41700: ** Open a temporary file.
41701: **
41702: ** Write the file descriptor into *pFile. Return SQLITE_OK on success
41703: ** or some other error code if we fail. The OS will automatically
41704: ** delete the temporary file when it is closed.
41705: **
41706: ** The flags passed to the VFS layer xOpen() call are those specified
41707: ** by parameter vfsFlags ORed with the following:
41708: **
41709: ** SQLITE_OPEN_READWRITE
41710: ** SQLITE_OPEN_CREATE
41711: ** SQLITE_OPEN_EXCLUSIVE
41712: ** SQLITE_OPEN_DELETEONCLOSE
41713: */
41714: static int pagerOpentemp(
41715: Pager *pPager, /* The pager object */
41716: sqlite3_file *pFile, /* Write the file descriptor here */
41717: int vfsFlags /* Flags passed through to the VFS */
41718: ){
41719: int rc; /* Return code */
41720:
41721: #ifdef SQLITE_TEST
41722: sqlite3_opentemp_count++; /* Used for testing and analysis only */
41723: #endif
41724:
41725: vfsFlags |= SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
41726: SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE;
41727: rc = sqlite3OsOpen(pPager->pVfs, 0, pFile, vfsFlags, 0);
41728: assert( rc!=SQLITE_OK || isOpen(pFile) );
41729: return rc;
41730: }
41731:
41732: /*
41733: ** Set the busy handler function.
41734: **
41735: ** The pager invokes the busy-handler if sqlite3OsLock() returns
41736: ** SQLITE_BUSY when trying to upgrade from no-lock to a SHARED lock,
41737: ** or when trying to upgrade from a RESERVED lock to an EXCLUSIVE
41738: ** lock. It does *not* invoke the busy handler when upgrading from
41739: ** SHARED to RESERVED, or when upgrading from SHARED to EXCLUSIVE
41740: ** (which occurs during hot-journal rollback). Summary:
41741: **
41742: ** Transition | Invokes xBusyHandler
41743: ** --------------------------------------------------------
41744: ** NO_LOCK -> SHARED_LOCK | Yes
41745: ** SHARED_LOCK -> RESERVED_LOCK | No
41746: ** SHARED_LOCK -> EXCLUSIVE_LOCK | No
41747: ** RESERVED_LOCK -> EXCLUSIVE_LOCK | Yes
41748: **
41749: ** If the busy-handler callback returns non-zero, the lock is
41750: ** retried. If it returns zero, then the SQLITE_BUSY error is
41751: ** returned to the caller of the pager API function.
41752: */
41753: SQLITE_PRIVATE void sqlite3PagerSetBusyhandler(
41754: Pager *pPager, /* Pager object */
41755: int (*xBusyHandler)(void *), /* Pointer to busy-handler function */
41756: void *pBusyHandlerArg /* Argument to pass to xBusyHandler */
41757: ){
41758: pPager->xBusyHandler = xBusyHandler;
41759: pPager->pBusyHandlerArg = pBusyHandlerArg;
41760: }
41761:
41762: /*
41763: ** Change the page size used by the Pager object. The new page size
41764: ** is passed in *pPageSize.
41765: **
41766: ** If the pager is in the error state when this function is called, it
41767: ** is a no-op. The value returned is the error state error code (i.e.
41768: ** one of SQLITE_IOERR, an SQLITE_IOERR_xxx sub-code or SQLITE_FULL).
41769: **
41770: ** Otherwise, if all of the following are true:
41771: **
41772: ** * the new page size (value of *pPageSize) is valid (a power
41773: ** of two between 512 and SQLITE_MAX_PAGE_SIZE, inclusive), and
41774: **
41775: ** * there are no outstanding page references, and
41776: **
41777: ** * the database is either not an in-memory database or it is
41778: ** an in-memory database that currently consists of zero pages.
41779: **
41780: ** then the pager object page size is set to *pPageSize.
41781: **
41782: ** If the page size is changed, then this function uses sqlite3PagerMalloc()
41783: ** to obtain a new Pager.pTmpSpace buffer. If this allocation attempt
41784: ** fails, SQLITE_NOMEM is returned and the page size remains unchanged.
41785: ** In all other cases, SQLITE_OK is returned.
41786: **
41787: ** If the page size is not changed, either because one of the enumerated
41788: ** conditions above is not true, the pager was in error state when this
41789: ** function was called, or because the memory allocation attempt failed,
41790: ** then *pPageSize is set to the old, retained page size before returning.
41791: */
41792: SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nReserve){
41793: int rc = SQLITE_OK;
41794:
41795: /* It is not possible to do a full assert_pager_state() here, as this
41796: ** function may be called from within PagerOpen(), before the state
41797: ** of the Pager object is internally consistent.
41798: **
41799: ** At one point this function returned an error if the pager was in
41800: ** PAGER_ERROR state. But since PAGER_ERROR state guarantees that
41801: ** there is at least one outstanding page reference, this function
41802: ** is a no-op for that case anyhow.
41803: */
41804:
41805: u32 pageSize = *pPageSize;
41806: assert( pageSize==0 || (pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE) );
41807: if( (pPager->memDb==0 || pPager->dbSize==0)
41808: && sqlite3PcacheRefCount(pPager->pPCache)==0
41809: && pageSize && pageSize!=(u32)pPager->pageSize
41810: ){
41811: char *pNew = NULL; /* New temp space */
41812: i64 nByte = 0;
41813:
41814: if( pPager->eState>PAGER_OPEN && isOpen(pPager->fd) ){
41815: rc = sqlite3OsFileSize(pPager->fd, &nByte);
41816: }
41817: if( rc==SQLITE_OK ){
41818: pNew = (char *)sqlite3PageMalloc(pageSize);
41819: if( !pNew ) rc = SQLITE_NOMEM;
41820: }
41821:
41822: if( rc==SQLITE_OK ){
41823: pager_reset(pPager);
41824: pPager->dbSize = (Pgno)((nByte+pageSize-1)/pageSize);
41825: pPager->pageSize = pageSize;
41826: sqlite3PageFree(pPager->pTmpSpace);
41827: pPager->pTmpSpace = pNew;
41828: sqlite3PcacheSetPageSize(pPager->pPCache, pageSize);
41829: }
41830: }
41831:
41832: *pPageSize = pPager->pageSize;
41833: if( rc==SQLITE_OK ){
41834: if( nReserve<0 ) nReserve = pPager->nReserve;
41835: assert( nReserve>=0 && nReserve<1000 );
41836: pPager->nReserve = (i16)nReserve;
41837: pagerReportSize(pPager);
41838: }
41839: return rc;
41840: }
41841:
41842: /*
41843: ** Return a pointer to the "temporary page" buffer held internally
41844: ** by the pager. This is a buffer that is big enough to hold the
41845: ** entire content of a database page. This buffer is used internally
41846: ** during rollback and will be overwritten whenever a rollback
41847: ** occurs. But other modules are free to use it too, as long as
41848: ** no rollbacks are happening.
41849: */
41850: SQLITE_PRIVATE void *sqlite3PagerTempSpace(Pager *pPager){
41851: return pPager->pTmpSpace;
41852: }
41853:
41854: /*
41855: ** Attempt to set the maximum database page count if mxPage is positive.
41856: ** Make no changes if mxPage is zero or negative. And never reduce the
41857: ** maximum page count below the current size of the database.
41858: **
41859: ** Regardless of mxPage, return the current maximum page count.
41860: */
41861: SQLITE_PRIVATE int sqlite3PagerMaxPageCount(Pager *pPager, int mxPage){
41862: if( mxPage>0 ){
41863: pPager->mxPgno = mxPage;
41864: }
41865: assert( pPager->eState!=PAGER_OPEN ); /* Called only by OP_MaxPgcnt */
41866: assert( pPager->mxPgno>=pPager->dbSize ); /* OP_MaxPgcnt enforces this */
41867: return pPager->mxPgno;
41868: }
41869:
41870: /*
41871: ** The following set of routines are used to disable the simulated
41872: ** I/O error mechanism. These routines are used to avoid simulated
41873: ** errors in places where we do not care about errors.
41874: **
41875: ** Unless -DSQLITE_TEST=1 is used, these routines are all no-ops
41876: ** and generate no code.
41877: */
41878: #ifdef SQLITE_TEST
41879: SQLITE_API extern int sqlite3_io_error_pending;
41880: SQLITE_API extern int sqlite3_io_error_hit;
41881: static int saved_cnt;
41882: void disable_simulated_io_errors(void){
41883: saved_cnt = sqlite3_io_error_pending;
41884: sqlite3_io_error_pending = -1;
41885: }
41886: void enable_simulated_io_errors(void){
41887: sqlite3_io_error_pending = saved_cnt;
41888: }
41889: #else
41890: # define disable_simulated_io_errors()
41891: # define enable_simulated_io_errors()
41892: #endif
41893:
41894: /*
41895: ** Read the first N bytes from the beginning of the file into memory
41896: ** that pDest points to.
41897: **
41898: ** If the pager was opened on a transient file (zFilename==""), or
41899: ** opened on a file less than N bytes in size, the output buffer is
41900: ** zeroed and SQLITE_OK returned. The rationale for this is that this
41901: ** function is used to read database headers, and a new transient or
41902: ** zero sized database has a header than consists entirely of zeroes.
41903: **
41904: ** If any IO error apart from SQLITE_IOERR_SHORT_READ is encountered,
41905: ** the error code is returned to the caller and the contents of the
41906: ** output buffer undefined.
41907: */
41908: SQLITE_PRIVATE int sqlite3PagerReadFileheader(Pager *pPager, int N, unsigned char *pDest){
41909: int rc = SQLITE_OK;
41910: memset(pDest, 0, N);
41911: assert( isOpen(pPager->fd) || pPager->tempFile );
41912:
41913: /* This routine is only called by btree immediately after creating
41914: ** the Pager object. There has not been an opportunity to transition
41915: ** to WAL mode yet.
41916: */
41917: assert( !pagerUseWal(pPager) );
41918:
41919: if( isOpen(pPager->fd) ){
41920: IOTRACE(("DBHDR %p 0 %d\n", pPager, N))
41921: rc = sqlite3OsRead(pPager->fd, pDest, N, 0);
41922: if( rc==SQLITE_IOERR_SHORT_READ ){
41923: rc = SQLITE_OK;
41924: }
41925: }
41926: return rc;
41927: }
41928:
41929: /*
41930: ** This function may only be called when a read-transaction is open on
41931: ** the pager. It returns the total number of pages in the database.
41932: **
41933: ** However, if the file is between 1 and <page-size> bytes in size, then
41934: ** this is considered a 1 page file.
41935: */
41936: SQLITE_PRIVATE void sqlite3PagerPagecount(Pager *pPager, int *pnPage){
41937: assert( pPager->eState>=PAGER_READER );
41938: assert( pPager->eState!=PAGER_WRITER_FINISHED );
41939: *pnPage = (int)pPager->dbSize;
41940: }
41941:
41942:
41943: /*
41944: ** Try to obtain a lock of type locktype on the database file. If
41945: ** a similar or greater lock is already held, this function is a no-op
41946: ** (returning SQLITE_OK immediately).
41947: **
41948: ** Otherwise, attempt to obtain the lock using sqlite3OsLock(). Invoke
41949: ** the busy callback if the lock is currently not available. Repeat
41950: ** until the busy callback returns false or until the attempt to
41951: ** obtain the lock succeeds.
41952: **
41953: ** Return SQLITE_OK on success and an error code if we cannot obtain
41954: ** the lock. If the lock is obtained successfully, set the Pager.state
41955: ** variable to locktype before returning.
41956: */
41957: static int pager_wait_on_lock(Pager *pPager, int locktype){
41958: int rc; /* Return code */
41959:
41960: /* Check that this is either a no-op (because the requested lock is
41961: ** already held, or one of the transistions that the busy-handler
41962: ** may be invoked during, according to the comment above
41963: ** sqlite3PagerSetBusyhandler().
41964: */
41965: assert( (pPager->eLock>=locktype)
41966: || (pPager->eLock==NO_LOCK && locktype==SHARED_LOCK)
41967: || (pPager->eLock==RESERVED_LOCK && locktype==EXCLUSIVE_LOCK)
41968: );
41969:
41970: do {
41971: rc = pagerLockDb(pPager, locktype);
41972: }while( rc==SQLITE_BUSY && pPager->xBusyHandler(pPager->pBusyHandlerArg) );
41973: return rc;
41974: }
41975:
41976: /*
41977: ** Function assertTruncateConstraint(pPager) checks that one of the
41978: ** following is true for all dirty pages currently in the page-cache:
41979: **
41980: ** a) The page number is less than or equal to the size of the
41981: ** current database image, in pages, OR
41982: **
41983: ** b) if the page content were written at this time, it would not
41984: ** be necessary to write the current content out to the sub-journal
41985: ** (as determined by function subjRequiresPage()).
41986: **
41987: ** If the condition asserted by this function were not true, and the
41988: ** dirty page were to be discarded from the cache via the pagerStress()
41989: ** routine, pagerStress() would not write the current page content to
41990: ** the database file. If a savepoint transaction were rolled back after
41991: ** this happened, the correct behaviour would be to restore the current
41992: ** content of the page. However, since this content is not present in either
41993: ** the database file or the portion of the rollback journal and
41994: ** sub-journal rolled back the content could not be restored and the
41995: ** database image would become corrupt. It is therefore fortunate that
41996: ** this circumstance cannot arise.
41997: */
41998: #if defined(SQLITE_DEBUG)
41999: static void assertTruncateConstraintCb(PgHdr *pPg){
42000: assert( pPg->flags&PGHDR_DIRTY );
42001: assert( !subjRequiresPage(pPg) || pPg->pgno<=pPg->pPager->dbSize );
42002: }
42003: static void assertTruncateConstraint(Pager *pPager){
42004: sqlite3PcacheIterateDirty(pPager->pPCache, assertTruncateConstraintCb);
42005: }
42006: #else
42007: # define assertTruncateConstraint(pPager)
42008: #endif
42009:
42010: /*
42011: ** Truncate the in-memory database file image to nPage pages. This
42012: ** function does not actually modify the database file on disk. It
42013: ** just sets the internal state of the pager object so that the
42014: ** truncation will be done when the current transaction is committed.
42015: */
42016: SQLITE_PRIVATE void sqlite3PagerTruncateImage(Pager *pPager, Pgno nPage){
42017: assert( pPager->dbSize>=nPage );
42018: assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
42019: pPager->dbSize = nPage;
42020: assertTruncateConstraint(pPager);
42021: }
42022:
42023:
42024: /*
42025: ** This function is called before attempting a hot-journal rollback. It
42026: ** syncs the journal file to disk, then sets pPager->journalHdr to the
42027: ** size of the journal file so that the pager_playback() routine knows
42028: ** that the entire journal file has been synced.
42029: **
42030: ** Syncing a hot-journal to disk before attempting to roll it back ensures
42031: ** that if a power-failure occurs during the rollback, the process that
42032: ** attempts rollback following system recovery sees the same journal
42033: ** content as this process.
42034: **
42035: ** If everything goes as planned, SQLITE_OK is returned. Otherwise,
42036: ** an SQLite error code.
42037: */
42038: static int pagerSyncHotJournal(Pager *pPager){
42039: int rc = SQLITE_OK;
42040: if( !pPager->noSync ){
42041: rc = sqlite3OsSync(pPager->jfd, SQLITE_SYNC_NORMAL);
42042: }
42043: if( rc==SQLITE_OK ){
42044: rc = sqlite3OsFileSize(pPager->jfd, &pPager->journalHdr);
42045: }
42046: return rc;
42047: }
42048:
42049: /*
42050: ** Shutdown the page cache. Free all memory and close all files.
42051: **
42052: ** If a transaction was in progress when this routine is called, that
42053: ** transaction is rolled back. All outstanding pages are invalidated
42054: ** and their memory is freed. Any attempt to use a page associated
42055: ** with this page cache after this function returns will likely
42056: ** result in a coredump.
42057: **
42058: ** This function always succeeds. If a transaction is active an attempt
42059: ** is made to roll it back. If an error occurs during the rollback
42060: ** a hot journal may be left in the filesystem but no error is returned
42061: ** to the caller.
42062: */
42063: SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager){
42064: u8 *pTmp = (u8 *)pPager->pTmpSpace;
42065:
42066: assert( assert_pager_state(pPager) );
42067: disable_simulated_io_errors();
42068: sqlite3BeginBenignMalloc();
42069: /* pPager->errCode = 0; */
42070: pPager->exclusiveMode = 0;
42071: #ifndef SQLITE_OMIT_WAL
42072: sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags, pPager->pageSize, pTmp);
42073: pPager->pWal = 0;
42074: #endif
42075: pager_reset(pPager);
42076: if( MEMDB ){
42077: pager_unlock(pPager);
42078: }else{
42079: /* If it is open, sync the journal file before calling UnlockAndRollback.
42080: ** If this is not done, then an unsynced portion of the open journal
42081: ** file may be played back into the database. If a power failure occurs
42082: ** while this is happening, the database could become corrupt.
42083: **
42084: ** If an error occurs while trying to sync the journal, shift the pager
42085: ** into the ERROR state. This causes UnlockAndRollback to unlock the
42086: ** database and close the journal file without attempting to roll it
42087: ** back or finalize it. The next database user will have to do hot-journal
42088: ** rollback before accessing the database file.
42089: */
42090: if( isOpen(pPager->jfd) ){
42091: pager_error(pPager, pagerSyncHotJournal(pPager));
42092: }
42093: pagerUnlockAndRollback(pPager);
42094: }
42095: sqlite3EndBenignMalloc();
42096: enable_simulated_io_errors();
42097: PAGERTRACE(("CLOSE %d\n", PAGERID(pPager)));
42098: IOTRACE(("CLOSE %p\n", pPager))
42099: sqlite3OsClose(pPager->jfd);
42100: sqlite3OsClose(pPager->fd);
42101: sqlite3PageFree(pTmp);
42102: sqlite3PcacheClose(pPager->pPCache);
42103:
42104: #ifdef SQLITE_HAS_CODEC
42105: if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
42106: #endif
42107:
42108: assert( !pPager->aSavepoint && !pPager->pInJournal );
42109: assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );
42110:
42111: sqlite3_free(pPager);
42112: return SQLITE_OK;
42113: }
42114:
42115: #if !defined(NDEBUG) || defined(SQLITE_TEST)
42116: /*
42117: ** Return the page number for page pPg.
42118: */
42119: SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage *pPg){
42120: return pPg->pgno;
42121: }
42122: #endif
42123:
42124: /*
42125: ** Increment the reference count for page pPg.
42126: */
42127: SQLITE_PRIVATE void sqlite3PagerRef(DbPage *pPg){
42128: sqlite3PcacheRef(pPg);
42129: }
42130:
42131: /*
42132: ** Sync the journal. In other words, make sure all the pages that have
42133: ** been written to the journal have actually reached the surface of the
42134: ** disk and can be restored in the event of a hot-journal rollback.
42135: **
42136: ** If the Pager.noSync flag is set, then this function is a no-op.
42137: ** Otherwise, the actions required depend on the journal-mode and the
42138: ** device characteristics of the the file-system, as follows:
42139: **
42140: ** * If the journal file is an in-memory journal file, no action need
42141: ** be taken.
42142: **
42143: ** * Otherwise, if the device does not support the SAFE_APPEND property,
42144: ** then the nRec field of the most recently written journal header
42145: ** is updated to contain the number of journal records that have
42146: ** been written following it. If the pager is operating in full-sync
42147: ** mode, then the journal file is synced before this field is updated.
42148: **
42149: ** * If the device does not support the SEQUENTIAL property, then
42150: ** journal file is synced.
42151: **
42152: ** Or, in pseudo-code:
42153: **
42154: ** if( NOT <in-memory journal> ){
42155: ** if( NOT SAFE_APPEND ){
42156: ** if( <full-sync mode> ) xSync(<journal file>);
42157: ** <update nRec field>
42158: ** }
42159: ** if( NOT SEQUENTIAL ) xSync(<journal file>);
42160: ** }
42161: **
42162: ** If successful, this routine clears the PGHDR_NEED_SYNC flag of every
42163: ** page currently held in memory before returning SQLITE_OK. If an IO
42164: ** error is encountered, then the IO error code is returned to the caller.
42165: */
42166: static int syncJournal(Pager *pPager, int newHdr){
42167: int rc; /* Return code */
42168:
42169: assert( pPager->eState==PAGER_WRITER_CACHEMOD
42170: || pPager->eState==PAGER_WRITER_DBMOD
42171: );
42172: assert( assert_pager_state(pPager) );
42173: assert( !pagerUseWal(pPager) );
42174:
42175: rc = sqlite3PagerExclusiveLock(pPager);
42176: if( rc!=SQLITE_OK ) return rc;
42177:
42178: if( !pPager->noSync ){
42179: assert( !pPager->tempFile );
42180: if( isOpen(pPager->jfd) && pPager->journalMode!=PAGER_JOURNALMODE_MEMORY ){
42181: const int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
42182: assert( isOpen(pPager->jfd) );
42183:
42184: if( 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
42185: /* This block deals with an obscure problem. If the last connection
42186: ** that wrote to this database was operating in persistent-journal
42187: ** mode, then the journal file may at this point actually be larger
42188: ** than Pager.journalOff bytes. If the next thing in the journal
42189: ** file happens to be a journal-header (written as part of the
42190: ** previous connection's transaction), and a crash or power-failure
42191: ** occurs after nRec is updated but before this connection writes
42192: ** anything else to the journal file (or commits/rolls back its
42193: ** transaction), then SQLite may become confused when doing the
42194: ** hot-journal rollback following recovery. It may roll back all
42195: ** of this connections data, then proceed to rolling back the old,
42196: ** out-of-date data that follows it. Database corruption.
42197: **
42198: ** To work around this, if the journal file does appear to contain
42199: ** a valid header following Pager.journalOff, then write a 0x00
42200: ** byte to the start of it to prevent it from being recognized.
42201: **
42202: ** Variable iNextHdrOffset is set to the offset at which this
42203: ** problematic header will occur, if it exists. aMagic is used
42204: ** as a temporary buffer to inspect the first couple of bytes of
42205: ** the potential journal header.
42206: */
42207: i64 iNextHdrOffset;
42208: u8 aMagic[8];
42209: u8 zHeader[sizeof(aJournalMagic)+4];
42210:
42211: memcpy(zHeader, aJournalMagic, sizeof(aJournalMagic));
42212: put32bits(&zHeader[sizeof(aJournalMagic)], pPager->nRec);
42213:
42214: iNextHdrOffset = journalHdrOffset(pPager);
42215: rc = sqlite3OsRead(pPager->jfd, aMagic, 8, iNextHdrOffset);
42216: if( rc==SQLITE_OK && 0==memcmp(aMagic, aJournalMagic, 8) ){
42217: static const u8 zerobyte = 0;
42218: rc = sqlite3OsWrite(pPager->jfd, &zerobyte, 1, iNextHdrOffset);
42219: }
42220: if( rc!=SQLITE_OK && rc!=SQLITE_IOERR_SHORT_READ ){
42221: return rc;
42222: }
42223:
42224: /* Write the nRec value into the journal file header. If in
42225: ** full-synchronous mode, sync the journal first. This ensures that
42226: ** all data has really hit the disk before nRec is updated to mark
42227: ** it as a candidate for rollback.
42228: **
42229: ** This is not required if the persistent media supports the
42230: ** SAFE_APPEND property. Because in this case it is not possible
42231: ** for garbage data to be appended to the file, the nRec field
42232: ** is populated with 0xFFFFFFFF when the journal header is written
42233: ** and never needs to be updated.
42234: */
42235: if( pPager->fullSync && 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
42236: PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
42237: IOTRACE(("JSYNC %p\n", pPager))
42238: rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags);
42239: if( rc!=SQLITE_OK ) return rc;
42240: }
42241: IOTRACE(("JHDR %p %lld\n", pPager, pPager->journalHdr));
42242: rc = sqlite3OsWrite(
42243: pPager->jfd, zHeader, sizeof(zHeader), pPager->journalHdr
42244: );
42245: if( rc!=SQLITE_OK ) return rc;
42246: }
42247: if( 0==(iDc&SQLITE_IOCAP_SEQUENTIAL) ){
42248: PAGERTRACE(("SYNC journal of %d\n", PAGERID(pPager)));
42249: IOTRACE(("JSYNC %p\n", pPager))
42250: rc = sqlite3OsSync(pPager->jfd, pPager->syncFlags|
42251: (pPager->syncFlags==SQLITE_SYNC_FULL?SQLITE_SYNC_DATAONLY:0)
42252: );
42253: if( rc!=SQLITE_OK ) return rc;
42254: }
42255:
42256: pPager->journalHdr = pPager->journalOff;
42257: if( newHdr && 0==(iDc&SQLITE_IOCAP_SAFE_APPEND) ){
42258: pPager->nRec = 0;
42259: rc = writeJournalHdr(pPager);
42260: if( rc!=SQLITE_OK ) return rc;
42261: }
42262: }else{
42263: pPager->journalHdr = pPager->journalOff;
42264: }
42265: }
42266:
42267: /* Unless the pager is in noSync mode, the journal file was just
42268: ** successfully synced. Either way, clear the PGHDR_NEED_SYNC flag on
42269: ** all pages.
42270: */
42271: sqlite3PcacheClearSyncFlags(pPager->pPCache);
42272: pPager->eState = PAGER_WRITER_DBMOD;
42273: assert( assert_pager_state(pPager) );
42274: return SQLITE_OK;
42275: }
42276:
42277: /*
42278: ** The argument is the first in a linked list of dirty pages connected
42279: ** by the PgHdr.pDirty pointer. This function writes each one of the
42280: ** in-memory pages in the list to the database file. The argument may
42281: ** be NULL, representing an empty list. In this case this function is
42282: ** a no-op.
42283: **
42284: ** The pager must hold at least a RESERVED lock when this function
42285: ** is called. Before writing anything to the database file, this lock
42286: ** is upgraded to an EXCLUSIVE lock. If the lock cannot be obtained,
42287: ** SQLITE_BUSY is returned and no data is written to the database file.
42288: **
42289: ** If the pager is a temp-file pager and the actual file-system file
42290: ** is not yet open, it is created and opened before any data is
42291: ** written out.
42292: **
42293: ** Once the lock has been upgraded and, if necessary, the file opened,
42294: ** the pages are written out to the database file in list order. Writing
42295: ** a page is skipped if it meets either of the following criteria:
42296: **
42297: ** * The page number is greater than Pager.dbSize, or
42298: ** * The PGHDR_DONT_WRITE flag is set on the page.
42299: **
42300: ** If writing out a page causes the database file to grow, Pager.dbFileSize
42301: ** is updated accordingly. If page 1 is written out, then the value cached
42302: ** in Pager.dbFileVers[] is updated to match the new value stored in
42303: ** the database file.
42304: **
42305: ** If everything is successful, SQLITE_OK is returned. If an IO error
42306: ** occurs, an IO error code is returned. Or, if the EXCLUSIVE lock cannot
42307: ** be obtained, SQLITE_BUSY is returned.
42308: */
42309: static int pager_write_pagelist(Pager *pPager, PgHdr *pList){
42310: int rc = SQLITE_OK; /* Return code */
42311:
42312: /* This function is only called for rollback pagers in WRITER_DBMOD state. */
42313: assert( !pagerUseWal(pPager) );
42314: assert( pPager->eState==PAGER_WRITER_DBMOD );
42315: assert( pPager->eLock==EXCLUSIVE_LOCK );
42316:
42317: /* If the file is a temp-file has not yet been opened, open it now. It
42318: ** is not possible for rc to be other than SQLITE_OK if this branch
42319: ** is taken, as pager_wait_on_lock() is a no-op for temp-files.
42320: */
42321: if( !isOpen(pPager->fd) ){
42322: assert( pPager->tempFile && rc==SQLITE_OK );
42323: rc = pagerOpentemp(pPager, pPager->fd, pPager->vfsFlags);
42324: }
42325:
42326: /* Before the first write, give the VFS a hint of what the final
42327: ** file size will be.
42328: */
42329: assert( rc!=SQLITE_OK || isOpen(pPager->fd) );
42330: if( rc==SQLITE_OK && pPager->dbSize>pPager->dbHintSize ){
42331: sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize;
42332: sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile);
42333: pPager->dbHintSize = pPager->dbSize;
42334: }
42335:
42336: while( rc==SQLITE_OK && pList ){
42337: Pgno pgno = pList->pgno;
42338:
42339: /* If there are dirty pages in the page cache with page numbers greater
42340: ** than Pager.dbSize, this means sqlite3PagerTruncateImage() was called to
42341: ** make the file smaller (presumably by auto-vacuum code). Do not write
42342: ** any such pages to the file.
42343: **
42344: ** Also, do not write out any page that has the PGHDR_DONT_WRITE flag
42345: ** set (set by sqlite3PagerDontWrite()).
42346: */
42347: if( pgno<=pPager->dbSize && 0==(pList->flags&PGHDR_DONT_WRITE) ){
42348: i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
42349: char *pData; /* Data to write */
42350:
42351: assert( (pList->flags&PGHDR_NEED_SYNC)==0 );
42352: if( pList->pgno==1 ) pager_write_changecounter(pList);
42353:
42354: /* Encode the database */
42355: CODEC2(pPager, pList->pData, pgno, 6, return SQLITE_NOMEM, pData);
42356:
42357: /* Write out the page data. */
42358: rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
42359:
42360: /* If page 1 was just written, update Pager.dbFileVers to match
42361: ** the value now stored in the database file. If writing this
42362: ** page caused the database file to grow, update dbFileSize.
42363: */
42364: if( pgno==1 ){
42365: memcpy(&pPager->dbFileVers, &pData[24], sizeof(pPager->dbFileVers));
42366: }
42367: if( pgno>pPager->dbFileSize ){
42368: pPager->dbFileSize = pgno;
42369: }
42370:
42371: /* Update any backup objects copying the contents of this pager. */
42372: sqlite3BackupUpdate(pPager->pBackup, pgno, (u8*)pList->pData);
42373:
42374: PAGERTRACE(("STORE %d page %d hash(%08x)\n",
42375: PAGERID(pPager), pgno, pager_pagehash(pList)));
42376: IOTRACE(("PGOUT %p %d\n", pPager, pgno));
42377: PAGER_INCR(sqlite3_pager_writedb_count);
42378: PAGER_INCR(pPager->nWrite);
42379: }else{
42380: PAGERTRACE(("NOSTORE %d page %d\n", PAGERID(pPager), pgno));
42381: }
42382: pager_set_pagehash(pList);
42383: pList = pList->pDirty;
42384: }
42385:
42386: return rc;
42387: }
42388:
42389: /*
42390: ** Ensure that the sub-journal file is open. If it is already open, this
42391: ** function is a no-op.
42392: **
42393: ** SQLITE_OK is returned if everything goes according to plan. An
42394: ** SQLITE_IOERR_XXX error code is returned if a call to sqlite3OsOpen()
42395: ** fails.
42396: */
42397: static int openSubJournal(Pager *pPager){
42398: int rc = SQLITE_OK;
42399: if( !isOpen(pPager->sjfd) ){
42400: if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY || pPager->subjInMemory ){
42401: sqlite3MemJournalOpen(pPager->sjfd);
42402: }else{
42403: rc = pagerOpentemp(pPager, pPager->sjfd, SQLITE_OPEN_SUBJOURNAL);
42404: }
42405: }
42406: return rc;
42407: }
42408:
42409: /*
42410: ** Append a record of the current state of page pPg to the sub-journal.
42411: ** It is the callers responsibility to use subjRequiresPage() to check
42412: ** that it is really required before calling this function.
42413: **
42414: ** If successful, set the bit corresponding to pPg->pgno in the bitvecs
42415: ** for all open savepoints before returning.
42416: **
42417: ** This function returns SQLITE_OK if everything is successful, an IO
42418: ** error code if the attempt to write to the sub-journal fails, or
42419: ** SQLITE_NOMEM if a malloc fails while setting a bit in a savepoint
42420: ** bitvec.
42421: */
42422: static int subjournalPage(PgHdr *pPg){
42423: int rc = SQLITE_OK;
42424: Pager *pPager = pPg->pPager;
42425: if( pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
42426:
42427: /* Open the sub-journal, if it has not already been opened */
42428: assert( pPager->useJournal );
42429: assert( isOpen(pPager->jfd) || pagerUseWal(pPager) );
42430: assert( isOpen(pPager->sjfd) || pPager->nSubRec==0 );
42431: assert( pagerUseWal(pPager)
42432: || pageInJournal(pPg)
42433: || pPg->pgno>pPager->dbOrigSize
42434: );
42435: rc = openSubJournal(pPager);
42436:
42437: /* If the sub-journal was opened successfully (or was already open),
42438: ** write the journal record into the file. */
42439: if( rc==SQLITE_OK ){
42440: void *pData = pPg->pData;
42441: i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
42442: char *pData2;
42443:
42444: CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
42445: PAGERTRACE(("STMT-JOURNAL %d page %d\n", PAGERID(pPager), pPg->pgno));
42446: rc = write32bits(pPager->sjfd, offset, pPg->pgno);
42447: if( rc==SQLITE_OK ){
42448: rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
42449: }
42450: }
42451: }
42452: if( rc==SQLITE_OK ){
42453: pPager->nSubRec++;
42454: assert( pPager->nSavepoint>0 );
42455: rc = addToSavepointBitvecs(pPager, pPg->pgno);
42456: }
42457: return rc;
42458: }
42459:
42460: /*
42461: ** This function is called by the pcache layer when it has reached some
42462: ** soft memory limit. The first argument is a pointer to a Pager object
42463: ** (cast as a void*). The pager is always 'purgeable' (not an in-memory
42464: ** database). The second argument is a reference to a page that is
42465: ** currently dirty but has no outstanding references. The page
42466: ** is always associated with the Pager object passed as the first
42467: ** argument.
42468: **
42469: ** The job of this function is to make pPg clean by writing its contents
42470: ** out to the database file, if possible. This may involve syncing the
42471: ** journal file.
42472: **
42473: ** If successful, sqlite3PcacheMakeClean() is called on the page and
42474: ** SQLITE_OK returned. If an IO error occurs while trying to make the
42475: ** page clean, the IO error code is returned. If the page cannot be
42476: ** made clean for some other reason, but no error occurs, then SQLITE_OK
42477: ** is returned by sqlite3PcacheMakeClean() is not called.
42478: */
42479: static int pagerStress(void *p, PgHdr *pPg){
42480: Pager *pPager = (Pager *)p;
42481: int rc = SQLITE_OK;
42482:
42483: assert( pPg->pPager==pPager );
42484: assert( pPg->flags&PGHDR_DIRTY );
42485:
42486: /* The doNotSyncSpill flag is set during times when doing a sync of
42487: ** journal (and adding a new header) is not allowed. This occurs
42488: ** during calls to sqlite3PagerWrite() while trying to journal multiple
42489: ** pages belonging to the same sector.
42490: **
42491: ** The doNotSpill flag inhibits all cache spilling regardless of whether
42492: ** or not a sync is required. This is set during a rollback.
42493: **
42494: ** Spilling is also prohibited when in an error state since that could
42495: ** lead to database corruption. In the current implementaton it
42496: ** is impossible for sqlite3PcacheFetch() to be called with createFlag==1
42497: ** while in the error state, hence it is impossible for this routine to
42498: ** be called in the error state. Nevertheless, we include a NEVER()
42499: ** test for the error state as a safeguard against future changes.
42500: */
42501: if( NEVER(pPager->errCode) ) return SQLITE_OK;
42502: if( pPager->doNotSpill ) return SQLITE_OK;
42503: if( pPager->doNotSyncSpill && (pPg->flags & PGHDR_NEED_SYNC)!=0 ){
42504: return SQLITE_OK;
42505: }
42506:
42507: pPg->pDirty = 0;
42508: if( pagerUseWal(pPager) ){
42509: /* Write a single frame for this page to the log. */
42510: if( subjRequiresPage(pPg) ){
42511: rc = subjournalPage(pPg);
42512: }
42513: if( rc==SQLITE_OK ){
42514: rc = pagerWalFrames(pPager, pPg, 0, 0);
42515: }
42516: }else{
42517:
42518: /* Sync the journal file if required. */
42519: if( pPg->flags&PGHDR_NEED_SYNC
42520: || pPager->eState==PAGER_WRITER_CACHEMOD
42521: ){
42522: rc = syncJournal(pPager, 1);
42523: }
42524:
42525: /* If the page number of this page is larger than the current size of
42526: ** the database image, it may need to be written to the sub-journal.
42527: ** This is because the call to pager_write_pagelist() below will not
42528: ** actually write data to the file in this case.
42529: **
42530: ** Consider the following sequence of events:
42531: **
42532: ** BEGIN;
42533: ** <journal page X>
42534: ** <modify page X>
42535: ** SAVEPOINT sp;
42536: ** <shrink database file to Y pages>
42537: ** pagerStress(page X)
42538: ** ROLLBACK TO sp;
42539: **
42540: ** If (X>Y), then when pagerStress is called page X will not be written
42541: ** out to the database file, but will be dropped from the cache. Then,
42542: ** following the "ROLLBACK TO sp" statement, reading page X will read
42543: ** data from the database file. This will be the copy of page X as it
42544: ** was when the transaction started, not as it was when "SAVEPOINT sp"
42545: ** was executed.
42546: **
42547: ** The solution is to write the current data for page X into the
42548: ** sub-journal file now (if it is not already there), so that it will
42549: ** be restored to its current value when the "ROLLBACK TO sp" is
42550: ** executed.
42551: */
42552: if( NEVER(
42553: rc==SQLITE_OK && pPg->pgno>pPager->dbSize && subjRequiresPage(pPg)
42554: ) ){
42555: rc = subjournalPage(pPg);
42556: }
42557:
42558: /* Write the contents of the page out to the database file. */
42559: if( rc==SQLITE_OK ){
42560: assert( (pPg->flags&PGHDR_NEED_SYNC)==0 );
42561: rc = pager_write_pagelist(pPager, pPg);
42562: }
42563: }
42564:
42565: /* Mark the page as clean. */
42566: if( rc==SQLITE_OK ){
42567: PAGERTRACE(("STRESS %d page %d\n", PAGERID(pPager), pPg->pgno));
42568: sqlite3PcacheMakeClean(pPg);
42569: }
42570:
42571: return pager_error(pPager, rc);
42572: }
42573:
42574:
42575: /*
42576: ** Allocate and initialize a new Pager object and put a pointer to it
42577: ** in *ppPager. The pager should eventually be freed by passing it
42578: ** to sqlite3PagerClose().
42579: **
42580: ** The zFilename argument is the path to the database file to open.
42581: ** If zFilename is NULL then a randomly-named temporary file is created
42582: ** and used as the file to be cached. Temporary files are be deleted
42583: ** automatically when they are closed. If zFilename is ":memory:" then
42584: ** all information is held in cache. It is never written to disk.
42585: ** This can be used to implement an in-memory database.
42586: **
42587: ** The nExtra parameter specifies the number of bytes of space allocated
42588: ** along with each page reference. This space is available to the user
42589: ** via the sqlite3PagerGetExtra() API.
42590: **
42591: ** The flags argument is used to specify properties that affect the
42592: ** operation of the pager. It should be passed some bitwise combination
42593: ** of the PAGER_OMIT_JOURNAL and PAGER_NO_READLOCK flags.
42594: **
42595: ** The vfsFlags parameter is a bitmask to pass to the flags parameter
42596: ** of the xOpen() method of the supplied VFS when opening files.
42597: **
42598: ** If the pager object is allocated and the specified file opened
42599: ** successfully, SQLITE_OK is returned and *ppPager set to point to
42600: ** the new pager object. If an error occurs, *ppPager is set to NULL
42601: ** and error code returned. This function may return SQLITE_NOMEM
42602: ** (sqlite3Malloc() is used to allocate memory), SQLITE_CANTOPEN or
42603: ** various SQLITE_IO_XXX errors.
42604: */
42605: SQLITE_PRIVATE int sqlite3PagerOpen(
42606: sqlite3_vfs *pVfs, /* The virtual file system to use */
42607: Pager **ppPager, /* OUT: Return the Pager structure here */
42608: const char *zFilename, /* Name of the database file to open */
42609: int nExtra, /* Extra bytes append to each in-memory page */
42610: int flags, /* flags controlling this file */
42611: int vfsFlags, /* flags passed through to sqlite3_vfs.xOpen() */
42612: void (*xReinit)(DbPage*) /* Function to reinitialize pages */
42613: ){
42614: u8 *pPtr;
42615: Pager *pPager = 0; /* Pager object to allocate and return */
42616: int rc = SQLITE_OK; /* Return code */
42617: int tempFile = 0; /* True for temp files (incl. in-memory files) */
42618: int memDb = 0; /* True if this is an in-memory file */
42619: int readOnly = 0; /* True if this is a read-only file */
42620: int journalFileSize; /* Bytes to allocate for each journal fd */
42621: char *zPathname = 0; /* Full path to database file */
42622: int nPathname = 0; /* Number of bytes in zPathname */
42623: int useJournal = (flags & PAGER_OMIT_JOURNAL)==0; /* False to omit journal */
42624: int noReadlock = (flags & PAGER_NO_READLOCK)!=0; /* True to omit read-lock */
42625: int pcacheSize = sqlite3PcacheSize(); /* Bytes to allocate for PCache */
42626: u32 szPageDflt = SQLITE_DEFAULT_PAGE_SIZE; /* Default page size */
42627: const char *zUri = 0; /* URI args to copy */
42628: int nUri = 0; /* Number of bytes of URI args at *zUri */
42629:
42630: /* Figure out how much space is required for each journal file-handle
42631: ** (there are two of them, the main journal and the sub-journal). This
42632: ** is the maximum space required for an in-memory journal file handle
42633: ** and a regular journal file-handle. Note that a "regular journal-handle"
42634: ** may be a wrapper capable of caching the first portion of the journal
42635: ** file in memory to implement the atomic-write optimization (see
42636: ** source file journal.c).
42637: */
42638: if( sqlite3JournalSize(pVfs)>sqlite3MemJournalSize() ){
42639: journalFileSize = ROUND8(sqlite3JournalSize(pVfs));
42640: }else{
42641: journalFileSize = ROUND8(sqlite3MemJournalSize());
42642: }
42643:
42644: /* Set the output variable to NULL in case an error occurs. */
42645: *ppPager = 0;
42646:
42647: #ifndef SQLITE_OMIT_MEMORYDB
42648: if( flags & PAGER_MEMORY ){
42649: memDb = 1;
42650: zFilename = 0;
42651: }
42652: #endif
42653:
42654: /* Compute and store the full pathname in an allocated buffer pointed
42655: ** to by zPathname, length nPathname. Or, if this is a temporary file,
42656: ** leave both nPathname and zPathname set to 0.
42657: */
42658: if( zFilename && zFilename[0] ){
42659: const char *z;
42660: nPathname = pVfs->mxPathname+1;
42661: zPathname = sqlite3Malloc(nPathname*2);
42662: if( zPathname==0 ){
42663: return SQLITE_NOMEM;
42664: }
42665: zPathname[0] = 0; /* Make sure initialized even if FullPathname() fails */
42666: rc = sqlite3OsFullPathname(pVfs, zFilename, nPathname, zPathname);
42667: nPathname = sqlite3Strlen30(zPathname);
42668: z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1];
42669: while( *z ){
42670: z += sqlite3Strlen30(z)+1;
42671: z += sqlite3Strlen30(z)+1;
42672: }
42673: nUri = (int)(&z[1] - zUri);
42674: assert( nUri>=0 );
42675: if( rc==SQLITE_OK && nPathname+8>pVfs->mxPathname ){
42676: /* This branch is taken when the journal path required by
42677: ** the database being opened will be more than pVfs->mxPathname
42678: ** bytes in length. This means the database cannot be opened,
42679: ** as it will not be possible to open the journal file or even
42680: ** check for a hot-journal before reading.
42681: */
42682: rc = SQLITE_CANTOPEN_BKPT;
42683: }
42684: if( rc!=SQLITE_OK ){
42685: sqlite3_free(zPathname);
42686: return rc;
42687: }
42688: }
42689:
42690: /* Allocate memory for the Pager structure, PCache object, the
42691: ** three file descriptors, the database file name and the journal
42692: ** file name. The layout in memory is as follows:
42693: **
42694: ** Pager object (sizeof(Pager) bytes)
42695: ** PCache object (sqlite3PcacheSize() bytes)
42696: ** Database file handle (pVfs->szOsFile bytes)
42697: ** Sub-journal file handle (journalFileSize bytes)
42698: ** Main journal file handle (journalFileSize bytes)
42699: ** Database file name (nPathname+1 bytes)
42700: ** Journal file name (nPathname+8+1 bytes)
42701: */
42702: pPtr = (u8 *)sqlite3MallocZero(
42703: ROUND8(sizeof(*pPager)) + /* Pager structure */
42704: ROUND8(pcacheSize) + /* PCache object */
42705: ROUND8(pVfs->szOsFile) + /* The main db file */
42706: journalFileSize * 2 + /* The two journal files */
42707: nPathname + 1 + nUri + /* zFilename */
42708: nPathname + 8 + 2 /* zJournal */
42709: #ifndef SQLITE_OMIT_WAL
42710: + nPathname + 4 + 2 /* zWal */
42711: #endif
42712: );
42713: assert( EIGHT_BYTE_ALIGNMENT(SQLITE_INT_TO_PTR(journalFileSize)) );
42714: if( !pPtr ){
42715: sqlite3_free(zPathname);
42716: return SQLITE_NOMEM;
42717: }
42718: pPager = (Pager*)(pPtr);
42719: pPager->pPCache = (PCache*)(pPtr += ROUND8(sizeof(*pPager)));
42720: pPager->fd = (sqlite3_file*)(pPtr += ROUND8(pcacheSize));
42721: pPager->sjfd = (sqlite3_file*)(pPtr += ROUND8(pVfs->szOsFile));
42722: pPager->jfd = (sqlite3_file*)(pPtr += journalFileSize);
42723: pPager->zFilename = (char*)(pPtr += journalFileSize);
42724: assert( EIGHT_BYTE_ALIGNMENT(pPager->jfd) );
42725:
42726: /* Fill in the Pager.zFilename and Pager.zJournal buffers, if required. */
42727: if( zPathname ){
42728: assert( nPathname>0 );
42729: pPager->zJournal = (char*)(pPtr += nPathname + 1 + nUri);
42730: memcpy(pPager->zFilename, zPathname, nPathname);
42731: memcpy(&pPager->zFilename[nPathname+1], zUri, nUri);
42732: memcpy(pPager->zJournal, zPathname, nPathname);
42733: memcpy(&pPager->zJournal[nPathname], "-journal\000", 8+1);
42734: sqlite3FileSuffix3(pPager->zFilename, pPager->zJournal);
42735: #ifndef SQLITE_OMIT_WAL
42736: pPager->zWal = &pPager->zJournal[nPathname+8+1];
42737: memcpy(pPager->zWal, zPathname, nPathname);
42738: memcpy(&pPager->zWal[nPathname], "-wal\000", 4+1);
42739: sqlite3FileSuffix3(pPager->zFilename, pPager->zWal);
42740: #endif
42741: sqlite3_free(zPathname);
42742: }
42743: pPager->pVfs = pVfs;
42744: pPager->vfsFlags = vfsFlags;
42745:
42746: /* Open the pager file.
42747: */
42748: if( zFilename && zFilename[0] ){
42749: int fout = 0; /* VFS flags returned by xOpen() */
42750: rc = sqlite3OsOpen(pVfs, pPager->zFilename, pPager->fd, vfsFlags, &fout);
42751: assert( !memDb );
42752: readOnly = (fout&SQLITE_OPEN_READONLY);
42753:
42754: /* If the file was successfully opened for read/write access,
42755: ** choose a default page size in case we have to create the
42756: ** database file. The default page size is the maximum of:
42757: **
42758: ** + SQLITE_DEFAULT_PAGE_SIZE,
42759: ** + The value returned by sqlite3OsSectorSize()
42760: ** + The largest page size that can be written atomically.
42761: */
42762: if( rc==SQLITE_OK && !readOnly ){
42763: setSectorSize(pPager);
42764: assert(SQLITE_DEFAULT_PAGE_SIZE<=SQLITE_MAX_DEFAULT_PAGE_SIZE);
42765: if( szPageDflt<pPager->sectorSize ){
42766: if( pPager->sectorSize>SQLITE_MAX_DEFAULT_PAGE_SIZE ){
42767: szPageDflt = SQLITE_MAX_DEFAULT_PAGE_SIZE;
42768: }else{
42769: szPageDflt = (u32)pPager->sectorSize;
42770: }
42771: }
42772: #ifdef SQLITE_ENABLE_ATOMIC_WRITE
42773: {
42774: int iDc = sqlite3OsDeviceCharacteristics(pPager->fd);
42775: int ii;
42776: assert(SQLITE_IOCAP_ATOMIC512==(512>>8));
42777: assert(SQLITE_IOCAP_ATOMIC64K==(65536>>8));
42778: assert(SQLITE_MAX_DEFAULT_PAGE_SIZE<=65536);
42779: for(ii=szPageDflt; ii<=SQLITE_MAX_DEFAULT_PAGE_SIZE; ii=ii*2){
42780: if( iDc&(SQLITE_IOCAP_ATOMIC|(ii>>8)) ){
42781: szPageDflt = ii;
42782: }
42783: }
42784: }
42785: #endif
42786: }
42787: }else{
42788: /* If a temporary file is requested, it is not opened immediately.
42789: ** In this case we accept the default page size and delay actually
42790: ** opening the file until the first call to OsWrite().
42791: **
42792: ** This branch is also run for an in-memory database. An in-memory
42793: ** database is the same as a temp-file that is never written out to
42794: ** disk and uses an in-memory rollback journal.
42795: */
42796: tempFile = 1;
42797: pPager->eState = PAGER_READER;
42798: pPager->eLock = EXCLUSIVE_LOCK;
42799: readOnly = (vfsFlags&SQLITE_OPEN_READONLY);
42800: }
42801:
42802: /* The following call to PagerSetPagesize() serves to set the value of
42803: ** Pager.pageSize and to allocate the Pager.pTmpSpace buffer.
42804: */
42805: if( rc==SQLITE_OK ){
42806: assert( pPager->memDb==0 );
42807: rc = sqlite3PagerSetPagesize(pPager, &szPageDflt, -1);
42808: testcase( rc!=SQLITE_OK );
42809: }
42810:
42811: /* If an error occurred in either of the blocks above, free the
42812: ** Pager structure and close the file.
42813: */
42814: if( rc!=SQLITE_OK ){
42815: assert( !pPager->pTmpSpace );
42816: sqlite3OsClose(pPager->fd);
42817: sqlite3_free(pPager);
42818: return rc;
42819: }
42820:
42821: /* Initialize the PCache object. */
42822: assert( nExtra<1000 );
42823: nExtra = ROUND8(nExtra);
42824: sqlite3PcacheOpen(szPageDflt, nExtra, !memDb,
42825: !memDb?pagerStress:0, (void *)pPager, pPager->pPCache);
42826:
42827: PAGERTRACE(("OPEN %d %s\n", FILEHANDLEID(pPager->fd), pPager->zFilename));
42828: IOTRACE(("OPEN %p %s\n", pPager, pPager->zFilename))
42829:
42830: pPager->useJournal = (u8)useJournal;
42831: pPager->noReadlock = (noReadlock && readOnly) ?1:0;
42832: /* pPager->stmtOpen = 0; */
42833: /* pPager->stmtInUse = 0; */
42834: /* pPager->nRef = 0; */
42835: /* pPager->stmtSize = 0; */
42836: /* pPager->stmtJSize = 0; */
42837: /* pPager->nPage = 0; */
42838: pPager->mxPgno = SQLITE_MAX_PAGE_COUNT;
42839: /* pPager->state = PAGER_UNLOCK; */
42840: #if 0
42841: assert( pPager->state == (tempFile ? PAGER_EXCLUSIVE : PAGER_UNLOCK) );
42842: #endif
42843: /* pPager->errMask = 0; */
42844: pPager->tempFile = (u8)tempFile;
42845: assert( tempFile==PAGER_LOCKINGMODE_NORMAL
42846: || tempFile==PAGER_LOCKINGMODE_EXCLUSIVE );
42847: assert( PAGER_LOCKINGMODE_EXCLUSIVE==1 );
42848: pPager->exclusiveMode = (u8)tempFile;
42849: pPager->changeCountDone = pPager->tempFile;
42850: pPager->memDb = (u8)memDb;
42851: pPager->readOnly = (u8)readOnly;
42852: assert( useJournal || pPager->tempFile );
42853: pPager->noSync = pPager->tempFile;
42854: if( pPager->noSync ){
42855: assert( pPager->fullSync==0 );
42856: assert( pPager->syncFlags==0 );
42857: assert( pPager->walSyncFlags==0 );
42858: assert( pPager->ckptSyncFlags==0 );
42859: }else{
42860: pPager->fullSync = 1;
42861: pPager->syncFlags = SQLITE_SYNC_NORMAL;
42862: pPager->walSyncFlags = SQLITE_SYNC_NORMAL | WAL_SYNC_TRANSACTIONS;
42863: pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
42864: }
42865: /* pPager->pFirst = 0; */
42866: /* pPager->pFirstSynced = 0; */
42867: /* pPager->pLast = 0; */
42868: pPager->nExtra = (u16)nExtra;
42869: pPager->journalSizeLimit = SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT;
42870: assert( isOpen(pPager->fd) || tempFile );
42871: setSectorSize(pPager);
42872: if( !useJournal ){
42873: pPager->journalMode = PAGER_JOURNALMODE_OFF;
42874: }else if( memDb ){
42875: pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
42876: }
42877: /* pPager->xBusyHandler = 0; */
42878: /* pPager->pBusyHandlerArg = 0; */
42879: pPager->xReiniter = xReinit;
42880: /* memset(pPager->aHash, 0, sizeof(pPager->aHash)); */
42881:
42882: *ppPager = pPager;
42883: return SQLITE_OK;
42884: }
42885:
42886:
42887:
42888: /*
42889: ** This function is called after transitioning from PAGER_UNLOCK to
42890: ** PAGER_SHARED state. It tests if there is a hot journal present in
42891: ** the file-system for the given pager. A hot journal is one that
42892: ** needs to be played back. According to this function, a hot-journal
42893: ** file exists if the following criteria are met:
42894: **
42895: ** * The journal file exists in the file system, and
42896: ** * No process holds a RESERVED or greater lock on the database file, and
42897: ** * The database file itself is greater than 0 bytes in size, and
42898: ** * The first byte of the journal file exists and is not 0x00.
42899: **
42900: ** If the current size of the database file is 0 but a journal file
42901: ** exists, that is probably an old journal left over from a prior
42902: ** database with the same name. In this case the journal file is
42903: ** just deleted using OsDelete, *pExists is set to 0 and SQLITE_OK
42904: ** is returned.
42905: **
42906: ** This routine does not check if there is a master journal filename
42907: ** at the end of the file. If there is, and that master journal file
42908: ** does not exist, then the journal file is not really hot. In this
42909: ** case this routine will return a false-positive. The pager_playback()
42910: ** routine will discover that the journal file is not really hot and
42911: ** will not roll it back.
42912: **
42913: ** If a hot-journal file is found to exist, *pExists is set to 1 and
42914: ** SQLITE_OK returned. If no hot-journal file is present, *pExists is
42915: ** set to 0 and SQLITE_OK returned. If an IO error occurs while trying
42916: ** to determine whether or not a hot-journal file exists, the IO error
42917: ** code is returned and the value of *pExists is undefined.
42918: */
42919: static int hasHotJournal(Pager *pPager, int *pExists){
42920: sqlite3_vfs * const pVfs = pPager->pVfs;
42921: int rc = SQLITE_OK; /* Return code */
42922: int exists = 1; /* True if a journal file is present */
42923: int jrnlOpen = !!isOpen(pPager->jfd);
42924:
42925: assert( pPager->useJournal );
42926: assert( isOpen(pPager->fd) );
42927: assert( pPager->eState==PAGER_OPEN );
42928:
42929: assert( jrnlOpen==0 || ( sqlite3OsDeviceCharacteristics(pPager->jfd) &
42930: SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
42931: ));
42932:
42933: *pExists = 0;
42934: if( !jrnlOpen ){
42935: rc = sqlite3OsAccess(pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &exists);
42936: }
42937: if( rc==SQLITE_OK && exists ){
42938: int locked = 0; /* True if some process holds a RESERVED lock */
42939:
42940: /* Race condition here: Another process might have been holding the
42941: ** the RESERVED lock and have a journal open at the sqlite3OsAccess()
42942: ** call above, but then delete the journal and drop the lock before
42943: ** we get to the following sqlite3OsCheckReservedLock() call. If that
42944: ** is the case, this routine might think there is a hot journal when
42945: ** in fact there is none. This results in a false-positive which will
42946: ** be dealt with by the playback routine. Ticket #3883.
42947: */
42948: rc = sqlite3OsCheckReservedLock(pPager->fd, &locked);
42949: if( rc==SQLITE_OK && !locked ){
42950: Pgno nPage; /* Number of pages in database file */
42951:
42952: /* Check the size of the database file. If it consists of 0 pages,
42953: ** then delete the journal file. See the header comment above for
42954: ** the reasoning here. Delete the obsolete journal file under
42955: ** a RESERVED lock to avoid race conditions and to avoid violating
42956: ** [H33020].
42957: */
42958: rc = pagerPagecount(pPager, &nPage);
42959: if( rc==SQLITE_OK ){
42960: if( nPage==0 ){
42961: sqlite3BeginBenignMalloc();
42962: if( pagerLockDb(pPager, RESERVED_LOCK)==SQLITE_OK ){
42963: sqlite3OsDelete(pVfs, pPager->zJournal, 0);
42964: if( !pPager->exclusiveMode ) pagerUnlockDb(pPager, SHARED_LOCK);
42965: }
42966: sqlite3EndBenignMalloc();
42967: }else{
42968: /* The journal file exists and no other connection has a reserved
42969: ** or greater lock on the database file. Now check that there is
42970: ** at least one non-zero bytes at the start of the journal file.
42971: ** If there is, then we consider this journal to be hot. If not,
42972: ** it can be ignored.
42973: */
42974: if( !jrnlOpen ){
42975: int f = SQLITE_OPEN_READONLY|SQLITE_OPEN_MAIN_JOURNAL;
42976: rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &f);
42977: }
42978: if( rc==SQLITE_OK ){
42979: u8 first = 0;
42980: rc = sqlite3OsRead(pPager->jfd, (void *)&first, 1, 0);
42981: if( rc==SQLITE_IOERR_SHORT_READ ){
42982: rc = SQLITE_OK;
42983: }
42984: if( !jrnlOpen ){
42985: sqlite3OsClose(pPager->jfd);
42986: }
42987: *pExists = (first!=0);
42988: }else if( rc==SQLITE_CANTOPEN ){
42989: /* If we cannot open the rollback journal file in order to see if
42990: ** its has a zero header, that might be due to an I/O error, or
42991: ** it might be due to the race condition described above and in
42992: ** ticket #3883. Either way, assume that the journal is hot.
42993: ** This might be a false positive. But if it is, then the
42994: ** automatic journal playback and recovery mechanism will deal
42995: ** with it under an EXCLUSIVE lock where we do not need to
42996: ** worry so much with race conditions.
42997: */
42998: *pExists = 1;
42999: rc = SQLITE_OK;
43000: }
43001: }
43002: }
43003: }
43004: }
43005:
43006: return rc;
43007: }
43008:
43009: /*
43010: ** This function is called to obtain a shared lock on the database file.
43011: ** It is illegal to call sqlite3PagerAcquire() until after this function
43012: ** has been successfully called. If a shared-lock is already held when
43013: ** this function is called, it is a no-op.
43014: **
43015: ** The following operations are also performed by this function.
43016: **
43017: ** 1) If the pager is currently in PAGER_OPEN state (no lock held
43018: ** on the database file), then an attempt is made to obtain a
43019: ** SHARED lock on the database file. Immediately after obtaining
43020: ** the SHARED lock, the file-system is checked for a hot-journal,
43021: ** which is played back if present. Following any hot-journal
43022: ** rollback, the contents of the cache are validated by checking
43023: ** the 'change-counter' field of the database file header and
43024: ** discarded if they are found to be invalid.
43025: **
43026: ** 2) If the pager is running in exclusive-mode, and there are currently
43027: ** no outstanding references to any pages, and is in the error state,
43028: ** then an attempt is made to clear the error state by discarding
43029: ** the contents of the page cache and rolling back any open journal
43030: ** file.
43031: **
43032: ** If everything is successful, SQLITE_OK is returned. If an IO error
43033: ** occurs while locking the database, checking for a hot-journal file or
43034: ** rolling back a journal file, the IO error code is returned.
43035: */
43036: SQLITE_PRIVATE int sqlite3PagerSharedLock(Pager *pPager){
43037: int rc = SQLITE_OK; /* Return code */
43038:
43039: /* This routine is only called from b-tree and only when there are no
43040: ** outstanding pages. This implies that the pager state should either
43041: ** be OPEN or READER. READER is only possible if the pager is or was in
43042: ** exclusive access mode.
43043: */
43044: assert( sqlite3PcacheRefCount(pPager->pPCache)==0 );
43045: assert( assert_pager_state(pPager) );
43046: assert( pPager->eState==PAGER_OPEN || pPager->eState==PAGER_READER );
43047: if( NEVER(MEMDB && pPager->errCode) ){ return pPager->errCode; }
43048:
43049: if( !pagerUseWal(pPager) && pPager->eState==PAGER_OPEN ){
43050: int bHotJournal = 1; /* True if there exists a hot journal-file */
43051:
43052: assert( !MEMDB );
43053: assert( pPager->noReadlock==0 || pPager->readOnly );
43054:
43055: if( pPager->noReadlock==0 ){
43056: rc = pager_wait_on_lock(pPager, SHARED_LOCK);
43057: if( rc!=SQLITE_OK ){
43058: assert( pPager->eLock==NO_LOCK || pPager->eLock==UNKNOWN_LOCK );
43059: goto failed;
43060: }
43061: }
43062:
43063: /* If a journal file exists, and there is no RESERVED lock on the
43064: ** database file, then it either needs to be played back or deleted.
43065: */
43066: if( pPager->eLock<=SHARED_LOCK ){
43067: rc = hasHotJournal(pPager, &bHotJournal);
43068: }
43069: if( rc!=SQLITE_OK ){
43070: goto failed;
43071: }
43072: if( bHotJournal ){
43073: /* Get an EXCLUSIVE lock on the database file. At this point it is
43074: ** important that a RESERVED lock is not obtained on the way to the
43075: ** EXCLUSIVE lock. If it were, another process might open the
43076: ** database file, detect the RESERVED lock, and conclude that the
43077: ** database is safe to read while this process is still rolling the
43078: ** hot-journal back.
43079: **
43080: ** Because the intermediate RESERVED lock is not requested, any
43081: ** other process attempting to access the database file will get to
43082: ** this point in the code and fail to obtain its own EXCLUSIVE lock
43083: ** on the database file.
43084: **
43085: ** Unless the pager is in locking_mode=exclusive mode, the lock is
43086: ** downgraded to SHARED_LOCK before this function returns.
43087: */
43088: rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
43089: if( rc!=SQLITE_OK ){
43090: goto failed;
43091: }
43092:
43093: /* If it is not already open and the file exists on disk, open the
43094: ** journal for read/write access. Write access is required because
43095: ** in exclusive-access mode the file descriptor will be kept open
43096: ** and possibly used for a transaction later on. Also, write-access
43097: ** is usually required to finalize the journal in journal_mode=persist
43098: ** mode (and also for journal_mode=truncate on some systems).
43099: **
43100: ** If the journal does not exist, it usually means that some
43101: ** other connection managed to get in and roll it back before
43102: ** this connection obtained the exclusive lock above. Or, it
43103: ** may mean that the pager was in the error-state when this
43104: ** function was called and the journal file does not exist.
43105: */
43106: if( !isOpen(pPager->jfd) ){
43107: sqlite3_vfs * const pVfs = pPager->pVfs;
43108: int bExists; /* True if journal file exists */
43109: rc = sqlite3OsAccess(
43110: pVfs, pPager->zJournal, SQLITE_ACCESS_EXISTS, &bExists);
43111: if( rc==SQLITE_OK && bExists ){
43112: int fout = 0;
43113: int f = SQLITE_OPEN_READWRITE|SQLITE_OPEN_MAIN_JOURNAL;
43114: assert( !pPager->tempFile );
43115: rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
43116: assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
43117: if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
43118: rc = SQLITE_CANTOPEN_BKPT;
43119: sqlite3OsClose(pPager->jfd);
43120: }
43121: }
43122: }
43123:
43124: /* Playback and delete the journal. Drop the database write
43125: ** lock and reacquire the read lock. Purge the cache before
43126: ** playing back the hot-journal so that we don't end up with
43127: ** an inconsistent cache. Sync the hot journal before playing
43128: ** it back since the process that crashed and left the hot journal
43129: ** probably did not sync it and we are required to always sync
43130: ** the journal before playing it back.
43131: */
43132: if( isOpen(pPager->jfd) ){
43133: assert( rc==SQLITE_OK );
43134: rc = pagerSyncHotJournal(pPager);
43135: if( rc==SQLITE_OK ){
43136: rc = pager_playback(pPager, 1);
43137: pPager->eState = PAGER_OPEN;
43138: }
43139: }else if( !pPager->exclusiveMode ){
43140: pagerUnlockDb(pPager, SHARED_LOCK);
43141: }
43142:
43143: if( rc!=SQLITE_OK ){
43144: /* This branch is taken if an error occurs while trying to open
43145: ** or roll back a hot-journal while holding an EXCLUSIVE lock. The
43146: ** pager_unlock() routine will be called before returning to unlock
43147: ** the file. If the unlock attempt fails, then Pager.eLock must be
43148: ** set to UNKNOWN_LOCK (see the comment above the #define for
43149: ** UNKNOWN_LOCK above for an explanation).
43150: **
43151: ** In order to get pager_unlock() to do this, set Pager.eState to
43152: ** PAGER_ERROR now. This is not actually counted as a transition
43153: ** to ERROR state in the state diagram at the top of this file,
43154: ** since we know that the same call to pager_unlock() will very
43155: ** shortly transition the pager object to the OPEN state. Calling
43156: ** assert_pager_state() would fail now, as it should not be possible
43157: ** to be in ERROR state when there are zero outstanding page
43158: ** references.
43159: */
43160: pager_error(pPager, rc);
43161: goto failed;
43162: }
43163:
43164: assert( pPager->eState==PAGER_OPEN );
43165: assert( (pPager->eLock==SHARED_LOCK)
43166: || (pPager->exclusiveMode && pPager->eLock>SHARED_LOCK)
43167: );
43168: }
43169:
43170: if( !pPager->tempFile
43171: && (pPager->pBackup || sqlite3PcachePagecount(pPager->pPCache)>0)
43172: ){
43173: /* The shared-lock has just been acquired on the database file
43174: ** and there are already pages in the cache (from a previous
43175: ** read or write transaction). Check to see if the database
43176: ** has been modified. If the database has changed, flush the
43177: ** cache.
43178: **
43179: ** Database changes is detected by looking at 15 bytes beginning
43180: ** at offset 24 into the file. The first 4 of these 16 bytes are
43181: ** a 32-bit counter that is incremented with each change. The
43182: ** other bytes change randomly with each file change when
43183: ** a codec is in use.
43184: **
43185: ** There is a vanishingly small chance that a change will not be
43186: ** detected. The chance of an undetected change is so small that
43187: ** it can be neglected.
43188: */
43189: Pgno nPage = 0;
43190: char dbFileVers[sizeof(pPager->dbFileVers)];
43191:
43192: rc = pagerPagecount(pPager, &nPage);
43193: if( rc ) goto failed;
43194:
43195: if( nPage>0 ){
43196: IOTRACE(("CKVERS %p %d\n", pPager, sizeof(dbFileVers)));
43197: rc = sqlite3OsRead(pPager->fd, &dbFileVers, sizeof(dbFileVers), 24);
43198: if( rc!=SQLITE_OK ){
43199: goto failed;
43200: }
43201: }else{
43202: memset(dbFileVers, 0, sizeof(dbFileVers));
43203: }
43204:
43205: if( memcmp(pPager->dbFileVers, dbFileVers, sizeof(dbFileVers))!=0 ){
43206: pager_reset(pPager);
43207: }
43208: }
43209:
43210: /* If there is a WAL file in the file-system, open this database in WAL
43211: ** mode. Otherwise, the following function call is a no-op.
43212: */
43213: rc = pagerOpenWalIfPresent(pPager);
43214: #ifndef SQLITE_OMIT_WAL
43215: assert( pPager->pWal==0 || rc==SQLITE_OK );
43216: #endif
43217: }
43218:
43219: if( pagerUseWal(pPager) ){
43220: assert( rc==SQLITE_OK );
43221: rc = pagerBeginReadTransaction(pPager);
43222: }
43223:
43224: if( pPager->eState==PAGER_OPEN && rc==SQLITE_OK ){
43225: rc = pagerPagecount(pPager, &pPager->dbSize);
43226: }
43227:
43228: failed:
43229: if( rc!=SQLITE_OK ){
43230: assert( !MEMDB );
43231: pager_unlock(pPager);
43232: assert( pPager->eState==PAGER_OPEN );
43233: }else{
43234: pPager->eState = PAGER_READER;
43235: }
43236: return rc;
43237: }
43238:
43239: /*
43240: ** If the reference count has reached zero, rollback any active
43241: ** transaction and unlock the pager.
43242: **
43243: ** Except, in locking_mode=EXCLUSIVE when there is nothing to in
43244: ** the rollback journal, the unlock is not performed and there is
43245: ** nothing to rollback, so this routine is a no-op.
43246: */
43247: static void pagerUnlockIfUnused(Pager *pPager){
43248: if( (sqlite3PcacheRefCount(pPager->pPCache)==0) ){
43249: pagerUnlockAndRollback(pPager);
43250: }
43251: }
43252:
43253: /*
43254: ** Acquire a reference to page number pgno in pager pPager (a page
43255: ** reference has type DbPage*). If the requested reference is
43256: ** successfully obtained, it is copied to *ppPage and SQLITE_OK returned.
43257: **
43258: ** If the requested page is already in the cache, it is returned.
43259: ** Otherwise, a new page object is allocated and populated with data
43260: ** read from the database file. In some cases, the pcache module may
43261: ** choose not to allocate a new page object and may reuse an existing
43262: ** object with no outstanding references.
43263: **
43264: ** The extra data appended to a page is always initialized to zeros the
43265: ** first time a page is loaded into memory. If the page requested is
43266: ** already in the cache when this function is called, then the extra
43267: ** data is left as it was when the page object was last used.
43268: **
43269: ** If the database image is smaller than the requested page or if a
43270: ** non-zero value is passed as the noContent parameter and the
43271: ** requested page is not already stored in the cache, then no
43272: ** actual disk read occurs. In this case the memory image of the
43273: ** page is initialized to all zeros.
43274: **
43275: ** If noContent is true, it means that we do not care about the contents
43276: ** of the page. This occurs in two seperate scenarios:
43277: **
43278: ** a) When reading a free-list leaf page from the database, and
43279: **
43280: ** b) When a savepoint is being rolled back and we need to load
43281: ** a new page into the cache to be filled with the data read
43282: ** from the savepoint journal.
43283: **
43284: ** If noContent is true, then the data returned is zeroed instead of
43285: ** being read from the database. Additionally, the bits corresponding
43286: ** to pgno in Pager.pInJournal (bitvec of pages already written to the
43287: ** journal file) and the PagerSavepoint.pInSavepoint bitvecs of any open
43288: ** savepoints are set. This means if the page is made writable at any
43289: ** point in the future, using a call to sqlite3PagerWrite(), its contents
43290: ** will not be journaled. This saves IO.
43291: **
43292: ** The acquisition might fail for several reasons. In all cases,
43293: ** an appropriate error code is returned and *ppPage is set to NULL.
43294: **
43295: ** See also sqlite3PagerLookup(). Both this routine and Lookup() attempt
43296: ** to find a page in the in-memory cache first. If the page is not already
43297: ** in memory, this routine goes to disk to read it in whereas Lookup()
43298: ** just returns 0. This routine acquires a read-lock the first time it
43299: ** has to go to disk, and could also playback an old journal if necessary.
43300: ** Since Lookup() never goes to disk, it never has to deal with locks
43301: ** or journal files.
43302: */
43303: SQLITE_PRIVATE int sqlite3PagerAcquire(
43304: Pager *pPager, /* The pager open on the database file */
43305: Pgno pgno, /* Page number to fetch */
43306: DbPage **ppPage, /* Write a pointer to the page here */
43307: int noContent /* Do not bother reading content from disk if true */
43308: ){
43309: int rc;
43310: PgHdr *pPg;
43311:
43312: assert( pPager->eState>=PAGER_READER );
43313: assert( assert_pager_state(pPager) );
43314:
43315: if( pgno==0 ){
43316: return SQLITE_CORRUPT_BKPT;
43317: }
43318:
43319: /* If the pager is in the error state, return an error immediately.
43320: ** Otherwise, request the page from the PCache layer. */
43321: if( pPager->errCode!=SQLITE_OK ){
43322: rc = pPager->errCode;
43323: }else{
43324: rc = sqlite3PcacheFetch(pPager->pPCache, pgno, 1, ppPage);
43325: }
43326:
43327: if( rc!=SQLITE_OK ){
43328: /* Either the call to sqlite3PcacheFetch() returned an error or the
43329: ** pager was already in the error-state when this function was called.
43330: ** Set pPg to 0 and jump to the exception handler. */
43331: pPg = 0;
43332: goto pager_acquire_err;
43333: }
43334: assert( (*ppPage)->pgno==pgno );
43335: assert( (*ppPage)->pPager==pPager || (*ppPage)->pPager==0 );
43336:
43337: if( (*ppPage)->pPager && !noContent ){
43338: /* In this case the pcache already contains an initialized copy of
43339: ** the page. Return without further ado. */
43340: assert( pgno<=PAGER_MAX_PGNO && pgno!=PAGER_MJ_PGNO(pPager) );
43341: pPager->nHit++;
43342: return SQLITE_OK;
43343:
43344: }else{
43345: /* The pager cache has created a new page. Its content needs to
43346: ** be initialized. */
43347:
43348: pPg = *ppPage;
43349: pPg->pPager = pPager;
43350:
43351: /* The maximum page number is 2^31. Return SQLITE_CORRUPT if a page
43352: ** number greater than this, or the unused locking-page, is requested. */
43353: if( pgno>PAGER_MAX_PGNO || pgno==PAGER_MJ_PGNO(pPager) ){
43354: rc = SQLITE_CORRUPT_BKPT;
43355: goto pager_acquire_err;
43356: }
43357:
43358: if( MEMDB || pPager->dbSize<pgno || noContent || !isOpen(pPager->fd) ){
43359: if( pgno>pPager->mxPgno ){
43360: rc = SQLITE_FULL;
43361: goto pager_acquire_err;
43362: }
43363: if( noContent ){
43364: /* Failure to set the bits in the InJournal bit-vectors is benign.
43365: ** It merely means that we might do some extra work to journal a
43366: ** page that does not need to be journaled. Nevertheless, be sure
43367: ** to test the case where a malloc error occurs while trying to set
43368: ** a bit in a bit vector.
43369: */
43370: sqlite3BeginBenignMalloc();
43371: if( pgno<=pPager->dbOrigSize ){
43372: TESTONLY( rc = ) sqlite3BitvecSet(pPager->pInJournal, pgno);
43373: testcase( rc==SQLITE_NOMEM );
43374: }
43375: TESTONLY( rc = ) addToSavepointBitvecs(pPager, pgno);
43376: testcase( rc==SQLITE_NOMEM );
43377: sqlite3EndBenignMalloc();
43378: }
43379: memset(pPg->pData, 0, pPager->pageSize);
43380: IOTRACE(("ZERO %p %d\n", pPager, pgno));
43381: }else{
43382: assert( pPg->pPager==pPager );
43383: pPager->nMiss++;
43384: rc = readDbPage(pPg);
43385: if( rc!=SQLITE_OK ){
43386: goto pager_acquire_err;
43387: }
43388: }
43389: pager_set_pagehash(pPg);
43390: }
43391:
43392: return SQLITE_OK;
43393:
43394: pager_acquire_err:
43395: assert( rc!=SQLITE_OK );
43396: if( pPg ){
43397: sqlite3PcacheDrop(pPg);
43398: }
43399: pagerUnlockIfUnused(pPager);
43400:
43401: *ppPage = 0;
43402: return rc;
43403: }
43404:
43405: /*
43406: ** Acquire a page if it is already in the in-memory cache. Do
43407: ** not read the page from disk. Return a pointer to the page,
43408: ** or 0 if the page is not in cache.
43409: **
43410: ** See also sqlite3PagerGet(). The difference between this routine
43411: ** and sqlite3PagerGet() is that _get() will go to the disk and read
43412: ** in the page if the page is not already in cache. This routine
43413: ** returns NULL if the page is not in cache or if a disk I/O error
43414: ** has ever happened.
43415: */
43416: SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno){
43417: PgHdr *pPg = 0;
43418: assert( pPager!=0 );
43419: assert( pgno!=0 );
43420: assert( pPager->pPCache!=0 );
43421: assert( pPager->eState>=PAGER_READER && pPager->eState!=PAGER_ERROR );
43422: sqlite3PcacheFetch(pPager->pPCache, pgno, 0, &pPg);
43423: return pPg;
43424: }
43425:
43426: /*
43427: ** Release a page reference.
43428: **
43429: ** If the number of references to the page drop to zero, then the
43430: ** page is added to the LRU list. When all references to all pages
43431: ** are released, a rollback occurs and the lock on the database is
43432: ** removed.
43433: */
43434: SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){
43435: if( pPg ){
43436: Pager *pPager = pPg->pPager;
43437: sqlite3PcacheRelease(pPg);
43438: pagerUnlockIfUnused(pPager);
43439: }
43440: }
43441:
43442: /*
43443: ** This function is called at the start of every write transaction.
43444: ** There must already be a RESERVED or EXCLUSIVE lock on the database
43445: ** file when this routine is called.
43446: **
43447: ** Open the journal file for pager pPager and write a journal header
43448: ** to the start of it. If there are active savepoints, open the sub-journal
43449: ** as well. This function is only used when the journal file is being
43450: ** opened to write a rollback log for a transaction. It is not used
43451: ** when opening a hot journal file to roll it back.
43452: **
43453: ** If the journal file is already open (as it may be in exclusive mode),
43454: ** then this function just writes a journal header to the start of the
43455: ** already open file.
43456: **
43457: ** Whether or not the journal file is opened by this function, the
43458: ** Pager.pInJournal bitvec structure is allocated.
43459: **
43460: ** Return SQLITE_OK if everything is successful. Otherwise, return
43461: ** SQLITE_NOMEM if the attempt to allocate Pager.pInJournal fails, or
43462: ** an IO error code if opening or writing the journal file fails.
43463: */
43464: static int pager_open_journal(Pager *pPager){
43465: int rc = SQLITE_OK; /* Return code */
43466: sqlite3_vfs * const pVfs = pPager->pVfs; /* Local cache of vfs pointer */
43467:
43468: assert( pPager->eState==PAGER_WRITER_LOCKED );
43469: assert( assert_pager_state(pPager) );
43470: assert( pPager->pInJournal==0 );
43471:
43472: /* If already in the error state, this function is a no-op. But on
43473: ** the other hand, this routine is never called if we are already in
43474: ** an error state. */
43475: if( NEVER(pPager->errCode) ) return pPager->errCode;
43476:
43477: if( !pagerUseWal(pPager) && pPager->journalMode!=PAGER_JOURNALMODE_OFF ){
43478: pPager->pInJournal = sqlite3BitvecCreate(pPager->dbSize);
43479: if( pPager->pInJournal==0 ){
43480: return SQLITE_NOMEM;
43481: }
43482:
43483: /* Open the journal file if it is not already open. */
43484: if( !isOpen(pPager->jfd) ){
43485: if( pPager->journalMode==PAGER_JOURNALMODE_MEMORY ){
43486: sqlite3MemJournalOpen(pPager->jfd);
43487: }else{
43488: const int flags = /* VFS flags to open journal file */
43489: SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
43490: (pPager->tempFile ?
43491: (SQLITE_OPEN_DELETEONCLOSE|SQLITE_OPEN_TEMP_JOURNAL):
43492: (SQLITE_OPEN_MAIN_JOURNAL)
43493: );
43494: #ifdef SQLITE_ENABLE_ATOMIC_WRITE
43495: rc = sqlite3JournalOpen(
43496: pVfs, pPager->zJournal, pPager->jfd, flags, jrnlBufferSize(pPager)
43497: );
43498: #else
43499: rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, flags, 0);
43500: #endif
43501: }
43502: assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
43503: }
43504:
43505:
43506: /* Write the first journal header to the journal file and open
43507: ** the sub-journal if necessary.
43508: */
43509: if( rc==SQLITE_OK ){
43510: /* TODO: Check if all of these are really required. */
43511: pPager->nRec = 0;
43512: pPager->journalOff = 0;
43513: pPager->setMaster = 0;
43514: pPager->journalHdr = 0;
43515: rc = writeJournalHdr(pPager);
43516: }
43517: }
43518:
43519: if( rc!=SQLITE_OK ){
43520: sqlite3BitvecDestroy(pPager->pInJournal);
43521: pPager->pInJournal = 0;
43522: }else{
43523: assert( pPager->eState==PAGER_WRITER_LOCKED );
43524: pPager->eState = PAGER_WRITER_CACHEMOD;
43525: }
43526:
43527: return rc;
43528: }
43529:
43530: /*
43531: ** Begin a write-transaction on the specified pager object. If a
43532: ** write-transaction has already been opened, this function is a no-op.
43533: **
43534: ** If the exFlag argument is false, then acquire at least a RESERVED
43535: ** lock on the database file. If exFlag is true, then acquire at least
43536: ** an EXCLUSIVE lock. If such a lock is already held, no locking
43537: ** functions need be called.
43538: **
43539: ** If the subjInMemory argument is non-zero, then any sub-journal opened
43540: ** within this transaction will be opened as an in-memory file. This
43541: ** has no effect if the sub-journal is already opened (as it may be when
43542: ** running in exclusive mode) or if the transaction does not require a
43543: ** sub-journal. If the subjInMemory argument is zero, then any required
43544: ** sub-journal is implemented in-memory if pPager is an in-memory database,
43545: ** or using a temporary file otherwise.
43546: */
43547: SQLITE_PRIVATE int sqlite3PagerBegin(Pager *pPager, int exFlag, int subjInMemory){
43548: int rc = SQLITE_OK;
43549:
43550: if( pPager->errCode ) return pPager->errCode;
43551: assert( pPager->eState>=PAGER_READER && pPager->eState<PAGER_ERROR );
43552: pPager->subjInMemory = (u8)subjInMemory;
43553:
43554: if( ALWAYS(pPager->eState==PAGER_READER) ){
43555: assert( pPager->pInJournal==0 );
43556:
43557: if( pagerUseWal(pPager) ){
43558: /* If the pager is configured to use locking_mode=exclusive, and an
43559: ** exclusive lock on the database is not already held, obtain it now.
43560: */
43561: if( pPager->exclusiveMode && sqlite3WalExclusiveMode(pPager->pWal, -1) ){
43562: rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
43563: if( rc!=SQLITE_OK ){
43564: return rc;
43565: }
43566: sqlite3WalExclusiveMode(pPager->pWal, 1);
43567: }
43568:
43569: /* Grab the write lock on the log file. If successful, upgrade to
43570: ** PAGER_RESERVED state. Otherwise, return an error code to the caller.
43571: ** The busy-handler is not invoked if another connection already
43572: ** holds the write-lock. If possible, the upper layer will call it.
43573: */
43574: rc = sqlite3WalBeginWriteTransaction(pPager->pWal);
43575: }else{
43576: /* Obtain a RESERVED lock on the database file. If the exFlag parameter
43577: ** is true, then immediately upgrade this to an EXCLUSIVE lock. The
43578: ** busy-handler callback can be used when upgrading to the EXCLUSIVE
43579: ** lock, but not when obtaining the RESERVED lock.
43580: */
43581: rc = pagerLockDb(pPager, RESERVED_LOCK);
43582: if( rc==SQLITE_OK && exFlag ){
43583: rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
43584: }
43585: }
43586:
43587: if( rc==SQLITE_OK ){
43588: /* Change to WRITER_LOCKED state.
43589: **
43590: ** WAL mode sets Pager.eState to PAGER_WRITER_LOCKED or CACHEMOD
43591: ** when it has an open transaction, but never to DBMOD or FINISHED.
43592: ** This is because in those states the code to roll back savepoint
43593: ** transactions may copy data from the sub-journal into the database
43594: ** file as well as into the page cache. Which would be incorrect in
43595: ** WAL mode.
43596: */
43597: pPager->eState = PAGER_WRITER_LOCKED;
43598: pPager->dbHintSize = pPager->dbSize;
43599: pPager->dbFileSize = pPager->dbSize;
43600: pPager->dbOrigSize = pPager->dbSize;
43601: pPager->journalOff = 0;
43602: }
43603:
43604: assert( rc==SQLITE_OK || pPager->eState==PAGER_READER );
43605: assert( rc!=SQLITE_OK || pPager->eState==PAGER_WRITER_LOCKED );
43606: assert( assert_pager_state(pPager) );
43607: }
43608:
43609: PAGERTRACE(("TRANSACTION %d\n", PAGERID(pPager)));
43610: return rc;
43611: }
43612:
43613: /*
43614: ** Mark a single data page as writeable. The page is written into the
43615: ** main journal or sub-journal as required. If the page is written into
43616: ** one of the journals, the corresponding bit is set in the
43617: ** Pager.pInJournal bitvec and the PagerSavepoint.pInSavepoint bitvecs
43618: ** of any open savepoints as appropriate.
43619: */
43620: static int pager_write(PgHdr *pPg){
43621: void *pData = pPg->pData;
43622: Pager *pPager = pPg->pPager;
43623: int rc = SQLITE_OK;
43624:
43625: /* This routine is not called unless a write-transaction has already
43626: ** been started. The journal file may or may not be open at this point.
43627: ** It is never called in the ERROR state.
43628: */
43629: assert( pPager->eState==PAGER_WRITER_LOCKED
43630: || pPager->eState==PAGER_WRITER_CACHEMOD
43631: || pPager->eState==PAGER_WRITER_DBMOD
43632: );
43633: assert( assert_pager_state(pPager) );
43634:
43635: /* If an error has been previously detected, report the same error
43636: ** again. This should not happen, but the check provides robustness. */
43637: if( NEVER(pPager->errCode) ) return pPager->errCode;
43638:
43639: /* Higher-level routines never call this function if database is not
43640: ** writable. But check anyway, just for robustness. */
43641: if( NEVER(pPager->readOnly) ) return SQLITE_PERM;
43642:
43643: CHECK_PAGE(pPg);
43644:
43645: /* The journal file needs to be opened. Higher level routines have already
43646: ** obtained the necessary locks to begin the write-transaction, but the
43647: ** rollback journal might not yet be open. Open it now if this is the case.
43648: **
43649: ** This is done before calling sqlite3PcacheMakeDirty() on the page.
43650: ** Otherwise, if it were done after calling sqlite3PcacheMakeDirty(), then
43651: ** an error might occur and the pager would end up in WRITER_LOCKED state
43652: ** with pages marked as dirty in the cache.
43653: */
43654: if( pPager->eState==PAGER_WRITER_LOCKED ){
43655: rc = pager_open_journal(pPager);
43656: if( rc!=SQLITE_OK ) return rc;
43657: }
43658: assert( pPager->eState>=PAGER_WRITER_CACHEMOD );
43659: assert( assert_pager_state(pPager) );
43660:
43661: /* Mark the page as dirty. If the page has already been written
43662: ** to the journal then we can return right away.
43663: */
43664: sqlite3PcacheMakeDirty(pPg);
43665: if( pageInJournal(pPg) && !subjRequiresPage(pPg) ){
43666: assert( !pagerUseWal(pPager) );
43667: }else{
43668:
43669: /* The transaction journal now exists and we have a RESERVED or an
43670: ** EXCLUSIVE lock on the main database file. Write the current page to
43671: ** the transaction journal if it is not there already.
43672: */
43673: if( !pageInJournal(pPg) && !pagerUseWal(pPager) ){
43674: assert( pagerUseWal(pPager)==0 );
43675: if( pPg->pgno<=pPager->dbOrigSize && isOpen(pPager->jfd) ){
43676: u32 cksum;
43677: char *pData2;
43678: i64 iOff = pPager->journalOff;
43679:
43680: /* We should never write to the journal file the page that
43681: ** contains the database locks. The following assert verifies
43682: ** that we do not. */
43683: assert( pPg->pgno!=PAGER_MJ_PGNO(pPager) );
43684:
43685: assert( pPager->journalHdr<=pPager->journalOff );
43686: CODEC2(pPager, pData, pPg->pgno, 7, return SQLITE_NOMEM, pData2);
43687: cksum = pager_cksum(pPager, (u8*)pData2);
43688:
43689: /* Even if an IO or diskfull error occurs while journalling the
43690: ** page in the block above, set the need-sync flag for the page.
43691: ** Otherwise, when the transaction is rolled back, the logic in
43692: ** playback_one_page() will think that the page needs to be restored
43693: ** in the database file. And if an IO error occurs while doing so,
43694: ** then corruption may follow.
43695: */
43696: pPg->flags |= PGHDR_NEED_SYNC;
43697:
43698: rc = write32bits(pPager->jfd, iOff, pPg->pgno);
43699: if( rc!=SQLITE_OK ) return rc;
43700: rc = sqlite3OsWrite(pPager->jfd, pData2, pPager->pageSize, iOff+4);
43701: if( rc!=SQLITE_OK ) return rc;
43702: rc = write32bits(pPager->jfd, iOff+pPager->pageSize+4, cksum);
43703: if( rc!=SQLITE_OK ) return rc;
43704:
43705: IOTRACE(("JOUT %p %d %lld %d\n", pPager, pPg->pgno,
43706: pPager->journalOff, pPager->pageSize));
43707: PAGER_INCR(sqlite3_pager_writej_count);
43708: PAGERTRACE(("JOURNAL %d page %d needSync=%d hash(%08x)\n",
43709: PAGERID(pPager), pPg->pgno,
43710: ((pPg->flags&PGHDR_NEED_SYNC)?1:0), pager_pagehash(pPg)));
43711:
43712: pPager->journalOff += 8 + pPager->pageSize;
43713: pPager->nRec++;
43714: assert( pPager->pInJournal!=0 );
43715: rc = sqlite3BitvecSet(pPager->pInJournal, pPg->pgno);
43716: testcase( rc==SQLITE_NOMEM );
43717: assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
43718: rc |= addToSavepointBitvecs(pPager, pPg->pgno);
43719: if( rc!=SQLITE_OK ){
43720: assert( rc==SQLITE_NOMEM );
43721: return rc;
43722: }
43723: }else{
43724: if( pPager->eState!=PAGER_WRITER_DBMOD ){
43725: pPg->flags |= PGHDR_NEED_SYNC;
43726: }
43727: PAGERTRACE(("APPEND %d page %d needSync=%d\n",
43728: PAGERID(pPager), pPg->pgno,
43729: ((pPg->flags&PGHDR_NEED_SYNC)?1:0)));
43730: }
43731: }
43732:
43733: /* If the statement journal is open and the page is not in it,
43734: ** then write the current page to the statement journal. Note that
43735: ** the statement journal format differs from the standard journal format
43736: ** in that it omits the checksums and the header.
43737: */
43738: if( subjRequiresPage(pPg) ){
43739: rc = subjournalPage(pPg);
43740: }
43741: }
43742:
43743: /* Update the database size and return.
43744: */
43745: if( pPager->dbSize<pPg->pgno ){
43746: pPager->dbSize = pPg->pgno;
43747: }
43748: return rc;
43749: }
43750:
43751: /*
43752: ** Mark a data page as writeable. This routine must be called before
43753: ** making changes to a page. The caller must check the return value
43754: ** of this function and be careful not to change any page data unless
43755: ** this routine returns SQLITE_OK.
43756: **
43757: ** The difference between this function and pager_write() is that this
43758: ** function also deals with the special case where 2 or more pages
43759: ** fit on a single disk sector. In this case all co-resident pages
43760: ** must have been written to the journal file before returning.
43761: **
43762: ** If an error occurs, SQLITE_NOMEM or an IO error code is returned
43763: ** as appropriate. Otherwise, SQLITE_OK.
43764: */
43765: SQLITE_PRIVATE int sqlite3PagerWrite(DbPage *pDbPage){
43766: int rc = SQLITE_OK;
43767:
43768: PgHdr *pPg = pDbPage;
43769: Pager *pPager = pPg->pPager;
43770: Pgno nPagePerSector = (pPager->sectorSize/pPager->pageSize);
43771:
43772: assert( pPager->eState>=PAGER_WRITER_LOCKED );
43773: assert( pPager->eState!=PAGER_ERROR );
43774: assert( assert_pager_state(pPager) );
43775:
43776: if( nPagePerSector>1 ){
43777: Pgno nPageCount; /* Total number of pages in database file */
43778: Pgno pg1; /* First page of the sector pPg is located on. */
43779: int nPage = 0; /* Number of pages starting at pg1 to journal */
43780: int ii; /* Loop counter */
43781: int needSync = 0; /* True if any page has PGHDR_NEED_SYNC */
43782:
43783: /* Set the doNotSyncSpill flag to 1. This is because we cannot allow
43784: ** a journal header to be written between the pages journaled by
43785: ** this function.
43786: */
43787: assert( !MEMDB );
43788: assert( pPager->doNotSyncSpill==0 );
43789: pPager->doNotSyncSpill++;
43790:
43791: /* This trick assumes that both the page-size and sector-size are
43792: ** an integer power of 2. It sets variable pg1 to the identifier
43793: ** of the first page of the sector pPg is located on.
43794: */
43795: pg1 = ((pPg->pgno-1) & ~(nPagePerSector-1)) + 1;
43796:
43797: nPageCount = pPager->dbSize;
43798: if( pPg->pgno>nPageCount ){
43799: nPage = (pPg->pgno - pg1)+1;
43800: }else if( (pg1+nPagePerSector-1)>nPageCount ){
43801: nPage = nPageCount+1-pg1;
43802: }else{
43803: nPage = nPagePerSector;
43804: }
43805: assert(nPage>0);
43806: assert(pg1<=pPg->pgno);
43807: assert((pg1+nPage)>pPg->pgno);
43808:
43809: for(ii=0; ii<nPage && rc==SQLITE_OK; ii++){
43810: Pgno pg = pg1+ii;
43811: PgHdr *pPage;
43812: if( pg==pPg->pgno || !sqlite3BitvecTest(pPager->pInJournal, pg) ){
43813: if( pg!=PAGER_MJ_PGNO(pPager) ){
43814: rc = sqlite3PagerGet(pPager, pg, &pPage);
43815: if( rc==SQLITE_OK ){
43816: rc = pager_write(pPage);
43817: if( pPage->flags&PGHDR_NEED_SYNC ){
43818: needSync = 1;
43819: }
43820: sqlite3PagerUnref(pPage);
43821: }
43822: }
43823: }else if( (pPage = pager_lookup(pPager, pg))!=0 ){
43824: if( pPage->flags&PGHDR_NEED_SYNC ){
43825: needSync = 1;
43826: }
43827: sqlite3PagerUnref(pPage);
43828: }
43829: }
43830:
43831: /* If the PGHDR_NEED_SYNC flag is set for any of the nPage pages
43832: ** starting at pg1, then it needs to be set for all of them. Because
43833: ** writing to any of these nPage pages may damage the others, the
43834: ** journal file must contain sync()ed copies of all of them
43835: ** before any of them can be written out to the database file.
43836: */
43837: if( rc==SQLITE_OK && needSync ){
43838: assert( !MEMDB );
43839: for(ii=0; ii<nPage; ii++){
43840: PgHdr *pPage = pager_lookup(pPager, pg1+ii);
43841: if( pPage ){
43842: pPage->flags |= PGHDR_NEED_SYNC;
43843: sqlite3PagerUnref(pPage);
43844: }
43845: }
43846: }
43847:
43848: assert( pPager->doNotSyncSpill==1 );
43849: pPager->doNotSyncSpill--;
43850: }else{
43851: rc = pager_write(pDbPage);
43852: }
43853: return rc;
43854: }
43855:
43856: /*
43857: ** Return TRUE if the page given in the argument was previously passed
43858: ** to sqlite3PagerWrite(). In other words, return TRUE if it is ok
43859: ** to change the content of the page.
43860: */
43861: #ifndef NDEBUG
43862: SQLITE_PRIVATE int sqlite3PagerIswriteable(DbPage *pPg){
43863: return pPg->flags&PGHDR_DIRTY;
43864: }
43865: #endif
43866:
43867: /*
43868: ** A call to this routine tells the pager that it is not necessary to
43869: ** write the information on page pPg back to the disk, even though
43870: ** that page might be marked as dirty. This happens, for example, when
43871: ** the page has been added as a leaf of the freelist and so its
43872: ** content no longer matters.
43873: **
43874: ** The overlying software layer calls this routine when all of the data
43875: ** on the given page is unused. The pager marks the page as clean so
43876: ** that it does not get written to disk.
43877: **
43878: ** Tests show that this optimization can quadruple the speed of large
43879: ** DELETE operations.
43880: */
43881: SQLITE_PRIVATE void sqlite3PagerDontWrite(PgHdr *pPg){
43882: Pager *pPager = pPg->pPager;
43883: if( (pPg->flags&PGHDR_DIRTY) && pPager->nSavepoint==0 ){
43884: PAGERTRACE(("DONT_WRITE page %d of %d\n", pPg->pgno, PAGERID(pPager)));
43885: IOTRACE(("CLEAN %p %d\n", pPager, pPg->pgno))
43886: pPg->flags |= PGHDR_DONT_WRITE;
43887: pager_set_pagehash(pPg);
43888: }
43889: }
43890:
43891: /*
43892: ** This routine is called to increment the value of the database file
43893: ** change-counter, stored as a 4-byte big-endian integer starting at
43894: ** byte offset 24 of the pager file. The secondary change counter at
43895: ** 92 is also updated, as is the SQLite version number at offset 96.
43896: **
43897: ** But this only happens if the pPager->changeCountDone flag is false.
43898: ** To avoid excess churning of page 1, the update only happens once.
43899: ** See also the pager_write_changecounter() routine that does an
43900: ** unconditional update of the change counters.
43901: **
43902: ** If the isDirectMode flag is zero, then this is done by calling
43903: ** sqlite3PagerWrite() on page 1, then modifying the contents of the
43904: ** page data. In this case the file will be updated when the current
43905: ** transaction is committed.
43906: **
43907: ** The isDirectMode flag may only be non-zero if the library was compiled
43908: ** with the SQLITE_ENABLE_ATOMIC_WRITE macro defined. In this case,
43909: ** if isDirect is non-zero, then the database file is updated directly
43910: ** by writing an updated version of page 1 using a call to the
43911: ** sqlite3OsWrite() function.
43912: */
43913: static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
43914: int rc = SQLITE_OK;
43915:
43916: assert( pPager->eState==PAGER_WRITER_CACHEMOD
43917: || pPager->eState==PAGER_WRITER_DBMOD
43918: );
43919: assert( assert_pager_state(pPager) );
43920:
43921: /* Declare and initialize constant integer 'isDirect'. If the
43922: ** atomic-write optimization is enabled in this build, then isDirect
43923: ** is initialized to the value passed as the isDirectMode parameter
43924: ** to this function. Otherwise, it is always set to zero.
43925: **
43926: ** The idea is that if the atomic-write optimization is not
43927: ** enabled at compile time, the compiler can omit the tests of
43928: ** 'isDirect' below, as well as the block enclosed in the
43929: ** "if( isDirect )" condition.
43930: */
43931: #ifndef SQLITE_ENABLE_ATOMIC_WRITE
43932: # define DIRECT_MODE 0
43933: assert( isDirectMode==0 );
43934: UNUSED_PARAMETER(isDirectMode);
43935: #else
43936: # define DIRECT_MODE isDirectMode
43937: #endif
43938:
43939: if( !pPager->changeCountDone && pPager->dbSize>0 ){
43940: PgHdr *pPgHdr; /* Reference to page 1 */
43941:
43942: assert( !pPager->tempFile && isOpen(pPager->fd) );
43943:
43944: /* Open page 1 of the file for writing. */
43945: rc = sqlite3PagerGet(pPager, 1, &pPgHdr);
43946: assert( pPgHdr==0 || rc==SQLITE_OK );
43947:
43948: /* If page one was fetched successfully, and this function is not
43949: ** operating in direct-mode, make page 1 writable. When not in
43950: ** direct mode, page 1 is always held in cache and hence the PagerGet()
43951: ** above is always successful - hence the ALWAYS on rc==SQLITE_OK.
43952: */
43953: if( !DIRECT_MODE && ALWAYS(rc==SQLITE_OK) ){
43954: rc = sqlite3PagerWrite(pPgHdr);
43955: }
43956:
43957: if( rc==SQLITE_OK ){
43958: /* Actually do the update of the change counter */
43959: pager_write_changecounter(pPgHdr);
43960:
43961: /* If running in direct mode, write the contents of page 1 to the file. */
43962: if( DIRECT_MODE ){
43963: const void *zBuf;
43964: assert( pPager->dbFileSize>0 );
43965: CODEC2(pPager, pPgHdr->pData, 1, 6, rc=SQLITE_NOMEM, zBuf);
43966: if( rc==SQLITE_OK ){
43967: rc = sqlite3OsWrite(pPager->fd, zBuf, pPager->pageSize, 0);
43968: }
43969: if( rc==SQLITE_OK ){
43970: pPager->changeCountDone = 1;
43971: }
43972: }else{
43973: pPager->changeCountDone = 1;
43974: }
43975: }
43976:
43977: /* Release the page reference. */
43978: sqlite3PagerUnref(pPgHdr);
43979: }
43980: return rc;
43981: }
43982:
43983: /*
43984: ** Sync the database file to disk. This is a no-op for in-memory databases
43985: ** or pages with the Pager.noSync flag set.
43986: **
43987: ** If successful, or if called on a pager for which it is a no-op, this
43988: ** function returns SQLITE_OK. Otherwise, an IO error code is returned.
43989: */
43990: SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager){
43991: int rc = SQLITE_OK;
43992: if( !pPager->noSync ){
43993: assert( !MEMDB );
43994: rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
43995: }else if( isOpen(pPager->fd) ){
43996: assert( !MEMDB );
43997: rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC_OMITTED, 0);
43998: if( rc==SQLITE_NOTFOUND ){
43999: rc = SQLITE_OK;
44000: }
44001: }
44002: return rc;
44003: }
44004:
44005: /*
44006: ** This function may only be called while a write-transaction is active in
44007: ** rollback. If the connection is in WAL mode, this call is a no-op.
44008: ** Otherwise, if the connection does not already have an EXCLUSIVE lock on
44009: ** the database file, an attempt is made to obtain one.
44010: **
44011: ** If the EXCLUSIVE lock is already held or the attempt to obtain it is
44012: ** successful, or the connection is in WAL mode, SQLITE_OK is returned.
44013: ** Otherwise, either SQLITE_BUSY or an SQLITE_IOERR_XXX error code is
44014: ** returned.
44015: */
44016: SQLITE_PRIVATE int sqlite3PagerExclusiveLock(Pager *pPager){
44017: int rc = SQLITE_OK;
44018: assert( pPager->eState==PAGER_WRITER_CACHEMOD
44019: || pPager->eState==PAGER_WRITER_DBMOD
44020: || pPager->eState==PAGER_WRITER_LOCKED
44021: );
44022: assert( assert_pager_state(pPager) );
44023: if( 0==pagerUseWal(pPager) ){
44024: rc = pager_wait_on_lock(pPager, EXCLUSIVE_LOCK);
44025: }
44026: return rc;
44027: }
44028:
44029: /*
44030: ** Sync the database file for the pager pPager. zMaster points to the name
44031: ** of a master journal file that should be written into the individual
44032: ** journal file. zMaster may be NULL, which is interpreted as no master
44033: ** journal (a single database transaction).
44034: **
44035: ** This routine ensures that:
44036: **
44037: ** * The database file change-counter is updated,
44038: ** * the journal is synced (unless the atomic-write optimization is used),
44039: ** * all dirty pages are written to the database file,
44040: ** * the database file is truncated (if required), and
44041: ** * the database file synced.
44042: **
44043: ** The only thing that remains to commit the transaction is to finalize
44044: ** (delete, truncate or zero the first part of) the journal file (or
44045: ** delete the master journal file if specified).
44046: **
44047: ** Note that if zMaster==NULL, this does not overwrite a previous value
44048: ** passed to an sqlite3PagerCommitPhaseOne() call.
44049: **
44050: ** If the final parameter - noSync - is true, then the database file itself
44051: ** is not synced. The caller must call sqlite3PagerSync() directly to
44052: ** sync the database file before calling CommitPhaseTwo() to delete the
44053: ** journal file in this case.
44054: */
44055: SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(
44056: Pager *pPager, /* Pager object */
44057: const char *zMaster, /* If not NULL, the master journal name */
44058: int noSync /* True to omit the xSync on the db file */
44059: ){
44060: int rc = SQLITE_OK; /* Return code */
44061:
44062: assert( pPager->eState==PAGER_WRITER_LOCKED
44063: || pPager->eState==PAGER_WRITER_CACHEMOD
44064: || pPager->eState==PAGER_WRITER_DBMOD
44065: || pPager->eState==PAGER_ERROR
44066: );
44067: assert( assert_pager_state(pPager) );
44068:
44069: /* If a prior error occurred, report that error again. */
44070: if( NEVER(pPager->errCode) ) return pPager->errCode;
44071:
44072: PAGERTRACE(("DATABASE SYNC: File=%s zMaster=%s nSize=%d\n",
44073: pPager->zFilename, zMaster, pPager->dbSize));
44074:
44075: /* If no database changes have been made, return early. */
44076: if( pPager->eState<PAGER_WRITER_CACHEMOD ) return SQLITE_OK;
44077:
44078: if( MEMDB ){
44079: /* If this is an in-memory db, or no pages have been written to, or this
44080: ** function has already been called, it is mostly a no-op. However, any
44081: ** backup in progress needs to be restarted.
44082: */
44083: sqlite3BackupRestart(pPager->pBackup);
44084: }else{
44085: if( pagerUseWal(pPager) ){
44086: PgHdr *pList = sqlite3PcacheDirtyList(pPager->pPCache);
44087: PgHdr *pPageOne = 0;
44088: if( pList==0 ){
44089: /* Must have at least one page for the WAL commit flag.
44090: ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
44091: rc = sqlite3PagerGet(pPager, 1, &pPageOne);
44092: pList = pPageOne;
44093: pList->pDirty = 0;
44094: }
44095: assert( rc==SQLITE_OK );
44096: if( ALWAYS(pList) ){
44097: rc = pagerWalFrames(pPager, pList, pPager->dbSize, 1);
44098: }
44099: sqlite3PagerUnref(pPageOne);
44100: if( rc==SQLITE_OK ){
44101: sqlite3PcacheCleanAll(pPager->pPCache);
44102: }
44103: }else{
44104: /* The following block updates the change-counter. Exactly how it
44105: ** does this depends on whether or not the atomic-update optimization
44106: ** was enabled at compile time, and if this transaction meets the
44107: ** runtime criteria to use the operation:
44108: **
44109: ** * The file-system supports the atomic-write property for
44110: ** blocks of size page-size, and
44111: ** * This commit is not part of a multi-file transaction, and
44112: ** * Exactly one page has been modified and store in the journal file.
44113: **
44114: ** If the optimization was not enabled at compile time, then the
44115: ** pager_incr_changecounter() function is called to update the change
44116: ** counter in 'indirect-mode'. If the optimization is compiled in but
44117: ** is not applicable to this transaction, call sqlite3JournalCreate()
44118: ** to make sure the journal file has actually been created, then call
44119: ** pager_incr_changecounter() to update the change-counter in indirect
44120: ** mode.
44121: **
44122: ** Otherwise, if the optimization is both enabled and applicable,
44123: ** then call pager_incr_changecounter() to update the change-counter
44124: ** in 'direct' mode. In this case the journal file will never be
44125: ** created for this transaction.
44126: */
44127: #ifdef SQLITE_ENABLE_ATOMIC_WRITE
44128: PgHdr *pPg;
44129: assert( isOpen(pPager->jfd)
44130: || pPager->journalMode==PAGER_JOURNALMODE_OFF
44131: || pPager->journalMode==PAGER_JOURNALMODE_WAL
44132: );
44133: if( !zMaster && isOpen(pPager->jfd)
44134: && pPager->journalOff==jrnlBufferSize(pPager)
44135: && pPager->dbSize>=pPager->dbOrigSize
44136: && (0==(pPg = sqlite3PcacheDirtyList(pPager->pPCache)) || 0==pPg->pDirty)
44137: ){
44138: /* Update the db file change counter via the direct-write method. The
44139: ** following call will modify the in-memory representation of page 1
44140: ** to include the updated change counter and then write page 1
44141: ** directly to the database file. Because of the atomic-write
44142: ** property of the host file-system, this is safe.
44143: */
44144: rc = pager_incr_changecounter(pPager, 1);
44145: }else{
44146: rc = sqlite3JournalCreate(pPager->jfd);
44147: if( rc==SQLITE_OK ){
44148: rc = pager_incr_changecounter(pPager, 0);
44149: }
44150: }
44151: #else
44152: rc = pager_incr_changecounter(pPager, 0);
44153: #endif
44154: if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44155:
44156: /* If this transaction has made the database smaller, then all pages
44157: ** being discarded by the truncation must be written to the journal
44158: ** file. This can only happen in auto-vacuum mode.
44159: **
44160: ** Before reading the pages with page numbers larger than the
44161: ** current value of Pager.dbSize, set dbSize back to the value
44162: ** that it took at the start of the transaction. Otherwise, the
44163: ** calls to sqlite3PagerGet() return zeroed pages instead of
44164: ** reading data from the database file.
44165: */
44166: #ifndef SQLITE_OMIT_AUTOVACUUM
44167: if( pPager->dbSize<pPager->dbOrigSize
44168: && pPager->journalMode!=PAGER_JOURNALMODE_OFF
44169: ){
44170: Pgno i; /* Iterator variable */
44171: const Pgno iSkip = PAGER_MJ_PGNO(pPager); /* Pending lock page */
44172: const Pgno dbSize = pPager->dbSize; /* Database image size */
44173: pPager->dbSize = pPager->dbOrigSize;
44174: for( i=dbSize+1; i<=pPager->dbOrigSize; i++ ){
44175: if( !sqlite3BitvecTest(pPager->pInJournal, i) && i!=iSkip ){
44176: PgHdr *pPage; /* Page to journal */
44177: rc = sqlite3PagerGet(pPager, i, &pPage);
44178: if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44179: rc = sqlite3PagerWrite(pPage);
44180: sqlite3PagerUnref(pPage);
44181: if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44182: }
44183: }
44184: pPager->dbSize = dbSize;
44185: }
44186: #endif
44187:
44188: /* Write the master journal name into the journal file. If a master
44189: ** journal file name has already been written to the journal file,
44190: ** or if zMaster is NULL (no master journal), then this call is a no-op.
44191: */
44192: rc = writeMasterJournal(pPager, zMaster);
44193: if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44194:
44195: /* Sync the journal file and write all dirty pages to the database.
44196: ** If the atomic-update optimization is being used, this sync will not
44197: ** create the journal file or perform any real IO.
44198: **
44199: ** Because the change-counter page was just modified, unless the
44200: ** atomic-update optimization is used it is almost certain that the
44201: ** journal requires a sync here. However, in locking_mode=exclusive
44202: ** on a system under memory pressure it is just possible that this is
44203: ** not the case. In this case it is likely enough that the redundant
44204: ** xSync() call will be changed to a no-op by the OS anyhow.
44205: */
44206: rc = syncJournal(pPager, 0);
44207: if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44208:
44209: rc = pager_write_pagelist(pPager,sqlite3PcacheDirtyList(pPager->pPCache));
44210: if( rc!=SQLITE_OK ){
44211: assert( rc!=SQLITE_IOERR_BLOCKED );
44212: goto commit_phase_one_exit;
44213: }
44214: sqlite3PcacheCleanAll(pPager->pPCache);
44215:
44216: /* If the file on disk is not the same size as the database image,
44217: ** then use pager_truncate to grow or shrink the file here.
44218: */
44219: if( pPager->dbSize!=pPager->dbFileSize ){
44220: Pgno nNew = pPager->dbSize - (pPager->dbSize==PAGER_MJ_PGNO(pPager));
44221: assert( pPager->eState==PAGER_WRITER_DBMOD );
44222: rc = pager_truncate(pPager, nNew);
44223: if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
44224: }
44225:
44226: /* Finally, sync the database file. */
44227: if( !noSync ){
44228: rc = sqlite3PagerSync(pPager);
44229: }
44230: IOTRACE(("DBSYNC %p\n", pPager))
44231: }
44232: }
44233:
44234: commit_phase_one_exit:
44235: if( rc==SQLITE_OK && !pagerUseWal(pPager) ){
44236: pPager->eState = PAGER_WRITER_FINISHED;
44237: }
44238: return rc;
44239: }
44240:
44241:
44242: /*
44243: ** When this function is called, the database file has been completely
44244: ** updated to reflect the changes made by the current transaction and
44245: ** synced to disk. The journal file still exists in the file-system
44246: ** though, and if a failure occurs at this point it will eventually
44247: ** be used as a hot-journal and the current transaction rolled back.
44248: **
44249: ** This function finalizes the journal file, either by deleting,
44250: ** truncating or partially zeroing it, so that it cannot be used
44251: ** for hot-journal rollback. Once this is done the transaction is
44252: ** irrevocably committed.
44253: **
44254: ** If an error occurs, an IO error code is returned and the pager
44255: ** moves into the error state. Otherwise, SQLITE_OK is returned.
44256: */
44257: SQLITE_PRIVATE int sqlite3PagerCommitPhaseTwo(Pager *pPager){
44258: int rc = SQLITE_OK; /* Return code */
44259:
44260: /* This routine should not be called if a prior error has occurred.
44261: ** But if (due to a coding error elsewhere in the system) it does get
44262: ** called, just return the same error code without doing anything. */
44263: if( NEVER(pPager->errCode) ) return pPager->errCode;
44264:
44265: assert( pPager->eState==PAGER_WRITER_LOCKED
44266: || pPager->eState==PAGER_WRITER_FINISHED
44267: || (pagerUseWal(pPager) && pPager->eState==PAGER_WRITER_CACHEMOD)
44268: );
44269: assert( assert_pager_state(pPager) );
44270:
44271: /* An optimization. If the database was not actually modified during
44272: ** this transaction, the pager is running in exclusive-mode and is
44273: ** using persistent journals, then this function is a no-op.
44274: **
44275: ** The start of the journal file currently contains a single journal
44276: ** header with the nRec field set to 0. If such a journal is used as
44277: ** a hot-journal during hot-journal rollback, 0 changes will be made
44278: ** to the database file. So there is no need to zero the journal
44279: ** header. Since the pager is in exclusive mode, there is no need
44280: ** to drop any locks either.
44281: */
44282: if( pPager->eState==PAGER_WRITER_LOCKED
44283: && pPager->exclusiveMode
44284: && pPager->journalMode==PAGER_JOURNALMODE_PERSIST
44285: ){
44286: assert( pPager->journalOff==JOURNAL_HDR_SZ(pPager) || !pPager->journalOff );
44287: pPager->eState = PAGER_READER;
44288: return SQLITE_OK;
44289: }
44290:
44291: PAGERTRACE(("COMMIT %d\n", PAGERID(pPager)));
44292: rc = pager_end_transaction(pPager, pPager->setMaster);
44293: return pager_error(pPager, rc);
44294: }
44295:
44296: /*
44297: ** If a write transaction is open, then all changes made within the
44298: ** transaction are reverted and the current write-transaction is closed.
44299: ** The pager falls back to PAGER_READER state if successful, or PAGER_ERROR
44300: ** state if an error occurs.
44301: **
44302: ** If the pager is already in PAGER_ERROR state when this function is called,
44303: ** it returns Pager.errCode immediately. No work is performed in this case.
44304: **
44305: ** Otherwise, in rollback mode, this function performs two functions:
44306: **
44307: ** 1) It rolls back the journal file, restoring all database file and
44308: ** in-memory cache pages to the state they were in when the transaction
44309: ** was opened, and
44310: **
44311: ** 2) It finalizes the journal file, so that it is not used for hot
44312: ** rollback at any point in the future.
44313: **
44314: ** Finalization of the journal file (task 2) is only performed if the
44315: ** rollback is successful.
44316: **
44317: ** In WAL mode, all cache-entries containing data modified within the
44318: ** current transaction are either expelled from the cache or reverted to
44319: ** their pre-transaction state by re-reading data from the database or
44320: ** WAL files. The WAL transaction is then closed.
44321: */
44322: SQLITE_PRIVATE int sqlite3PagerRollback(Pager *pPager){
44323: int rc = SQLITE_OK; /* Return code */
44324: PAGERTRACE(("ROLLBACK %d\n", PAGERID(pPager)));
44325:
44326: /* PagerRollback() is a no-op if called in READER or OPEN state. If
44327: ** the pager is already in the ERROR state, the rollback is not
44328: ** attempted here. Instead, the error code is returned to the caller.
44329: */
44330: assert( assert_pager_state(pPager) );
44331: if( pPager->eState==PAGER_ERROR ) return pPager->errCode;
44332: if( pPager->eState<=PAGER_READER ) return SQLITE_OK;
44333:
44334: if( pagerUseWal(pPager) ){
44335: int rc2;
44336: rc = sqlite3PagerSavepoint(pPager, SAVEPOINT_ROLLBACK, -1);
44337: rc2 = pager_end_transaction(pPager, pPager->setMaster);
44338: if( rc==SQLITE_OK ) rc = rc2;
44339: }else if( !isOpen(pPager->jfd) || pPager->eState==PAGER_WRITER_LOCKED ){
44340: int eState = pPager->eState;
44341: rc = pager_end_transaction(pPager, 0);
44342: if( !MEMDB && eState>PAGER_WRITER_LOCKED ){
44343: /* This can happen using journal_mode=off. Move the pager to the error
44344: ** state to indicate that the contents of the cache may not be trusted.
44345: ** Any active readers will get SQLITE_ABORT.
44346: */
44347: pPager->errCode = SQLITE_ABORT;
44348: pPager->eState = PAGER_ERROR;
44349: return rc;
44350: }
44351: }else{
44352: rc = pager_playback(pPager, 0);
44353: }
44354:
44355: assert( pPager->eState==PAGER_READER || rc!=SQLITE_OK );
44356: assert( rc==SQLITE_OK || rc==SQLITE_FULL
44357: || rc==SQLITE_NOMEM || (rc&0xFF)==SQLITE_IOERR );
44358:
44359: /* If an error occurs during a ROLLBACK, we can no longer trust the pager
44360: ** cache. So call pager_error() on the way out to make any error persistent.
44361: */
44362: return pager_error(pPager, rc);
44363: }
44364:
44365: /*
44366: ** Return TRUE if the database file is opened read-only. Return FALSE
44367: ** if the database is (in theory) writable.
44368: */
44369: SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager *pPager){
44370: return pPager->readOnly;
44371: }
44372:
44373: /*
44374: ** Return the number of references to the pager.
44375: */
44376: SQLITE_PRIVATE int sqlite3PagerRefcount(Pager *pPager){
44377: return sqlite3PcacheRefCount(pPager->pPCache);
44378: }
44379:
44380: /*
44381: ** Return the approximate number of bytes of memory currently
44382: ** used by the pager and its associated cache.
44383: */
44384: SQLITE_PRIVATE int sqlite3PagerMemUsed(Pager *pPager){
44385: int perPageSize = pPager->pageSize + pPager->nExtra + sizeof(PgHdr)
44386: + 5*sizeof(void*);
44387: return perPageSize*sqlite3PcachePagecount(pPager->pPCache)
44388: + sqlite3MallocSize(pPager)
44389: + pPager->pageSize;
44390: }
44391:
44392: /*
44393: ** Return the number of references to the specified page.
44394: */
44395: SQLITE_PRIVATE int sqlite3PagerPageRefcount(DbPage *pPage){
44396: return sqlite3PcachePageRefcount(pPage);
44397: }
44398:
44399: #ifdef SQLITE_TEST
44400: /*
44401: ** This routine is used for testing and analysis only.
44402: */
44403: SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){
44404: static int a[11];
44405: a[0] = sqlite3PcacheRefCount(pPager->pPCache);
44406: a[1] = sqlite3PcachePagecount(pPager->pPCache);
44407: a[2] = sqlite3PcacheGetCachesize(pPager->pPCache);
44408: a[3] = pPager->eState==PAGER_OPEN ? -1 : (int) pPager->dbSize;
44409: a[4] = pPager->eState;
44410: a[5] = pPager->errCode;
44411: a[6] = pPager->nHit;
44412: a[7] = pPager->nMiss;
44413: a[8] = 0; /* Used to be pPager->nOvfl */
44414: a[9] = pPager->nRead;
44415: a[10] = pPager->nWrite;
44416: return a;
44417: }
44418: #endif
44419:
44420: /*
44421: ** Parameter eStat must be either SQLITE_DBSTATUS_CACHE_HIT or
44422: ** SQLITE_DBSTATUS_CACHE_MISS. Before returning, *pnVal is incremented by the
44423: ** current cache hit or miss count, according to the value of eStat. If the
44424: ** reset parameter is non-zero, the cache hit or miss count is zeroed before
44425: ** returning.
44426: */
44427: SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, int *pnVal){
44428: int *piStat;
44429:
44430: assert( eStat==SQLITE_DBSTATUS_CACHE_HIT
44431: || eStat==SQLITE_DBSTATUS_CACHE_MISS
44432: );
44433: if( eStat==SQLITE_DBSTATUS_CACHE_HIT ){
44434: piStat = &pPager->nHit;
44435: }else{
44436: piStat = &pPager->nMiss;
44437: }
44438:
44439: *pnVal += *piStat;
44440: if( reset ){
44441: *piStat = 0;
44442: }
44443: }
44444:
44445: /*
44446: ** Return true if this is an in-memory pager.
44447: */
44448: SQLITE_PRIVATE int sqlite3PagerIsMemdb(Pager *pPager){
44449: return MEMDB;
44450: }
44451:
44452: /*
44453: ** Check that there are at least nSavepoint savepoints open. If there are
44454: ** currently less than nSavepoints open, then open one or more savepoints
44455: ** to make up the difference. If the number of savepoints is already
44456: ** equal to nSavepoint, then this function is a no-op.
44457: **
44458: ** If a memory allocation fails, SQLITE_NOMEM is returned. If an error
44459: ** occurs while opening the sub-journal file, then an IO error code is
44460: ** returned. Otherwise, SQLITE_OK.
44461: */
44462: SQLITE_PRIVATE int sqlite3PagerOpenSavepoint(Pager *pPager, int nSavepoint){
44463: int rc = SQLITE_OK; /* Return code */
44464: int nCurrent = pPager->nSavepoint; /* Current number of savepoints */
44465:
44466: assert( pPager->eState>=PAGER_WRITER_LOCKED );
44467: assert( assert_pager_state(pPager) );
44468:
44469: if( nSavepoint>nCurrent && pPager->useJournal ){
44470: int ii; /* Iterator variable */
44471: PagerSavepoint *aNew; /* New Pager.aSavepoint array */
44472:
44473: /* Grow the Pager.aSavepoint array using realloc(). Return SQLITE_NOMEM
44474: ** if the allocation fails. Otherwise, zero the new portion in case a
44475: ** malloc failure occurs while populating it in the for(...) loop below.
44476: */
44477: aNew = (PagerSavepoint *)sqlite3Realloc(
44478: pPager->aSavepoint, sizeof(PagerSavepoint)*nSavepoint
44479: );
44480: if( !aNew ){
44481: return SQLITE_NOMEM;
44482: }
44483: memset(&aNew[nCurrent], 0, (nSavepoint-nCurrent) * sizeof(PagerSavepoint));
44484: pPager->aSavepoint = aNew;
44485:
44486: /* Populate the PagerSavepoint structures just allocated. */
44487: for(ii=nCurrent; ii<nSavepoint; ii++){
44488: aNew[ii].nOrig = pPager->dbSize;
44489: if( isOpen(pPager->jfd) && pPager->journalOff>0 ){
44490: aNew[ii].iOffset = pPager->journalOff;
44491: }else{
44492: aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
44493: }
44494: aNew[ii].iSubRec = pPager->nSubRec;
44495: aNew[ii].pInSavepoint = sqlite3BitvecCreate(pPager->dbSize);
44496: if( !aNew[ii].pInSavepoint ){
44497: return SQLITE_NOMEM;
44498: }
44499: if( pagerUseWal(pPager) ){
44500: sqlite3WalSavepoint(pPager->pWal, aNew[ii].aWalData);
44501: }
44502: pPager->nSavepoint = ii+1;
44503: }
44504: assert( pPager->nSavepoint==nSavepoint );
44505: assertTruncateConstraint(pPager);
44506: }
44507:
44508: return rc;
44509: }
44510:
44511: /*
44512: ** This function is called to rollback or release (commit) a savepoint.
44513: ** The savepoint to release or rollback need not be the most recently
44514: ** created savepoint.
44515: **
44516: ** Parameter op is always either SAVEPOINT_ROLLBACK or SAVEPOINT_RELEASE.
44517: ** If it is SAVEPOINT_RELEASE, then release and destroy the savepoint with
44518: ** index iSavepoint. If it is SAVEPOINT_ROLLBACK, then rollback all changes
44519: ** that have occurred since the specified savepoint was created.
44520: **
44521: ** The savepoint to rollback or release is identified by parameter
44522: ** iSavepoint. A value of 0 means to operate on the outermost savepoint
44523: ** (the first created). A value of (Pager.nSavepoint-1) means operate
44524: ** on the most recently created savepoint. If iSavepoint is greater than
44525: ** (Pager.nSavepoint-1), then this function is a no-op.
44526: **
44527: ** If a negative value is passed to this function, then the current
44528: ** transaction is rolled back. This is different to calling
44529: ** sqlite3PagerRollback() because this function does not terminate
44530: ** the transaction or unlock the database, it just restores the
44531: ** contents of the database to its original state.
44532: **
44533: ** In any case, all savepoints with an index greater than iSavepoint
44534: ** are destroyed. If this is a release operation (op==SAVEPOINT_RELEASE),
44535: ** then savepoint iSavepoint is also destroyed.
44536: **
44537: ** This function may return SQLITE_NOMEM if a memory allocation fails,
44538: ** or an IO error code if an IO error occurs while rolling back a
44539: ** savepoint. If no errors occur, SQLITE_OK is returned.
44540: */
44541: SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
44542: int rc = pPager->errCode; /* Return code */
44543:
44544: assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
44545: assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
44546:
44547: if( rc==SQLITE_OK && iSavepoint<pPager->nSavepoint ){
44548: int ii; /* Iterator variable */
44549: int nNew; /* Number of remaining savepoints after this op. */
44550:
44551: /* Figure out how many savepoints will still be active after this
44552: ** operation. Store this value in nNew. Then free resources associated
44553: ** with any savepoints that are destroyed by this operation.
44554: */
44555: nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
44556: for(ii=nNew; ii<pPager->nSavepoint; ii++){
44557: sqlite3BitvecDestroy(pPager->aSavepoint[ii].pInSavepoint);
44558: }
44559: pPager->nSavepoint = nNew;
44560:
44561: /* If this is a release of the outermost savepoint, truncate
44562: ** the sub-journal to zero bytes in size. */
44563: if( op==SAVEPOINT_RELEASE ){
44564: if( nNew==0 && isOpen(pPager->sjfd) ){
44565: /* Only truncate if it is an in-memory sub-journal. */
44566: if( sqlite3IsMemJournal(pPager->sjfd) ){
44567: rc = sqlite3OsTruncate(pPager->sjfd, 0);
44568: assert( rc==SQLITE_OK );
44569: }
44570: pPager->nSubRec = 0;
44571: }
44572: }
44573: /* Else this is a rollback operation, playback the specified savepoint.
44574: ** If this is a temp-file, it is possible that the journal file has
44575: ** not yet been opened. In this case there have been no changes to
44576: ** the database file, so the playback operation can be skipped.
44577: */
44578: else if( pagerUseWal(pPager) || isOpen(pPager->jfd) ){
44579: PagerSavepoint *pSavepoint = (nNew==0)?0:&pPager->aSavepoint[nNew-1];
44580: rc = pagerPlaybackSavepoint(pPager, pSavepoint);
44581: assert(rc!=SQLITE_DONE);
44582: }
44583: }
44584:
44585: return rc;
44586: }
44587:
44588: /*
44589: ** Return the full pathname of the database file.
44590: */
44591: SQLITE_PRIVATE const char *sqlite3PagerFilename(Pager *pPager){
44592: return pPager->zFilename;
44593: }
44594:
44595: /*
44596: ** Return the VFS structure for the pager.
44597: */
44598: SQLITE_PRIVATE const sqlite3_vfs *sqlite3PagerVfs(Pager *pPager){
44599: return pPager->pVfs;
44600: }
44601:
44602: /*
44603: ** Return the file handle for the database file associated
44604: ** with the pager. This might return NULL if the file has
44605: ** not yet been opened.
44606: */
44607: SQLITE_PRIVATE sqlite3_file *sqlite3PagerFile(Pager *pPager){
44608: return pPager->fd;
44609: }
44610:
44611: /*
44612: ** Return the full pathname of the journal file.
44613: */
44614: SQLITE_PRIVATE const char *sqlite3PagerJournalname(Pager *pPager){
44615: return pPager->zJournal;
44616: }
44617:
44618: /*
44619: ** Return true if fsync() calls are disabled for this pager. Return FALSE
44620: ** if fsync()s are executed normally.
44621: */
44622: SQLITE_PRIVATE int sqlite3PagerNosync(Pager *pPager){
44623: return pPager->noSync;
44624: }
44625:
44626: #ifdef SQLITE_HAS_CODEC
44627: /*
44628: ** Set or retrieve the codec for this pager
44629: */
44630: SQLITE_PRIVATE void sqlite3PagerSetCodec(
44631: Pager *pPager,
44632: void *(*xCodec)(void*,void*,Pgno,int),
44633: void (*xCodecSizeChng)(void*,int,int),
44634: void (*xCodecFree)(void*),
44635: void *pCodec
44636: ){
44637: if( pPager->xCodecFree ) pPager->xCodecFree(pPager->pCodec);
44638: pPager->xCodec = pPager->memDb ? 0 : xCodec;
44639: pPager->xCodecSizeChng = xCodecSizeChng;
44640: pPager->xCodecFree = xCodecFree;
44641: pPager->pCodec = pCodec;
44642: pagerReportSize(pPager);
44643: }
44644: SQLITE_PRIVATE void *sqlite3PagerGetCodec(Pager *pPager){
44645: return pPager->pCodec;
44646: }
44647: #endif
44648:
44649: #ifndef SQLITE_OMIT_AUTOVACUUM
44650: /*
44651: ** Move the page pPg to location pgno in the file.
44652: **
44653: ** There must be no references to the page previously located at
44654: ** pgno (which we call pPgOld) though that page is allowed to be
44655: ** in cache. If the page previously located at pgno is not already
44656: ** in the rollback journal, it is not put there by by this routine.
44657: **
44658: ** References to the page pPg remain valid. Updating any
44659: ** meta-data associated with pPg (i.e. data stored in the nExtra bytes
44660: ** allocated along with the page) is the responsibility of the caller.
44661: **
44662: ** A transaction must be active when this routine is called. It used to be
44663: ** required that a statement transaction was not active, but this restriction
44664: ** has been removed (CREATE INDEX needs to move a page when a statement
44665: ** transaction is active).
44666: **
44667: ** If the fourth argument, isCommit, is non-zero, then this page is being
44668: ** moved as part of a database reorganization just before the transaction
44669: ** is being committed. In this case, it is guaranteed that the database page
44670: ** pPg refers to will not be written to again within this transaction.
44671: **
44672: ** This function may return SQLITE_NOMEM or an IO error code if an error
44673: ** occurs. Otherwise, it returns SQLITE_OK.
44674: */
44675: SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, int isCommit){
44676: PgHdr *pPgOld; /* The page being overwritten. */
44677: Pgno needSyncPgno = 0; /* Old value of pPg->pgno, if sync is required */
44678: int rc; /* Return code */
44679: Pgno origPgno; /* The original page number */
44680:
44681: assert( pPg->nRef>0 );
44682: assert( pPager->eState==PAGER_WRITER_CACHEMOD
44683: || pPager->eState==PAGER_WRITER_DBMOD
44684: );
44685: assert( assert_pager_state(pPager) );
44686:
44687: /* In order to be able to rollback, an in-memory database must journal
44688: ** the page we are moving from.
44689: */
44690: if( MEMDB ){
44691: rc = sqlite3PagerWrite(pPg);
44692: if( rc ) return rc;
44693: }
44694:
44695: /* If the page being moved is dirty and has not been saved by the latest
44696: ** savepoint, then save the current contents of the page into the
44697: ** sub-journal now. This is required to handle the following scenario:
44698: **
44699: ** BEGIN;
44700: ** <journal page X, then modify it in memory>
44701: ** SAVEPOINT one;
44702: ** <Move page X to location Y>
44703: ** ROLLBACK TO one;
44704: **
44705: ** If page X were not written to the sub-journal here, it would not
44706: ** be possible to restore its contents when the "ROLLBACK TO one"
44707: ** statement were is processed.
44708: **
44709: ** subjournalPage() may need to allocate space to store pPg->pgno into
44710: ** one or more savepoint bitvecs. This is the reason this function
44711: ** may return SQLITE_NOMEM.
44712: */
44713: if( pPg->flags&PGHDR_DIRTY
44714: && subjRequiresPage(pPg)
44715: && SQLITE_OK!=(rc = subjournalPage(pPg))
44716: ){
44717: return rc;
44718: }
44719:
44720: PAGERTRACE(("MOVE %d page %d (needSync=%d) moves to %d\n",
44721: PAGERID(pPager), pPg->pgno, (pPg->flags&PGHDR_NEED_SYNC)?1:0, pgno));
44722: IOTRACE(("MOVE %p %d %d\n", pPager, pPg->pgno, pgno))
44723:
44724: /* If the journal needs to be sync()ed before page pPg->pgno can
44725: ** be written to, store pPg->pgno in local variable needSyncPgno.
44726: **
44727: ** If the isCommit flag is set, there is no need to remember that
44728: ** the journal needs to be sync()ed before database page pPg->pgno
44729: ** can be written to. The caller has already promised not to write to it.
44730: */
44731: if( (pPg->flags&PGHDR_NEED_SYNC) && !isCommit ){
44732: needSyncPgno = pPg->pgno;
44733: assert( pageInJournal(pPg) || pPg->pgno>pPager->dbOrigSize );
44734: assert( pPg->flags&PGHDR_DIRTY );
44735: }
44736:
44737: /* If the cache contains a page with page-number pgno, remove it
44738: ** from its hash chain. Also, if the PGHDR_NEED_SYNC flag was set for
44739: ** page pgno before the 'move' operation, it needs to be retained
44740: ** for the page moved there.
44741: */
44742: pPg->flags &= ~PGHDR_NEED_SYNC;
44743: pPgOld = pager_lookup(pPager, pgno);
44744: assert( !pPgOld || pPgOld->nRef==1 );
44745: if( pPgOld ){
44746: pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
44747: if( MEMDB ){
44748: /* Do not discard pages from an in-memory database since we might
44749: ** need to rollback later. Just move the page out of the way. */
44750: sqlite3PcacheMove(pPgOld, pPager->dbSize+1);
44751: }else{
44752: sqlite3PcacheDrop(pPgOld);
44753: }
44754: }
44755:
44756: origPgno = pPg->pgno;
44757: sqlite3PcacheMove(pPg, pgno);
44758: sqlite3PcacheMakeDirty(pPg);
44759:
44760: /* For an in-memory database, make sure the original page continues
44761: ** to exist, in case the transaction needs to roll back. Use pPgOld
44762: ** as the original page since it has already been allocated.
44763: */
44764: if( MEMDB ){
44765: assert( pPgOld );
44766: sqlite3PcacheMove(pPgOld, origPgno);
44767: sqlite3PagerUnref(pPgOld);
44768: }
44769:
44770: if( needSyncPgno ){
44771: /* If needSyncPgno is non-zero, then the journal file needs to be
44772: ** sync()ed before any data is written to database file page needSyncPgno.
44773: ** Currently, no such page exists in the page-cache and the
44774: ** "is journaled" bitvec flag has been set. This needs to be remedied by
44775: ** loading the page into the pager-cache and setting the PGHDR_NEED_SYNC
44776: ** flag.
44777: **
44778: ** If the attempt to load the page into the page-cache fails, (due
44779: ** to a malloc() or IO failure), clear the bit in the pInJournal[]
44780: ** array. Otherwise, if the page is loaded and written again in
44781: ** this transaction, it may be written to the database file before
44782: ** it is synced into the journal file. This way, it may end up in
44783: ** the journal file twice, but that is not a problem.
44784: */
44785: PgHdr *pPgHdr;
44786: rc = sqlite3PagerGet(pPager, needSyncPgno, &pPgHdr);
44787: if( rc!=SQLITE_OK ){
44788: if( needSyncPgno<=pPager->dbOrigSize ){
44789: assert( pPager->pTmpSpace!=0 );
44790: sqlite3BitvecClear(pPager->pInJournal, needSyncPgno, pPager->pTmpSpace);
44791: }
44792: return rc;
44793: }
44794: pPgHdr->flags |= PGHDR_NEED_SYNC;
44795: sqlite3PcacheMakeDirty(pPgHdr);
44796: sqlite3PagerUnref(pPgHdr);
44797: }
44798:
44799: return SQLITE_OK;
44800: }
44801: #endif
44802:
44803: /*
44804: ** Return a pointer to the data for the specified page.
44805: */
44806: SQLITE_PRIVATE void *sqlite3PagerGetData(DbPage *pPg){
44807: assert( pPg->nRef>0 || pPg->pPager->memDb );
44808: return pPg->pData;
44809: }
44810:
44811: /*
44812: ** Return a pointer to the Pager.nExtra bytes of "extra" space
44813: ** allocated along with the specified page.
44814: */
44815: SQLITE_PRIVATE void *sqlite3PagerGetExtra(DbPage *pPg){
44816: return pPg->pExtra;
44817: }
44818:
44819: /*
44820: ** Get/set the locking-mode for this pager. Parameter eMode must be one
44821: ** of PAGER_LOCKINGMODE_QUERY, PAGER_LOCKINGMODE_NORMAL or
44822: ** PAGER_LOCKINGMODE_EXCLUSIVE. If the parameter is not _QUERY, then
44823: ** the locking-mode is set to the value specified.
44824: **
44825: ** The returned value is either PAGER_LOCKINGMODE_NORMAL or
44826: ** PAGER_LOCKINGMODE_EXCLUSIVE, indicating the current (possibly updated)
44827: ** locking-mode.
44828: */
44829: SQLITE_PRIVATE int sqlite3PagerLockingMode(Pager *pPager, int eMode){
44830: assert( eMode==PAGER_LOCKINGMODE_QUERY
44831: || eMode==PAGER_LOCKINGMODE_NORMAL
44832: || eMode==PAGER_LOCKINGMODE_EXCLUSIVE );
44833: assert( PAGER_LOCKINGMODE_QUERY<0 );
44834: assert( PAGER_LOCKINGMODE_NORMAL>=0 && PAGER_LOCKINGMODE_EXCLUSIVE>=0 );
44835: assert( pPager->exclusiveMode || 0==sqlite3WalHeapMemory(pPager->pWal) );
44836: if( eMode>=0 && !pPager->tempFile && !sqlite3WalHeapMemory(pPager->pWal) ){
44837: pPager->exclusiveMode = (u8)eMode;
44838: }
44839: return (int)pPager->exclusiveMode;
44840: }
44841:
44842: /*
44843: ** Set the journal-mode for this pager. Parameter eMode must be one of:
44844: **
44845: ** PAGER_JOURNALMODE_DELETE
44846: ** PAGER_JOURNALMODE_TRUNCATE
44847: ** PAGER_JOURNALMODE_PERSIST
44848: ** PAGER_JOURNALMODE_OFF
44849: ** PAGER_JOURNALMODE_MEMORY
44850: ** PAGER_JOURNALMODE_WAL
44851: **
44852: ** The journalmode is set to the value specified if the change is allowed.
44853: ** The change may be disallowed for the following reasons:
44854: **
44855: ** * An in-memory database can only have its journal_mode set to _OFF
44856: ** or _MEMORY.
44857: **
44858: ** * Temporary databases cannot have _WAL journalmode.
44859: **
44860: ** The returned indicate the current (possibly updated) journal-mode.
44861: */
44862: SQLITE_PRIVATE int sqlite3PagerSetJournalMode(Pager *pPager, int eMode){
44863: u8 eOld = pPager->journalMode; /* Prior journalmode */
44864:
44865: #ifdef SQLITE_DEBUG
44866: /* The print_pager_state() routine is intended to be used by the debugger
44867: ** only. We invoke it once here to suppress a compiler warning. */
44868: print_pager_state(pPager);
44869: #endif
44870:
44871:
44872: /* The eMode parameter is always valid */
44873: assert( eMode==PAGER_JOURNALMODE_DELETE
44874: || eMode==PAGER_JOURNALMODE_TRUNCATE
44875: || eMode==PAGER_JOURNALMODE_PERSIST
44876: || eMode==PAGER_JOURNALMODE_OFF
44877: || eMode==PAGER_JOURNALMODE_WAL
44878: || eMode==PAGER_JOURNALMODE_MEMORY );
44879:
44880: /* This routine is only called from the OP_JournalMode opcode, and
44881: ** the logic there will never allow a temporary file to be changed
44882: ** to WAL mode.
44883: */
44884: assert( pPager->tempFile==0 || eMode!=PAGER_JOURNALMODE_WAL );
44885:
44886: /* Do allow the journalmode of an in-memory database to be set to
44887: ** anything other than MEMORY or OFF
44888: */
44889: if( MEMDB ){
44890: assert( eOld==PAGER_JOURNALMODE_MEMORY || eOld==PAGER_JOURNALMODE_OFF );
44891: if( eMode!=PAGER_JOURNALMODE_MEMORY && eMode!=PAGER_JOURNALMODE_OFF ){
44892: eMode = eOld;
44893: }
44894: }
44895:
44896: if( eMode!=eOld ){
44897:
44898: /* Change the journal mode. */
44899: assert( pPager->eState!=PAGER_ERROR );
44900: pPager->journalMode = (u8)eMode;
44901:
44902: /* When transistioning from TRUNCATE or PERSIST to any other journal
44903: ** mode except WAL, unless the pager is in locking_mode=exclusive mode,
44904: ** delete the journal file.
44905: */
44906: assert( (PAGER_JOURNALMODE_TRUNCATE & 5)==1 );
44907: assert( (PAGER_JOURNALMODE_PERSIST & 5)==1 );
44908: assert( (PAGER_JOURNALMODE_DELETE & 5)==0 );
44909: assert( (PAGER_JOURNALMODE_MEMORY & 5)==4 );
44910: assert( (PAGER_JOURNALMODE_OFF & 5)==0 );
44911: assert( (PAGER_JOURNALMODE_WAL & 5)==5 );
44912:
44913: assert( isOpen(pPager->fd) || pPager->exclusiveMode );
44914: if( !pPager->exclusiveMode && (eOld & 5)==1 && (eMode & 1)==0 ){
44915:
44916: /* In this case we would like to delete the journal file. If it is
44917: ** not possible, then that is not a problem. Deleting the journal file
44918: ** here is an optimization only.
44919: **
44920: ** Before deleting the journal file, obtain a RESERVED lock on the
44921: ** database file. This ensures that the journal file is not deleted
44922: ** while it is in use by some other client.
44923: */
44924: sqlite3OsClose(pPager->jfd);
44925: if( pPager->eLock>=RESERVED_LOCK ){
44926: sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
44927: }else{
44928: int rc = SQLITE_OK;
44929: int state = pPager->eState;
44930: assert( state==PAGER_OPEN || state==PAGER_READER );
44931: if( state==PAGER_OPEN ){
44932: rc = sqlite3PagerSharedLock(pPager);
44933: }
44934: if( pPager->eState==PAGER_READER ){
44935: assert( rc==SQLITE_OK );
44936: rc = pagerLockDb(pPager, RESERVED_LOCK);
44937: }
44938: if( rc==SQLITE_OK ){
44939: sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
44940: }
44941: if( rc==SQLITE_OK && state==PAGER_READER ){
44942: pagerUnlockDb(pPager, SHARED_LOCK);
44943: }else if( state==PAGER_OPEN ){
44944: pager_unlock(pPager);
44945: }
44946: assert( state==pPager->eState );
44947: }
44948: }
44949: }
44950:
44951: /* Return the new journal mode */
44952: return (int)pPager->journalMode;
44953: }
44954:
44955: /*
44956: ** Return the current journal mode.
44957: */
44958: SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){
44959: return (int)pPager->journalMode;
44960: }
44961:
44962: /*
44963: ** Return TRUE if the pager is in a state where it is OK to change the
44964: ** journalmode. Journalmode changes can only happen when the database
44965: ** is unmodified.
44966: */
44967: SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
44968: assert( assert_pager_state(pPager) );
44969: if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
44970: if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0;
44971: return 1;
44972: }
44973:
44974: /*
44975: ** Get/set the size-limit used for persistent journal files.
44976: **
44977: ** Setting the size limit to -1 means no limit is enforced.
44978: ** An attempt to set a limit smaller than -1 is a no-op.
44979: */
44980: SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
44981: if( iLimit>=-1 ){
44982: pPager->journalSizeLimit = iLimit;
44983: sqlite3WalLimit(pPager->pWal, iLimit);
44984: }
44985: return pPager->journalSizeLimit;
44986: }
44987:
44988: /*
44989: ** Return a pointer to the pPager->pBackup variable. The backup module
44990: ** in backup.c maintains the content of this variable. This module
44991: ** uses it opaquely as an argument to sqlite3BackupRestart() and
44992: ** sqlite3BackupUpdate() only.
44993: */
44994: SQLITE_PRIVATE sqlite3_backup **sqlite3PagerBackupPtr(Pager *pPager){
44995: return &pPager->pBackup;
44996: }
44997:
44998: #ifndef SQLITE_OMIT_VACUUM
44999: /*
45000: ** Unless this is an in-memory or temporary database, clear the pager cache.
45001: */
45002: SQLITE_PRIVATE void sqlite3PagerClearCache(Pager *pPager){
45003: if( !MEMDB && pPager->tempFile==0 ) pager_reset(pPager);
45004: }
45005: #endif
45006:
45007: #ifndef SQLITE_OMIT_WAL
45008: /*
45009: ** This function is called when the user invokes "PRAGMA wal_checkpoint",
45010: ** "PRAGMA wal_blocking_checkpoint" or calls the sqlite3_wal_checkpoint()
45011: ** or wal_blocking_checkpoint() API functions.
45012: **
45013: ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
45014: */
45015: SQLITE_PRIVATE int sqlite3PagerCheckpoint(Pager *pPager, int eMode, int *pnLog, int *pnCkpt){
45016: int rc = SQLITE_OK;
45017: if( pPager->pWal ){
45018: rc = sqlite3WalCheckpoint(pPager->pWal, eMode,
45019: pPager->xBusyHandler, pPager->pBusyHandlerArg,
45020: pPager->ckptSyncFlags, pPager->pageSize, (u8 *)pPager->pTmpSpace,
45021: pnLog, pnCkpt
45022: );
45023: }
45024: return rc;
45025: }
45026:
45027: SQLITE_PRIVATE int sqlite3PagerWalCallback(Pager *pPager){
45028: return sqlite3WalCallback(pPager->pWal);
45029: }
45030:
45031: /*
45032: ** Return true if the underlying VFS for the given pager supports the
45033: ** primitives necessary for write-ahead logging.
45034: */
45035: SQLITE_PRIVATE int sqlite3PagerWalSupported(Pager *pPager){
45036: const sqlite3_io_methods *pMethods = pPager->fd->pMethods;
45037: return pPager->exclusiveMode || (pMethods->iVersion>=2 && pMethods->xShmMap);
45038: }
45039:
45040: /*
45041: ** Attempt to take an exclusive lock on the database file. If a PENDING lock
45042: ** is obtained instead, immediately release it.
45043: */
45044: static int pagerExclusiveLock(Pager *pPager){
45045: int rc; /* Return code */
45046:
45047: assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK );
45048: rc = pagerLockDb(pPager, EXCLUSIVE_LOCK);
45049: if( rc!=SQLITE_OK ){
45050: /* If the attempt to grab the exclusive lock failed, release the
45051: ** pending lock that may have been obtained instead. */
45052: pagerUnlockDb(pPager, SHARED_LOCK);
45053: }
45054:
45055: return rc;
45056: }
45057:
45058: /*
45059: ** Call sqlite3WalOpen() to open the WAL handle. If the pager is in
45060: ** exclusive-locking mode when this function is called, take an EXCLUSIVE
45061: ** lock on the database file and use heap-memory to store the wal-index
45062: ** in. Otherwise, use the normal shared-memory.
45063: */
45064: static int pagerOpenWal(Pager *pPager){
45065: int rc = SQLITE_OK;
45066:
45067: assert( pPager->pWal==0 && pPager->tempFile==0 );
45068: assert( pPager->eLock==SHARED_LOCK || pPager->eLock==EXCLUSIVE_LOCK || pPager->noReadlock);
45069:
45070: /* If the pager is already in exclusive-mode, the WAL module will use
45071: ** heap-memory for the wal-index instead of the VFS shared-memory
45072: ** implementation. Take the exclusive lock now, before opening the WAL
45073: ** file, to make sure this is safe.
45074: */
45075: if( pPager->exclusiveMode ){
45076: rc = pagerExclusiveLock(pPager);
45077: }
45078:
45079: /* Open the connection to the log file. If this operation fails,
45080: ** (e.g. due to malloc() failure), return an error code.
45081: */
45082: if( rc==SQLITE_OK ){
45083: rc = sqlite3WalOpen(pPager->pVfs,
45084: pPager->fd, pPager->zWal, pPager->exclusiveMode,
45085: pPager->journalSizeLimit, &pPager->pWal
45086: );
45087: }
45088:
45089: return rc;
45090: }
45091:
45092:
45093: /*
45094: ** The caller must be holding a SHARED lock on the database file to call
45095: ** this function.
45096: **
45097: ** If the pager passed as the first argument is open on a real database
45098: ** file (not a temp file or an in-memory database), and the WAL file
45099: ** is not already open, make an attempt to open it now. If successful,
45100: ** return SQLITE_OK. If an error occurs or the VFS used by the pager does
45101: ** not support the xShmXXX() methods, return an error code. *pbOpen is
45102: ** not modified in either case.
45103: **
45104: ** If the pager is open on a temp-file (or in-memory database), or if
45105: ** the WAL file is already open, set *pbOpen to 1 and return SQLITE_OK
45106: ** without doing anything.
45107: */
45108: SQLITE_PRIVATE int sqlite3PagerOpenWal(
45109: Pager *pPager, /* Pager object */
45110: int *pbOpen /* OUT: Set to true if call is a no-op */
45111: ){
45112: int rc = SQLITE_OK; /* Return code */
45113:
45114: assert( assert_pager_state(pPager) );
45115: assert( pPager->eState==PAGER_OPEN || pbOpen );
45116: assert( pPager->eState==PAGER_READER || !pbOpen );
45117: assert( pbOpen==0 || *pbOpen==0 );
45118: assert( pbOpen!=0 || (!pPager->tempFile && !pPager->pWal) );
45119:
45120: if( !pPager->tempFile && !pPager->pWal ){
45121: if( !sqlite3PagerWalSupported(pPager) ) return SQLITE_CANTOPEN;
45122:
45123: /* Close any rollback journal previously open */
45124: sqlite3OsClose(pPager->jfd);
45125:
45126: rc = pagerOpenWal(pPager);
45127: if( rc==SQLITE_OK ){
45128: pPager->journalMode = PAGER_JOURNALMODE_WAL;
45129: pPager->eState = PAGER_OPEN;
45130: }
45131: }else{
45132: *pbOpen = 1;
45133: }
45134:
45135: return rc;
45136: }
45137:
45138: /*
45139: ** This function is called to close the connection to the log file prior
45140: ** to switching from WAL to rollback mode.
45141: **
45142: ** Before closing the log file, this function attempts to take an
45143: ** EXCLUSIVE lock on the database file. If this cannot be obtained, an
45144: ** error (SQLITE_BUSY) is returned and the log connection is not closed.
45145: ** If successful, the EXCLUSIVE lock is not released before returning.
45146: */
45147: SQLITE_PRIVATE int sqlite3PagerCloseWal(Pager *pPager){
45148: int rc = SQLITE_OK;
45149:
45150: assert( pPager->journalMode==PAGER_JOURNALMODE_WAL );
45151:
45152: /* If the log file is not already open, but does exist in the file-system,
45153: ** it may need to be checkpointed before the connection can switch to
45154: ** rollback mode. Open it now so this can happen.
45155: */
45156: if( !pPager->pWal ){
45157: int logexists = 0;
45158: rc = pagerLockDb(pPager, SHARED_LOCK);
45159: if( rc==SQLITE_OK ){
45160: rc = sqlite3OsAccess(
45161: pPager->pVfs, pPager->zWal, SQLITE_ACCESS_EXISTS, &logexists
45162: );
45163: }
45164: if( rc==SQLITE_OK && logexists ){
45165: rc = pagerOpenWal(pPager);
45166: }
45167: }
45168:
45169: /* Checkpoint and close the log. Because an EXCLUSIVE lock is held on
45170: ** the database file, the log and log-summary files will be deleted.
45171: */
45172: if( rc==SQLITE_OK && pPager->pWal ){
45173: rc = pagerExclusiveLock(pPager);
45174: if( rc==SQLITE_OK ){
45175: rc = sqlite3WalClose(pPager->pWal, pPager->ckptSyncFlags,
45176: pPager->pageSize, (u8*)pPager->pTmpSpace);
45177: pPager->pWal = 0;
45178: }
45179: }
45180: return rc;
45181: }
45182:
45183: #ifdef SQLITE_HAS_CODEC
45184: /*
45185: ** This function is called by the wal module when writing page content
45186: ** into the log file.
45187: **
45188: ** This function returns a pointer to a buffer containing the encrypted
45189: ** page content. If a malloc fails, this function may return NULL.
45190: */
45191: SQLITE_PRIVATE void *sqlite3PagerCodec(PgHdr *pPg){
45192: void *aData = 0;
45193: CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData);
45194: return aData;
45195: }
45196: #endif /* SQLITE_HAS_CODEC */
45197:
45198: #endif /* !SQLITE_OMIT_WAL */
45199:
45200: #endif /* SQLITE_OMIT_DISKIO */
45201:
45202: /************** End of pager.c ***********************************************/
45203: /************** Begin file wal.c *********************************************/
45204: /*
45205: ** 2010 February 1
45206: **
45207: ** The author disclaims copyright to this source code. In place of
45208: ** a legal notice, here is a blessing:
45209: **
45210: ** May you do good and not evil.
45211: ** May you find forgiveness for yourself and forgive others.
45212: ** May you share freely, never taking more than you give.
45213: **
45214: *************************************************************************
45215: **
45216: ** This file contains the implementation of a write-ahead log (WAL) used in
45217: ** "journal_mode=WAL" mode.
45218: **
45219: ** WRITE-AHEAD LOG (WAL) FILE FORMAT
45220: **
45221: ** A WAL file consists of a header followed by zero or more "frames".
45222: ** Each frame records the revised content of a single page from the
45223: ** database file. All changes to the database are recorded by writing
45224: ** frames into the WAL. Transactions commit when a frame is written that
45225: ** contains a commit marker. A single WAL can and usually does record
45226: ** multiple transactions. Periodically, the content of the WAL is
45227: ** transferred back into the database file in an operation called a
45228: ** "checkpoint".
45229: **
45230: ** A single WAL file can be used multiple times. In other words, the
45231: ** WAL can fill up with frames and then be checkpointed and then new
45232: ** frames can overwrite the old ones. A WAL always grows from beginning
45233: ** toward the end. Checksums and counters attached to each frame are
45234: ** used to determine which frames within the WAL are valid and which
45235: ** are leftovers from prior checkpoints.
45236: **
45237: ** The WAL header is 32 bytes in size and consists of the following eight
45238: ** big-endian 32-bit unsigned integer values:
45239: **
45240: ** 0: Magic number. 0x377f0682 or 0x377f0683
45241: ** 4: File format version. Currently 3007000
45242: ** 8: Database page size. Example: 1024
45243: ** 12: Checkpoint sequence number
45244: ** 16: Salt-1, random integer incremented with each checkpoint
45245: ** 20: Salt-2, a different random integer changing with each ckpt
45246: ** 24: Checksum-1 (first part of checksum for first 24 bytes of header).
45247: ** 28: Checksum-2 (second part of checksum for first 24 bytes of header).
45248: **
45249: ** Immediately following the wal-header are zero or more frames. Each
45250: ** frame consists of a 24-byte frame-header followed by a <page-size> bytes
45251: ** of page data. The frame-header is six big-endian 32-bit unsigned
45252: ** integer values, as follows:
45253: **
45254: ** 0: Page number.
45255: ** 4: For commit records, the size of the database image in pages
45256: ** after the commit. For all other records, zero.
45257: ** 8: Salt-1 (copied from the header)
45258: ** 12: Salt-2 (copied from the header)
45259: ** 16: Checksum-1.
45260: ** 20: Checksum-2.
45261: **
45262: ** A frame is considered valid if and only if the following conditions are
45263: ** true:
45264: **
45265: ** (1) The salt-1 and salt-2 values in the frame-header match
45266: ** salt values in the wal-header
45267: **
45268: ** (2) The checksum values in the final 8 bytes of the frame-header
45269: ** exactly match the checksum computed consecutively on the
45270: ** WAL header and the first 8 bytes and the content of all frames
45271: ** up to and including the current frame.
45272: **
45273: ** The checksum is computed using 32-bit big-endian integers if the
45274: ** magic number in the first 4 bytes of the WAL is 0x377f0683 and it
45275: ** is computed using little-endian if the magic number is 0x377f0682.
45276: ** The checksum values are always stored in the frame header in a
45277: ** big-endian format regardless of which byte order is used to compute
45278: ** the checksum. The checksum is computed by interpreting the input as
45279: ** an even number of unsigned 32-bit integers: x[0] through x[N]. The
45280: ** algorithm used for the checksum is as follows:
45281: **
45282: ** for i from 0 to n-1 step 2:
45283: ** s0 += x[i] + s1;
45284: ** s1 += x[i+1] + s0;
45285: ** endfor
45286: **
45287: ** Note that s0 and s1 are both weighted checksums using fibonacci weights
45288: ** in reverse order (the largest fibonacci weight occurs on the first element
45289: ** of the sequence being summed.) The s1 value spans all 32-bit
45290: ** terms of the sequence whereas s0 omits the final term.
45291: **
45292: ** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the
45293: ** WAL is transferred into the database, then the database is VFS.xSync-ed.
45294: ** The VFS.xSync operations serve as write barriers - all writes launched
45295: ** before the xSync must complete before any write that launches after the
45296: ** xSync begins.
45297: **
45298: ** After each checkpoint, the salt-1 value is incremented and the salt-2
45299: ** value is randomized. This prevents old and new frames in the WAL from
45300: ** being considered valid at the same time and being checkpointing together
45301: ** following a crash.
45302: **
45303: ** READER ALGORITHM
45304: **
45305: ** To read a page from the database (call it page number P), a reader
45306: ** first checks the WAL to see if it contains page P. If so, then the
45307: ** last valid instance of page P that is a followed by a commit frame
45308: ** or is a commit frame itself becomes the value read. If the WAL
45309: ** contains no copies of page P that are valid and which are a commit
45310: ** frame or are followed by a commit frame, then page P is read from
45311: ** the database file.
45312: **
45313: ** To start a read transaction, the reader records the index of the last
45314: ** valid frame in the WAL. The reader uses this recorded "mxFrame" value
45315: ** for all subsequent read operations. New transactions can be appended
45316: ** to the WAL, but as long as the reader uses its original mxFrame value
45317: ** and ignores the newly appended content, it will see a consistent snapshot
45318: ** of the database from a single point in time. This technique allows
45319: ** multiple concurrent readers to view different versions of the database
45320: ** content simultaneously.
45321: **
45322: ** The reader algorithm in the previous paragraphs works correctly, but
45323: ** because frames for page P can appear anywhere within the WAL, the
45324: ** reader has to scan the entire WAL looking for page P frames. If the
45325: ** WAL is large (multiple megabytes is typical) that scan can be slow,
45326: ** and read performance suffers. To overcome this problem, a separate
45327: ** data structure called the wal-index is maintained to expedite the
45328: ** search for frames of a particular page.
45329: **
45330: ** WAL-INDEX FORMAT
45331: **
45332: ** Conceptually, the wal-index is shared memory, though VFS implementations
45333: ** might choose to implement the wal-index using a mmapped file. Because
45334: ** the wal-index is shared memory, SQLite does not support journal_mode=WAL
45335: ** on a network filesystem. All users of the database must be able to
45336: ** share memory.
45337: **
45338: ** The wal-index is transient. After a crash, the wal-index can (and should
45339: ** be) reconstructed from the original WAL file. In fact, the VFS is required
45340: ** to either truncate or zero the header of the wal-index when the last
45341: ** connection to it closes. Because the wal-index is transient, it can
45342: ** use an architecture-specific format; it does not have to be cross-platform.
45343: ** Hence, unlike the database and WAL file formats which store all values
45344: ** as big endian, the wal-index can store multi-byte values in the native
45345: ** byte order of the host computer.
45346: **
45347: ** The purpose of the wal-index is to answer this question quickly: Given
45348: ** a page number P, return the index of the last frame for page P in the WAL,
45349: ** or return NULL if there are no frames for page P in the WAL.
45350: **
45351: ** The wal-index consists of a header region, followed by an one or
45352: ** more index blocks.
45353: **
45354: ** The wal-index header contains the total number of frames within the WAL
45355: ** in the the mxFrame field.
45356: **
45357: ** Each index block except for the first contains information on
45358: ** HASHTABLE_NPAGE frames. The first index block contains information on
45359: ** HASHTABLE_NPAGE_ONE frames. The values of HASHTABLE_NPAGE_ONE and
45360: ** HASHTABLE_NPAGE are selected so that together the wal-index header and
45361: ** first index block are the same size as all other index blocks in the
45362: ** wal-index.
45363: **
45364: ** Each index block contains two sections, a page-mapping that contains the
45365: ** database page number associated with each wal frame, and a hash-table
45366: ** that allows readers to query an index block for a specific page number.
45367: ** The page-mapping is an array of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE
45368: ** for the first index block) 32-bit page numbers. The first entry in the
45369: ** first index-block contains the database page number corresponding to the
45370: ** first frame in the WAL file. The first entry in the second index block
45371: ** in the WAL file corresponds to the (HASHTABLE_NPAGE_ONE+1)th frame in
45372: ** the log, and so on.
45373: **
45374: ** The last index block in a wal-index usually contains less than the full
45375: ** complement of HASHTABLE_NPAGE (or HASHTABLE_NPAGE_ONE) page-numbers,
45376: ** depending on the contents of the WAL file. This does not change the
45377: ** allocated size of the page-mapping array - the page-mapping array merely
45378: ** contains unused entries.
45379: **
45380: ** Even without using the hash table, the last frame for page P
45381: ** can be found by scanning the page-mapping sections of each index block
45382: ** starting with the last index block and moving toward the first, and
45383: ** within each index block, starting at the end and moving toward the
45384: ** beginning. The first entry that equals P corresponds to the frame
45385: ** holding the content for that page.
45386: **
45387: ** The hash table consists of HASHTABLE_NSLOT 16-bit unsigned integers.
45388: ** HASHTABLE_NSLOT = 2*HASHTABLE_NPAGE, and there is one entry in the
45389: ** hash table for each page number in the mapping section, so the hash
45390: ** table is never more than half full. The expected number of collisions
45391: ** prior to finding a match is 1. Each entry of the hash table is an
45392: ** 1-based index of an entry in the mapping section of the same
45393: ** index block. Let K be the 1-based index of the largest entry in
45394: ** the mapping section. (For index blocks other than the last, K will
45395: ** always be exactly HASHTABLE_NPAGE (4096) and for the last index block
45396: ** K will be (mxFrame%HASHTABLE_NPAGE).) Unused slots of the hash table
45397: ** contain a value of 0.
45398: **
45399: ** To look for page P in the hash table, first compute a hash iKey on
45400: ** P as follows:
45401: **
45402: ** iKey = (P * 383) % HASHTABLE_NSLOT
45403: **
45404: ** Then start scanning entries of the hash table, starting with iKey
45405: ** (wrapping around to the beginning when the end of the hash table is
45406: ** reached) until an unused hash slot is found. Let the first unused slot
45407: ** be at index iUnused. (iUnused might be less than iKey if there was
45408: ** wrap-around.) Because the hash table is never more than half full,
45409: ** the search is guaranteed to eventually hit an unused entry. Let
45410: ** iMax be the value between iKey and iUnused, closest to iUnused,
45411: ** where aHash[iMax]==P. If there is no iMax entry (if there exists
45412: ** no hash slot such that aHash[i]==p) then page P is not in the
45413: ** current index block. Otherwise the iMax-th mapping entry of the
45414: ** current index block corresponds to the last entry that references
45415: ** page P.
45416: **
45417: ** A hash search begins with the last index block and moves toward the
45418: ** first index block, looking for entries corresponding to page P. On
45419: ** average, only two or three slots in each index block need to be
45420: ** examined in order to either find the last entry for page P, or to
45421: ** establish that no such entry exists in the block. Each index block
45422: ** holds over 4000 entries. So two or three index blocks are sufficient
45423: ** to cover a typical 10 megabyte WAL file, assuming 1K pages. 8 or 10
45424: ** comparisons (on average) suffice to either locate a frame in the
45425: ** WAL or to establish that the frame does not exist in the WAL. This
45426: ** is much faster than scanning the entire 10MB WAL.
45427: **
45428: ** Note that entries are added in order of increasing K. Hence, one
45429: ** reader might be using some value K0 and a second reader that started
45430: ** at a later time (after additional transactions were added to the WAL
45431: ** and to the wal-index) might be using a different value K1, where K1>K0.
45432: ** Both readers can use the same hash table and mapping section to get
45433: ** the correct result. There may be entries in the hash table with
45434: ** K>K0 but to the first reader, those entries will appear to be unused
45435: ** slots in the hash table and so the first reader will get an answer as
45436: ** if no values greater than K0 had ever been inserted into the hash table
45437: ** in the first place - which is what reader one wants. Meanwhile, the
45438: ** second reader using K1 will see additional values that were inserted
45439: ** later, which is exactly what reader two wants.
45440: **
45441: ** When a rollback occurs, the value of K is decreased. Hash table entries
45442: ** that correspond to frames greater than the new K value are removed
45443: ** from the hash table at this point.
45444: */
45445: #ifndef SQLITE_OMIT_WAL
45446:
45447:
45448: /*
45449: ** Trace output macros
45450: */
45451: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
45452: SQLITE_PRIVATE int sqlite3WalTrace = 0;
45453: # define WALTRACE(X) if(sqlite3WalTrace) sqlite3DebugPrintf X
45454: #else
45455: # define WALTRACE(X)
45456: #endif
45457:
45458: /*
45459: ** The maximum (and only) versions of the wal and wal-index formats
45460: ** that may be interpreted by this version of SQLite.
45461: **
45462: ** If a client begins recovering a WAL file and finds that (a) the checksum
45463: ** values in the wal-header are correct and (b) the version field is not
45464: ** WAL_MAX_VERSION, recovery fails and SQLite returns SQLITE_CANTOPEN.
45465: **
45466: ** Similarly, if a client successfully reads a wal-index header (i.e. the
45467: ** checksum test is successful) and finds that the version field is not
45468: ** WALINDEX_MAX_VERSION, then no read-transaction is opened and SQLite
45469: ** returns SQLITE_CANTOPEN.
45470: */
45471: #define WAL_MAX_VERSION 3007000
45472: #define WALINDEX_MAX_VERSION 3007000
45473:
45474: /*
45475: ** Indices of various locking bytes. WAL_NREADER is the number
45476: ** of available reader locks and should be at least 3.
45477: */
45478: #define WAL_WRITE_LOCK 0
45479: #define WAL_ALL_BUT_WRITE 1
45480: #define WAL_CKPT_LOCK 1
45481: #define WAL_RECOVER_LOCK 2
45482: #define WAL_READ_LOCK(I) (3+(I))
45483: #define WAL_NREADER (SQLITE_SHM_NLOCK-3)
45484:
45485:
45486: /* Object declarations */
45487: typedef struct WalIndexHdr WalIndexHdr;
45488: typedef struct WalIterator WalIterator;
45489: typedef struct WalCkptInfo WalCkptInfo;
45490:
45491:
45492: /*
45493: ** The following object holds a copy of the wal-index header content.
45494: **
45495: ** The actual header in the wal-index consists of two copies of this
45496: ** object.
45497: **
45498: ** The szPage value can be any power of 2 between 512 and 32768, inclusive.
45499: ** Or it can be 1 to represent a 65536-byte page. The latter case was
45500: ** added in 3.7.1 when support for 64K pages was added.
45501: */
45502: struct WalIndexHdr {
45503: u32 iVersion; /* Wal-index version */
45504: u32 unused; /* Unused (padding) field */
45505: u32 iChange; /* Counter incremented each transaction */
45506: u8 isInit; /* 1 when initialized */
45507: u8 bigEndCksum; /* True if checksums in WAL are big-endian */
45508: u16 szPage; /* Database page size in bytes. 1==64K */
45509: u32 mxFrame; /* Index of last valid frame in the WAL */
45510: u32 nPage; /* Size of database in pages */
45511: u32 aFrameCksum[2]; /* Checksum of last frame in log */
45512: u32 aSalt[2]; /* Two salt values copied from WAL header */
45513: u32 aCksum[2]; /* Checksum over all prior fields */
45514: };
45515:
45516: /*
45517: ** A copy of the following object occurs in the wal-index immediately
45518: ** following the second copy of the WalIndexHdr. This object stores
45519: ** information used by checkpoint.
45520: **
45521: ** nBackfill is the number of frames in the WAL that have been written
45522: ** back into the database. (We call the act of moving content from WAL to
45523: ** database "backfilling".) The nBackfill number is never greater than
45524: ** WalIndexHdr.mxFrame. nBackfill can only be increased by threads
45525: ** holding the WAL_CKPT_LOCK lock (which includes a recovery thread).
45526: ** However, a WAL_WRITE_LOCK thread can move the value of nBackfill from
45527: ** mxFrame back to zero when the WAL is reset.
45528: **
45529: ** There is one entry in aReadMark[] for each reader lock. If a reader
45530: ** holds read-lock K, then the value in aReadMark[K] is no greater than
45531: ** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff)
45532: ** for any aReadMark[] means that entry is unused. aReadMark[0] is
45533: ** a special case; its value is never used and it exists as a place-holder
45534: ** to avoid having to offset aReadMark[] indexs by one. Readers holding
45535: ** WAL_READ_LOCK(0) always ignore the entire WAL and read all content
45536: ** directly from the database.
45537: **
45538: ** The value of aReadMark[K] may only be changed by a thread that
45539: ** is holding an exclusive lock on WAL_READ_LOCK(K). Thus, the value of
45540: ** aReadMark[K] cannot changed while there is a reader is using that mark
45541: ** since the reader will be holding a shared lock on WAL_READ_LOCK(K).
45542: **
45543: ** The checkpointer may only transfer frames from WAL to database where
45544: ** the frame numbers are less than or equal to every aReadMark[] that is
45545: ** in use (that is, every aReadMark[j] for which there is a corresponding
45546: ** WAL_READ_LOCK(j)). New readers (usually) pick the aReadMark[] with the
45547: ** largest value and will increase an unused aReadMark[] to mxFrame if there
45548: ** is not already an aReadMark[] equal to mxFrame. The exception to the
45549: ** previous sentence is when nBackfill equals mxFrame (meaning that everything
45550: ** in the WAL has been backfilled into the database) then new readers
45551: ** will choose aReadMark[0] which has value 0 and hence such reader will
45552: ** get all their all content directly from the database file and ignore
45553: ** the WAL.
45554: **
45555: ** Writers normally append new frames to the end of the WAL. However,
45556: ** if nBackfill equals mxFrame (meaning that all WAL content has been
45557: ** written back into the database) and if no readers are using the WAL
45558: ** (in other words, if there are no WAL_READ_LOCK(i) where i>0) then
45559: ** the writer will first "reset" the WAL back to the beginning and start
45560: ** writing new content beginning at frame 1.
45561: **
45562: ** We assume that 32-bit loads are atomic and so no locks are needed in
45563: ** order to read from any aReadMark[] entries.
45564: */
45565: struct WalCkptInfo {
45566: u32 nBackfill; /* Number of WAL frames backfilled into DB */
45567: u32 aReadMark[WAL_NREADER]; /* Reader marks */
45568: };
45569: #define READMARK_NOT_USED 0xffffffff
45570:
45571:
45572: /* A block of WALINDEX_LOCK_RESERVED bytes beginning at
45573: ** WALINDEX_LOCK_OFFSET is reserved for locks. Since some systems
45574: ** only support mandatory file-locks, we do not read or write data
45575: ** from the region of the file on which locks are applied.
45576: */
45577: #define WALINDEX_LOCK_OFFSET (sizeof(WalIndexHdr)*2 + sizeof(WalCkptInfo))
45578: #define WALINDEX_LOCK_RESERVED 16
45579: #define WALINDEX_HDR_SIZE (WALINDEX_LOCK_OFFSET+WALINDEX_LOCK_RESERVED)
45580:
45581: /* Size of header before each frame in wal */
45582: #define WAL_FRAME_HDRSIZE 24
45583:
45584: /* Size of write ahead log header, including checksum. */
45585: /* #define WAL_HDRSIZE 24 */
45586: #define WAL_HDRSIZE 32
45587:
45588: /* WAL magic value. Either this value, or the same value with the least
45589: ** significant bit also set (WAL_MAGIC | 0x00000001) is stored in 32-bit
45590: ** big-endian format in the first 4 bytes of a WAL file.
45591: **
45592: ** If the LSB is set, then the checksums for each frame within the WAL
45593: ** file are calculated by treating all data as an array of 32-bit
45594: ** big-endian words. Otherwise, they are calculated by interpreting
45595: ** all data as 32-bit little-endian words.
45596: */
45597: #define WAL_MAGIC 0x377f0682
45598:
45599: /*
45600: ** Return the offset of frame iFrame in the write-ahead log file,
45601: ** assuming a database page size of szPage bytes. The offset returned
45602: ** is to the start of the write-ahead log frame-header.
45603: */
45604: #define walFrameOffset(iFrame, szPage) ( \
45605: WAL_HDRSIZE + ((iFrame)-1)*(i64)((szPage)+WAL_FRAME_HDRSIZE) \
45606: )
45607:
45608: /*
45609: ** An open write-ahead log file is represented by an instance of the
45610: ** following object.
45611: */
45612: struct Wal {
45613: sqlite3_vfs *pVfs; /* The VFS used to create pDbFd */
45614: sqlite3_file *pDbFd; /* File handle for the database file */
45615: sqlite3_file *pWalFd; /* File handle for WAL file */
45616: u32 iCallback; /* Value to pass to log callback (or 0) */
45617: i64 mxWalSize; /* Truncate WAL to this size upon reset */
45618: int nWiData; /* Size of array apWiData */
45619: int szFirstBlock; /* Size of first block written to WAL file */
45620: volatile u32 **apWiData; /* Pointer to wal-index content in memory */
45621: u32 szPage; /* Database page size */
45622: i16 readLock; /* Which read lock is being held. -1 for none */
45623: u8 syncFlags; /* Flags to use to sync header writes */
45624: u8 exclusiveMode; /* Non-zero if connection is in exclusive mode */
45625: u8 writeLock; /* True if in a write transaction */
45626: u8 ckptLock; /* True if holding a checkpoint lock */
45627: u8 readOnly; /* WAL_RDWR, WAL_RDONLY, or WAL_SHM_RDONLY */
45628: u8 truncateOnCommit; /* True to truncate WAL file on commit */
45629: u8 syncHeader; /* Fsync the WAL header if true */
45630: u8 padToSectorBoundary; /* Pad transactions out to the next sector */
45631: WalIndexHdr hdr; /* Wal-index header for current transaction */
45632: const char *zWalName; /* Name of WAL file */
45633: u32 nCkpt; /* Checkpoint sequence counter in the wal-header */
45634: #ifdef SQLITE_DEBUG
45635: u8 lockError; /* True if a locking error has occurred */
45636: #endif
45637: };
45638:
45639: /*
45640: ** Candidate values for Wal.exclusiveMode.
45641: */
45642: #define WAL_NORMAL_MODE 0
45643: #define WAL_EXCLUSIVE_MODE 1
45644: #define WAL_HEAPMEMORY_MODE 2
45645:
45646: /*
45647: ** Possible values for WAL.readOnly
45648: */
45649: #define WAL_RDWR 0 /* Normal read/write connection */
45650: #define WAL_RDONLY 1 /* The WAL file is readonly */
45651: #define WAL_SHM_RDONLY 2 /* The SHM file is readonly */
45652:
45653: /*
45654: ** Each page of the wal-index mapping contains a hash-table made up of
45655: ** an array of HASHTABLE_NSLOT elements of the following type.
45656: */
45657: typedef u16 ht_slot;
45658:
45659: /*
45660: ** This structure is used to implement an iterator that loops through
45661: ** all frames in the WAL in database page order. Where two or more frames
45662: ** correspond to the same database page, the iterator visits only the
45663: ** frame most recently written to the WAL (in other words, the frame with
45664: ** the largest index).
45665: **
45666: ** The internals of this structure are only accessed by:
45667: **
45668: ** walIteratorInit() - Create a new iterator,
45669: ** walIteratorNext() - Step an iterator,
45670: ** walIteratorFree() - Free an iterator.
45671: **
45672: ** This functionality is used by the checkpoint code (see walCheckpoint()).
45673: */
45674: struct WalIterator {
45675: int iPrior; /* Last result returned from the iterator */
45676: int nSegment; /* Number of entries in aSegment[] */
45677: struct WalSegment {
45678: int iNext; /* Next slot in aIndex[] not yet returned */
45679: ht_slot *aIndex; /* i0, i1, i2... such that aPgno[iN] ascend */
45680: u32 *aPgno; /* Array of page numbers. */
45681: int nEntry; /* Nr. of entries in aPgno[] and aIndex[] */
45682: int iZero; /* Frame number associated with aPgno[0] */
45683: } aSegment[1]; /* One for every 32KB page in the wal-index */
45684: };
45685:
45686: /*
45687: ** Define the parameters of the hash tables in the wal-index file. There
45688: ** is a hash-table following every HASHTABLE_NPAGE page numbers in the
45689: ** wal-index.
45690: **
45691: ** Changing any of these constants will alter the wal-index format and
45692: ** create incompatibilities.
45693: */
45694: #define HASHTABLE_NPAGE 4096 /* Must be power of 2 */
45695: #define HASHTABLE_HASH_1 383 /* Should be prime */
45696: #define HASHTABLE_NSLOT (HASHTABLE_NPAGE*2) /* Must be a power of 2 */
45697:
45698: /*
45699: ** The block of page numbers associated with the first hash-table in a
45700: ** wal-index is smaller than usual. This is so that there is a complete
45701: ** hash-table on each aligned 32KB page of the wal-index.
45702: */
45703: #define HASHTABLE_NPAGE_ONE (HASHTABLE_NPAGE - (WALINDEX_HDR_SIZE/sizeof(u32)))
45704:
45705: /* The wal-index is divided into pages of WALINDEX_PGSZ bytes each. */
45706: #define WALINDEX_PGSZ ( \
45707: sizeof(ht_slot)*HASHTABLE_NSLOT + HASHTABLE_NPAGE*sizeof(u32) \
45708: )
45709:
45710: /*
45711: ** Obtain a pointer to the iPage'th page of the wal-index. The wal-index
45712: ** is broken into pages of WALINDEX_PGSZ bytes. Wal-index pages are
45713: ** numbered from zero.
45714: **
45715: ** If this call is successful, *ppPage is set to point to the wal-index
45716: ** page and SQLITE_OK is returned. If an error (an OOM or VFS error) occurs,
45717: ** then an SQLite error code is returned and *ppPage is set to 0.
45718: */
45719: static int walIndexPage(Wal *pWal, int iPage, volatile u32 **ppPage){
45720: int rc = SQLITE_OK;
45721:
45722: /* Enlarge the pWal->apWiData[] array if required */
45723: if( pWal->nWiData<=iPage ){
45724: int nByte = sizeof(u32*)*(iPage+1);
45725: volatile u32 **apNew;
45726: apNew = (volatile u32 **)sqlite3_realloc((void *)pWal->apWiData, nByte);
45727: if( !apNew ){
45728: *ppPage = 0;
45729: return SQLITE_NOMEM;
45730: }
45731: memset((void*)&apNew[pWal->nWiData], 0,
45732: sizeof(u32*)*(iPage+1-pWal->nWiData));
45733: pWal->apWiData = apNew;
45734: pWal->nWiData = iPage+1;
45735: }
45736:
45737: /* Request a pointer to the required page from the VFS */
45738: if( pWal->apWiData[iPage]==0 ){
45739: if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
45740: pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);
45741: if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM;
45742: }else{
45743: rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ,
45744: pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]
45745: );
45746: if( rc==SQLITE_READONLY ){
45747: pWal->readOnly |= WAL_SHM_RDONLY;
45748: rc = SQLITE_OK;
45749: }
45750: }
45751: }
45752:
45753: *ppPage = pWal->apWiData[iPage];
45754: assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
45755: return rc;
45756: }
45757:
45758: /*
45759: ** Return a pointer to the WalCkptInfo structure in the wal-index.
45760: */
45761: static volatile WalCkptInfo *walCkptInfo(Wal *pWal){
45762: assert( pWal->nWiData>0 && pWal->apWiData[0] );
45763: return (volatile WalCkptInfo*)&(pWal->apWiData[0][sizeof(WalIndexHdr)/2]);
45764: }
45765:
45766: /*
45767: ** Return a pointer to the WalIndexHdr structure in the wal-index.
45768: */
45769: static volatile WalIndexHdr *walIndexHdr(Wal *pWal){
45770: assert( pWal->nWiData>0 && pWal->apWiData[0] );
45771: return (volatile WalIndexHdr*)pWal->apWiData[0];
45772: }
45773:
45774: /*
45775: ** The argument to this macro must be of type u32. On a little-endian
45776: ** architecture, it returns the u32 value that results from interpreting
45777: ** the 4 bytes as a big-endian value. On a big-endian architecture, it
45778: ** returns the value that would be produced by intepreting the 4 bytes
45779: ** of the input value as a little-endian integer.
45780: */
45781: #define BYTESWAP32(x) ( \
45782: (((x)&0x000000FF)<<24) + (((x)&0x0000FF00)<<8) \
45783: + (((x)&0x00FF0000)>>8) + (((x)&0xFF000000)>>24) \
45784: )
45785:
45786: /*
45787: ** Generate or extend an 8 byte checksum based on the data in
45788: ** array aByte[] and the initial values of aIn[0] and aIn[1] (or
45789: ** initial values of 0 and 0 if aIn==NULL).
45790: **
45791: ** The checksum is written back into aOut[] before returning.
45792: **
45793: ** nByte must be a positive multiple of 8.
45794: */
45795: static void walChecksumBytes(
45796: int nativeCksum, /* True for native byte-order, false for non-native */
45797: u8 *a, /* Content to be checksummed */
45798: int nByte, /* Bytes of content in a[]. Must be a multiple of 8. */
45799: const u32 *aIn, /* Initial checksum value input */
45800: u32 *aOut /* OUT: Final checksum value output */
45801: ){
45802: u32 s1, s2;
45803: u32 *aData = (u32 *)a;
45804: u32 *aEnd = (u32 *)&a[nByte];
45805:
45806: if( aIn ){
45807: s1 = aIn[0];
45808: s2 = aIn[1];
45809: }else{
45810: s1 = s2 = 0;
45811: }
45812:
45813: assert( nByte>=8 );
45814: assert( (nByte&0x00000007)==0 );
45815:
45816: if( nativeCksum ){
45817: do {
45818: s1 += *aData++ + s2;
45819: s2 += *aData++ + s1;
45820: }while( aData<aEnd );
45821: }else{
45822: do {
45823: s1 += BYTESWAP32(aData[0]) + s2;
45824: s2 += BYTESWAP32(aData[1]) + s1;
45825: aData += 2;
45826: }while( aData<aEnd );
45827: }
45828:
45829: aOut[0] = s1;
45830: aOut[1] = s2;
45831: }
45832:
45833: static void walShmBarrier(Wal *pWal){
45834: if( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE ){
45835: sqlite3OsShmBarrier(pWal->pDbFd);
45836: }
45837: }
45838:
45839: /*
45840: ** Write the header information in pWal->hdr into the wal-index.
45841: **
45842: ** The checksum on pWal->hdr is updated before it is written.
45843: */
45844: static void walIndexWriteHdr(Wal *pWal){
45845: volatile WalIndexHdr *aHdr = walIndexHdr(pWal);
45846: const int nCksum = offsetof(WalIndexHdr, aCksum);
45847:
45848: assert( pWal->writeLock );
45849: pWal->hdr.isInit = 1;
45850: pWal->hdr.iVersion = WALINDEX_MAX_VERSION;
45851: walChecksumBytes(1, (u8*)&pWal->hdr, nCksum, 0, pWal->hdr.aCksum);
45852: memcpy((void *)&aHdr[1], (void *)&pWal->hdr, sizeof(WalIndexHdr));
45853: walShmBarrier(pWal);
45854: memcpy((void *)&aHdr[0], (void *)&pWal->hdr, sizeof(WalIndexHdr));
45855: }
45856:
45857: /*
45858: ** This function encodes a single frame header and writes it to a buffer
45859: ** supplied by the caller. A frame-header is made up of a series of
45860: ** 4-byte big-endian integers, as follows:
45861: **
45862: ** 0: Page number.
45863: ** 4: For commit records, the size of the database image in pages
45864: ** after the commit. For all other records, zero.
45865: ** 8: Salt-1 (copied from the wal-header)
45866: ** 12: Salt-2 (copied from the wal-header)
45867: ** 16: Checksum-1.
45868: ** 20: Checksum-2.
45869: */
45870: static void walEncodeFrame(
45871: Wal *pWal, /* The write-ahead log */
45872: u32 iPage, /* Database page number for frame */
45873: u32 nTruncate, /* New db size (or 0 for non-commit frames) */
45874: u8 *aData, /* Pointer to page data */
45875: u8 *aFrame /* OUT: Write encoded frame here */
45876: ){
45877: int nativeCksum; /* True for native byte-order checksums */
45878: u32 *aCksum = pWal->hdr.aFrameCksum;
45879: assert( WAL_FRAME_HDRSIZE==24 );
45880: sqlite3Put4byte(&aFrame[0], iPage);
45881: sqlite3Put4byte(&aFrame[4], nTruncate);
45882: memcpy(&aFrame[8], pWal->hdr.aSalt, 8);
45883:
45884: nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
45885: walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
45886: walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
45887:
45888: sqlite3Put4byte(&aFrame[16], aCksum[0]);
45889: sqlite3Put4byte(&aFrame[20], aCksum[1]);
45890: }
45891:
45892: /*
45893: ** Check to see if the frame with header in aFrame[] and content
45894: ** in aData[] is valid. If it is a valid frame, fill *piPage and
45895: ** *pnTruncate and return true. Return if the frame is not valid.
45896: */
45897: static int walDecodeFrame(
45898: Wal *pWal, /* The write-ahead log */
45899: u32 *piPage, /* OUT: Database page number for frame */
45900: u32 *pnTruncate, /* OUT: New db size (or 0 if not commit) */
45901: u8 *aData, /* Pointer to page data (for checksum) */
45902: u8 *aFrame /* Frame data */
45903: ){
45904: int nativeCksum; /* True for native byte-order checksums */
45905: u32 *aCksum = pWal->hdr.aFrameCksum;
45906: u32 pgno; /* Page number of the frame */
45907: assert( WAL_FRAME_HDRSIZE==24 );
45908:
45909: /* A frame is only valid if the salt values in the frame-header
45910: ** match the salt values in the wal-header.
45911: */
45912: if( memcmp(&pWal->hdr.aSalt, &aFrame[8], 8)!=0 ){
45913: return 0;
45914: }
45915:
45916: /* A frame is only valid if the page number is creater than zero.
45917: */
45918: pgno = sqlite3Get4byte(&aFrame[0]);
45919: if( pgno==0 ){
45920: return 0;
45921: }
45922:
45923: /* A frame is only valid if a checksum of the WAL header,
45924: ** all prior frams, the first 16 bytes of this frame-header,
45925: ** and the frame-data matches the checksum in the last 8
45926: ** bytes of this frame-header.
45927: */
45928: nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
45929: walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
45930: walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
45931: if( aCksum[0]!=sqlite3Get4byte(&aFrame[16])
45932: || aCksum[1]!=sqlite3Get4byte(&aFrame[20])
45933: ){
45934: /* Checksum failed. */
45935: return 0;
45936: }
45937:
45938: /* If we reach this point, the frame is valid. Return the page number
45939: ** and the new database size.
45940: */
45941: *piPage = pgno;
45942: *pnTruncate = sqlite3Get4byte(&aFrame[4]);
45943: return 1;
45944: }
45945:
45946:
45947: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
45948: /*
45949: ** Names of locks. This routine is used to provide debugging output and is not
45950: ** a part of an ordinary build.
45951: */
45952: static const char *walLockName(int lockIdx){
45953: if( lockIdx==WAL_WRITE_LOCK ){
45954: return "WRITE-LOCK";
45955: }else if( lockIdx==WAL_CKPT_LOCK ){
45956: return "CKPT-LOCK";
45957: }else if( lockIdx==WAL_RECOVER_LOCK ){
45958: return "RECOVER-LOCK";
45959: }else{
45960: static char zName[15];
45961: sqlite3_snprintf(sizeof(zName), zName, "READ-LOCK[%d]",
45962: lockIdx-WAL_READ_LOCK(0));
45963: return zName;
45964: }
45965: }
45966: #endif /*defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */
45967:
45968:
45969: /*
45970: ** Set or release locks on the WAL. Locks are either shared or exclusive.
45971: ** A lock cannot be moved directly between shared and exclusive - it must go
45972: ** through the unlocked state first.
45973: **
45974: ** In locking_mode=EXCLUSIVE, all of these routines become no-ops.
45975: */
45976: static int walLockShared(Wal *pWal, int lockIdx){
45977: int rc;
45978: if( pWal->exclusiveMode ) return SQLITE_OK;
45979: rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,
45980: SQLITE_SHM_LOCK | SQLITE_SHM_SHARED);
45981: WALTRACE(("WAL%p: acquire SHARED-%s %s\n", pWal,
45982: walLockName(lockIdx), rc ? "failed" : "ok"));
45983: VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
45984: return rc;
45985: }
45986: static void walUnlockShared(Wal *pWal, int lockIdx){
45987: if( pWal->exclusiveMode ) return;
45988: (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, 1,
45989: SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED);
45990: WALTRACE(("WAL%p: release SHARED-%s\n", pWal, walLockName(lockIdx)));
45991: }
45992: static int walLockExclusive(Wal *pWal, int lockIdx, int n){
45993: int rc;
45994: if( pWal->exclusiveMode ) return SQLITE_OK;
45995: rc = sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,
45996: SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE);
45997: WALTRACE(("WAL%p: acquire EXCLUSIVE-%s cnt=%d %s\n", pWal,
45998: walLockName(lockIdx), n, rc ? "failed" : "ok"));
45999: VVA_ONLY( pWal->lockError = (u8)(rc!=SQLITE_OK && rc!=SQLITE_BUSY); )
46000: return rc;
46001: }
46002: static void walUnlockExclusive(Wal *pWal, int lockIdx, int n){
46003: if( pWal->exclusiveMode ) return;
46004: (void)sqlite3OsShmLock(pWal->pDbFd, lockIdx, n,
46005: SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE);
46006: WALTRACE(("WAL%p: release EXCLUSIVE-%s cnt=%d\n", pWal,
46007: walLockName(lockIdx), n));
46008: }
46009:
46010: /*
46011: ** Compute a hash on a page number. The resulting hash value must land
46012: ** between 0 and (HASHTABLE_NSLOT-1). The walHashNext() function advances
46013: ** the hash to the next value in the event of a collision.
46014: */
46015: static int walHash(u32 iPage){
46016: assert( iPage>0 );
46017: assert( (HASHTABLE_NSLOT & (HASHTABLE_NSLOT-1))==0 );
46018: return (iPage*HASHTABLE_HASH_1) & (HASHTABLE_NSLOT-1);
46019: }
46020: static int walNextHash(int iPriorHash){
46021: return (iPriorHash+1)&(HASHTABLE_NSLOT-1);
46022: }
46023:
46024: /*
46025: ** Return pointers to the hash table and page number array stored on
46026: ** page iHash of the wal-index. The wal-index is broken into 32KB pages
46027: ** numbered starting from 0.
46028: **
46029: ** Set output variable *paHash to point to the start of the hash table
46030: ** in the wal-index file. Set *piZero to one less than the frame
46031: ** number of the first frame indexed by this hash table. If a
46032: ** slot in the hash table is set to N, it refers to frame number
46033: ** (*piZero+N) in the log.
46034: **
46035: ** Finally, set *paPgno so that *paPgno[1] is the page number of the
46036: ** first frame indexed by the hash table, frame (*piZero+1).
46037: */
46038: static int walHashGet(
46039: Wal *pWal, /* WAL handle */
46040: int iHash, /* Find the iHash'th table */
46041: volatile ht_slot **paHash, /* OUT: Pointer to hash index */
46042: volatile u32 **paPgno, /* OUT: Pointer to page number array */
46043: u32 *piZero /* OUT: Frame associated with *paPgno[0] */
46044: ){
46045: int rc; /* Return code */
46046: volatile u32 *aPgno;
46047:
46048: rc = walIndexPage(pWal, iHash, &aPgno);
46049: assert( rc==SQLITE_OK || iHash>0 );
46050:
46051: if( rc==SQLITE_OK ){
46052: u32 iZero;
46053: volatile ht_slot *aHash;
46054:
46055: aHash = (volatile ht_slot *)&aPgno[HASHTABLE_NPAGE];
46056: if( iHash==0 ){
46057: aPgno = &aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];
46058: iZero = 0;
46059: }else{
46060: iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE;
46061: }
46062:
46063: *paPgno = &aPgno[-1];
46064: *paHash = aHash;
46065: *piZero = iZero;
46066: }
46067: return rc;
46068: }
46069:
46070: /*
46071: ** Return the number of the wal-index page that contains the hash-table
46072: ** and page-number array that contain entries corresponding to WAL frame
46073: ** iFrame. The wal-index is broken up into 32KB pages. Wal-index pages
46074: ** are numbered starting from 0.
46075: */
46076: static int walFramePage(u32 iFrame){
46077: int iHash = (iFrame+HASHTABLE_NPAGE-HASHTABLE_NPAGE_ONE-1) / HASHTABLE_NPAGE;
46078: assert( (iHash==0 || iFrame>HASHTABLE_NPAGE_ONE)
46079: && (iHash>=1 || iFrame<=HASHTABLE_NPAGE_ONE)
46080: && (iHash<=1 || iFrame>(HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE))
46081: && (iHash>=2 || iFrame<=HASHTABLE_NPAGE_ONE+HASHTABLE_NPAGE)
46082: && (iHash<=2 || iFrame>(HASHTABLE_NPAGE_ONE+2*HASHTABLE_NPAGE))
46083: );
46084: return iHash;
46085: }
46086:
46087: /*
46088: ** Return the page number associated with frame iFrame in this WAL.
46089: */
46090: static u32 walFramePgno(Wal *pWal, u32 iFrame){
46091: int iHash = walFramePage(iFrame);
46092: if( iHash==0 ){
46093: return pWal->apWiData[0][WALINDEX_HDR_SIZE/sizeof(u32) + iFrame - 1];
46094: }
46095: return pWal->apWiData[iHash][(iFrame-1-HASHTABLE_NPAGE_ONE)%HASHTABLE_NPAGE];
46096: }
46097:
46098: /*
46099: ** Remove entries from the hash table that point to WAL slots greater
46100: ** than pWal->hdr.mxFrame.
46101: **
46102: ** This function is called whenever pWal->hdr.mxFrame is decreased due
46103: ** to a rollback or savepoint.
46104: **
46105: ** At most only the hash table containing pWal->hdr.mxFrame needs to be
46106: ** updated. Any later hash tables will be automatically cleared when
46107: ** pWal->hdr.mxFrame advances to the point where those hash tables are
46108: ** actually needed.
46109: */
46110: static void walCleanupHash(Wal *pWal){
46111: volatile ht_slot *aHash = 0; /* Pointer to hash table to clear */
46112: volatile u32 *aPgno = 0; /* Page number array for hash table */
46113: u32 iZero = 0; /* frame == (aHash[x]+iZero) */
46114: int iLimit = 0; /* Zero values greater than this */
46115: int nByte; /* Number of bytes to zero in aPgno[] */
46116: int i; /* Used to iterate through aHash[] */
46117:
46118: assert( pWal->writeLock );
46119: testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE-1 );
46120: testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE );
46121: testcase( pWal->hdr.mxFrame==HASHTABLE_NPAGE_ONE+1 );
46122:
46123: if( pWal->hdr.mxFrame==0 ) return;
46124:
46125: /* Obtain pointers to the hash-table and page-number array containing
46126: ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed
46127: ** that the page said hash-table and array reside on is already mapped.
46128: */
46129: assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
46130: assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
46131: walHashGet(pWal, walFramePage(pWal->hdr.mxFrame), &aHash, &aPgno, &iZero);
46132:
46133: /* Zero all hash-table entries that correspond to frame numbers greater
46134: ** than pWal->hdr.mxFrame.
46135: */
46136: iLimit = pWal->hdr.mxFrame - iZero;
46137: assert( iLimit>0 );
46138: for(i=0; i<HASHTABLE_NSLOT; i++){
46139: if( aHash[i]>iLimit ){
46140: aHash[i] = 0;
46141: }
46142: }
46143:
46144: /* Zero the entries in the aPgno array that correspond to frames with
46145: ** frame numbers greater than pWal->hdr.mxFrame.
46146: */
46147: nByte = (int)((char *)aHash - (char *)&aPgno[iLimit+1]);
46148: memset((void *)&aPgno[iLimit+1], 0, nByte);
46149:
46150: #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
46151: /* Verify that the every entry in the mapping region is still reachable
46152: ** via the hash table even after the cleanup.
46153: */
46154: if( iLimit ){
46155: int i; /* Loop counter */
46156: int iKey; /* Hash key */
46157: for(i=1; i<=iLimit; i++){
46158: for(iKey=walHash(aPgno[i]); aHash[iKey]; iKey=walNextHash(iKey)){
46159: if( aHash[iKey]==i ) break;
46160: }
46161: assert( aHash[iKey]==i );
46162: }
46163: }
46164: #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
46165: }
46166:
46167:
46168: /*
46169: ** Set an entry in the wal-index that will map database page number
46170: ** pPage into WAL frame iFrame.
46171: */
46172: static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
46173: int rc; /* Return code */
46174: u32 iZero = 0; /* One less than frame number of aPgno[1] */
46175: volatile u32 *aPgno = 0; /* Page number array */
46176: volatile ht_slot *aHash = 0; /* Hash table */
46177:
46178: rc = walHashGet(pWal, walFramePage(iFrame), &aHash, &aPgno, &iZero);
46179:
46180: /* Assuming the wal-index file was successfully mapped, populate the
46181: ** page number array and hash table entry.
46182: */
46183: if( rc==SQLITE_OK ){
46184: int iKey; /* Hash table key */
46185: int idx; /* Value to write to hash-table slot */
46186: int nCollide; /* Number of hash collisions */
46187:
46188: idx = iFrame - iZero;
46189: assert( idx <= HASHTABLE_NSLOT/2 + 1 );
46190:
46191: /* If this is the first entry to be added to this hash-table, zero the
46192: ** entire hash table and aPgno[] array before proceding.
46193: */
46194: if( idx==1 ){
46195: int nByte = (int)((u8 *)&aHash[HASHTABLE_NSLOT] - (u8 *)&aPgno[1]);
46196: memset((void*)&aPgno[1], 0, nByte);
46197: }
46198:
46199: /* If the entry in aPgno[] is already set, then the previous writer
46200: ** must have exited unexpectedly in the middle of a transaction (after
46201: ** writing one or more dirty pages to the WAL to free up memory).
46202: ** Remove the remnants of that writers uncommitted transaction from
46203: ** the hash-table before writing any new entries.
46204: */
46205: if( aPgno[idx] ){
46206: walCleanupHash(pWal);
46207: assert( !aPgno[idx] );
46208: }
46209:
46210: /* Write the aPgno[] array entry and the hash-table slot. */
46211: nCollide = idx;
46212: for(iKey=walHash(iPage); aHash[iKey]; iKey=walNextHash(iKey)){
46213: if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT;
46214: }
46215: aPgno[idx] = iPage;
46216: aHash[iKey] = (ht_slot)idx;
46217:
46218: #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
46219: /* Verify that the number of entries in the hash table exactly equals
46220: ** the number of entries in the mapping region.
46221: */
46222: {
46223: int i; /* Loop counter */
46224: int nEntry = 0; /* Number of entries in the hash table */
46225: for(i=0; i<HASHTABLE_NSLOT; i++){ if( aHash[i] ) nEntry++; }
46226: assert( nEntry==idx );
46227: }
46228:
46229: /* Verify that the every entry in the mapping region is reachable
46230: ** via the hash table. This turns out to be a really, really expensive
46231: ** thing to check, so only do this occasionally - not on every
46232: ** iteration.
46233: */
46234: if( (idx&0x3ff)==0 ){
46235: int i; /* Loop counter */
46236: for(i=1; i<=idx; i++){
46237: for(iKey=walHash(aPgno[i]); aHash[iKey]; iKey=walNextHash(iKey)){
46238: if( aHash[iKey]==i ) break;
46239: }
46240: assert( aHash[iKey]==i );
46241: }
46242: }
46243: #endif /* SQLITE_ENABLE_EXPENSIVE_ASSERT */
46244: }
46245:
46246:
46247: return rc;
46248: }
46249:
46250:
46251: /*
46252: ** Recover the wal-index by reading the write-ahead log file.
46253: **
46254: ** This routine first tries to establish an exclusive lock on the
46255: ** wal-index to prevent other threads/processes from doing anything
46256: ** with the WAL or wal-index while recovery is running. The
46257: ** WAL_RECOVER_LOCK is also held so that other threads will know
46258: ** that this thread is running recovery. If unable to establish
46259: ** the necessary locks, this routine returns SQLITE_BUSY.
46260: */
46261: static int walIndexRecover(Wal *pWal){
46262: int rc; /* Return Code */
46263: i64 nSize; /* Size of log file */
46264: u32 aFrameCksum[2] = {0, 0};
46265: int iLock; /* Lock offset to lock for checkpoint */
46266: int nLock; /* Number of locks to hold */
46267:
46268: /* Obtain an exclusive lock on all byte in the locking range not already
46269: ** locked by the caller. The caller is guaranteed to have locked the
46270: ** WAL_WRITE_LOCK byte, and may have also locked the WAL_CKPT_LOCK byte.
46271: ** If successful, the same bytes that are locked here are unlocked before
46272: ** this function returns.
46273: */
46274: assert( pWal->ckptLock==1 || pWal->ckptLock==0 );
46275: assert( WAL_ALL_BUT_WRITE==WAL_WRITE_LOCK+1 );
46276: assert( WAL_CKPT_LOCK==WAL_ALL_BUT_WRITE );
46277: assert( pWal->writeLock );
46278: iLock = WAL_ALL_BUT_WRITE + pWal->ckptLock;
46279: nLock = SQLITE_SHM_NLOCK - iLock;
46280: rc = walLockExclusive(pWal, iLock, nLock);
46281: if( rc ){
46282: return rc;
46283: }
46284: WALTRACE(("WAL%p: recovery begin...\n", pWal));
46285:
46286: memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
46287:
46288: rc = sqlite3OsFileSize(pWal->pWalFd, &nSize);
46289: if( rc!=SQLITE_OK ){
46290: goto recovery_error;
46291: }
46292:
46293: if( nSize>WAL_HDRSIZE ){
46294: u8 aBuf[WAL_HDRSIZE]; /* Buffer to load WAL header into */
46295: u8 *aFrame = 0; /* Malloc'd buffer to load entire frame */
46296: int szFrame; /* Number of bytes in buffer aFrame[] */
46297: u8 *aData; /* Pointer to data part of aFrame buffer */
46298: int iFrame; /* Index of last frame read */
46299: i64 iOffset; /* Next offset to read from log file */
46300: int szPage; /* Page size according to the log */
46301: u32 magic; /* Magic value read from WAL header */
46302: u32 version; /* Magic value read from WAL header */
46303: int isValid; /* True if this frame is valid */
46304:
46305: /* Read in the WAL header. */
46306: rc = sqlite3OsRead(pWal->pWalFd, aBuf, WAL_HDRSIZE, 0);
46307: if( rc!=SQLITE_OK ){
46308: goto recovery_error;
46309: }
46310:
46311: /* If the database page size is not a power of two, or is greater than
46312: ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid
46313: ** data. Similarly, if the 'magic' value is invalid, ignore the whole
46314: ** WAL file.
46315: */
46316: magic = sqlite3Get4byte(&aBuf[0]);
46317: szPage = sqlite3Get4byte(&aBuf[8]);
46318: if( (magic&0xFFFFFFFE)!=WAL_MAGIC
46319: || szPage&(szPage-1)
46320: || szPage>SQLITE_MAX_PAGE_SIZE
46321: || szPage<512
46322: ){
46323: goto finished;
46324: }
46325: pWal->hdr.bigEndCksum = (u8)(magic&0x00000001);
46326: pWal->szPage = szPage;
46327: pWal->nCkpt = sqlite3Get4byte(&aBuf[12]);
46328: memcpy(&pWal->hdr.aSalt, &aBuf[16], 8);
46329:
46330: /* Verify that the WAL header checksum is correct */
46331: walChecksumBytes(pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN,
46332: aBuf, WAL_HDRSIZE-2*4, 0, pWal->hdr.aFrameCksum
46333: );
46334: if( pWal->hdr.aFrameCksum[0]!=sqlite3Get4byte(&aBuf[24])
46335: || pWal->hdr.aFrameCksum[1]!=sqlite3Get4byte(&aBuf[28])
46336: ){
46337: goto finished;
46338: }
46339:
46340: /* Verify that the version number on the WAL format is one that
46341: ** are able to understand */
46342: version = sqlite3Get4byte(&aBuf[4]);
46343: if( version!=WAL_MAX_VERSION ){
46344: rc = SQLITE_CANTOPEN_BKPT;
46345: goto finished;
46346: }
46347:
46348: /* Malloc a buffer to read frames into. */
46349: szFrame = szPage + WAL_FRAME_HDRSIZE;
46350: aFrame = (u8 *)sqlite3_malloc(szFrame);
46351: if( !aFrame ){
46352: rc = SQLITE_NOMEM;
46353: goto recovery_error;
46354: }
46355: aData = &aFrame[WAL_FRAME_HDRSIZE];
46356:
46357: /* Read all frames from the log file. */
46358: iFrame = 0;
46359: for(iOffset=WAL_HDRSIZE; (iOffset+szFrame)<=nSize; iOffset+=szFrame){
46360: u32 pgno; /* Database page number for frame */
46361: u32 nTruncate; /* dbsize field from frame header */
46362:
46363: /* Read and decode the next log frame. */
46364: iFrame++;
46365: rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
46366: if( rc!=SQLITE_OK ) break;
46367: isValid = walDecodeFrame(pWal, &pgno, &nTruncate, aData, aFrame);
46368: if( !isValid ) break;
46369: rc = walIndexAppend(pWal, iFrame, pgno);
46370: if( rc!=SQLITE_OK ) break;
46371:
46372: /* If nTruncate is non-zero, this is a commit record. */
46373: if( nTruncate ){
46374: pWal->hdr.mxFrame = iFrame;
46375: pWal->hdr.nPage = nTruncate;
46376: pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
46377: testcase( szPage<=32768 );
46378: testcase( szPage>=65536 );
46379: aFrameCksum[0] = pWal->hdr.aFrameCksum[0];
46380: aFrameCksum[1] = pWal->hdr.aFrameCksum[1];
46381: }
46382: }
46383:
46384: sqlite3_free(aFrame);
46385: }
46386:
46387: finished:
46388: if( rc==SQLITE_OK ){
46389: volatile WalCkptInfo *pInfo;
46390: int i;
46391: pWal->hdr.aFrameCksum[0] = aFrameCksum[0];
46392: pWal->hdr.aFrameCksum[1] = aFrameCksum[1];
46393: walIndexWriteHdr(pWal);
46394:
46395: /* Reset the checkpoint-header. This is safe because this thread is
46396: ** currently holding locks that exclude all other readers, writers and
46397: ** checkpointers.
46398: */
46399: pInfo = walCkptInfo(pWal);
46400: pInfo->nBackfill = 0;
46401: pInfo->aReadMark[0] = 0;
46402: for(i=1; i<WAL_NREADER; i++) pInfo->aReadMark[i] = READMARK_NOT_USED;
46403:
46404: /* If more than one frame was recovered from the log file, report an
46405: ** event via sqlite3_log(). This is to help with identifying performance
46406: ** problems caused by applications routinely shutting down without
46407: ** checkpointing the log file.
46408: */
46409: if( pWal->hdr.nPage ){
46410: sqlite3_log(SQLITE_OK, "Recovered %d frames from WAL file %s",
46411: pWal->hdr.nPage, pWal->zWalName
46412: );
46413: }
46414: }
46415:
46416: recovery_error:
46417: WALTRACE(("WAL%p: recovery %s\n", pWal, rc ? "failed" : "ok"));
46418: walUnlockExclusive(pWal, iLock, nLock);
46419: return rc;
46420: }
46421:
46422: /*
46423: ** Close an open wal-index.
46424: */
46425: static void walIndexClose(Wal *pWal, int isDelete){
46426: if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
46427: int i;
46428: for(i=0; i<pWal->nWiData; i++){
46429: sqlite3_free((void *)pWal->apWiData[i]);
46430: pWal->apWiData[i] = 0;
46431: }
46432: }else{
46433: sqlite3OsShmUnmap(pWal->pDbFd, isDelete);
46434: }
46435: }
46436:
46437: /*
46438: ** Open a connection to the WAL file zWalName. The database file must
46439: ** already be opened on connection pDbFd. The buffer that zWalName points
46440: ** to must remain valid for the lifetime of the returned Wal* handle.
46441: **
46442: ** A SHARED lock should be held on the database file when this function
46443: ** is called. The purpose of this SHARED lock is to prevent any other
46444: ** client from unlinking the WAL or wal-index file. If another process
46445: ** were to do this just after this client opened one of these files, the
46446: ** system would be badly broken.
46447: **
46448: ** If the log file is successfully opened, SQLITE_OK is returned and
46449: ** *ppWal is set to point to a new WAL handle. If an error occurs,
46450: ** an SQLite error code is returned and *ppWal is left unmodified.
46451: */
46452: SQLITE_PRIVATE int sqlite3WalOpen(
46453: sqlite3_vfs *pVfs, /* vfs module to open wal and wal-index */
46454: sqlite3_file *pDbFd, /* The open database file */
46455: const char *zWalName, /* Name of the WAL file */
46456: int bNoShm, /* True to run in heap-memory mode */
46457: i64 mxWalSize, /* Truncate WAL to this size on reset */
46458: Wal **ppWal /* OUT: Allocated Wal handle */
46459: ){
46460: int rc; /* Return Code */
46461: Wal *pRet; /* Object to allocate and return */
46462: int flags; /* Flags passed to OsOpen() */
46463:
46464: assert( zWalName && zWalName[0] );
46465: assert( pDbFd );
46466:
46467: /* In the amalgamation, the os_unix.c and os_win.c source files come before
46468: ** this source file. Verify that the #defines of the locking byte offsets
46469: ** in os_unix.c and os_win.c agree with the WALINDEX_LOCK_OFFSET value.
46470: */
46471: #ifdef WIN_SHM_BASE
46472: assert( WIN_SHM_BASE==WALINDEX_LOCK_OFFSET );
46473: #endif
46474: #ifdef UNIX_SHM_BASE
46475: assert( UNIX_SHM_BASE==WALINDEX_LOCK_OFFSET );
46476: #endif
46477:
46478:
46479: /* Allocate an instance of struct Wal to return. */
46480: *ppWal = 0;
46481: pRet = (Wal*)sqlite3MallocZero(sizeof(Wal) + pVfs->szOsFile);
46482: if( !pRet ){
46483: return SQLITE_NOMEM;
46484: }
46485:
46486: pRet->pVfs = pVfs;
46487: pRet->pWalFd = (sqlite3_file *)&pRet[1];
46488: pRet->pDbFd = pDbFd;
46489: pRet->readLock = -1;
46490: pRet->mxWalSize = mxWalSize;
46491: pRet->zWalName = zWalName;
46492: pRet->syncHeader = 1;
46493: pRet->padToSectorBoundary = 1;
46494: pRet->exclusiveMode = (bNoShm ? WAL_HEAPMEMORY_MODE: WAL_NORMAL_MODE);
46495:
46496: /* Open file handle on the write-ahead log file. */
46497: flags = (SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|SQLITE_OPEN_WAL);
46498: rc = sqlite3OsOpen(pVfs, zWalName, pRet->pWalFd, flags, &flags);
46499: if( rc==SQLITE_OK && flags&SQLITE_OPEN_READONLY ){
46500: pRet->readOnly = WAL_RDONLY;
46501: }
46502:
46503: if( rc!=SQLITE_OK ){
46504: walIndexClose(pRet, 0);
46505: sqlite3OsClose(pRet->pWalFd);
46506: sqlite3_free(pRet);
46507: }else{
46508: int iDC = sqlite3OsDeviceCharacteristics(pRet->pWalFd);
46509: if( iDC & SQLITE_IOCAP_SEQUENTIAL ){ pRet->syncHeader = 0; }
46510: if( iDC & SQLITE_IOCAP_POWERSAFE_OVERWRITE ){
46511: pRet->padToSectorBoundary = 0;
46512: }
46513: *ppWal = pRet;
46514: WALTRACE(("WAL%d: opened\n", pRet));
46515: }
46516: return rc;
46517: }
46518:
46519: /*
46520: ** Change the size to which the WAL file is trucated on each reset.
46521: */
46522: SQLITE_PRIVATE void sqlite3WalLimit(Wal *pWal, i64 iLimit){
46523: if( pWal ) pWal->mxWalSize = iLimit;
46524: }
46525:
46526: /*
46527: ** Find the smallest page number out of all pages held in the WAL that
46528: ** has not been returned by any prior invocation of this method on the
46529: ** same WalIterator object. Write into *piFrame the frame index where
46530: ** that page was last written into the WAL. Write into *piPage the page
46531: ** number.
46532: **
46533: ** Return 0 on success. If there are no pages in the WAL with a page
46534: ** number larger than *piPage, then return 1.
46535: */
46536: static int walIteratorNext(
46537: WalIterator *p, /* Iterator */
46538: u32 *piPage, /* OUT: The page number of the next page */
46539: u32 *piFrame /* OUT: Wal frame index of next page */
46540: ){
46541: u32 iMin; /* Result pgno must be greater than iMin */
46542: u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */
46543: int i; /* For looping through segments */
46544:
46545: iMin = p->iPrior;
46546: assert( iMin<0xffffffff );
46547: for(i=p->nSegment-1; i>=0; i--){
46548: struct WalSegment *pSegment = &p->aSegment[i];
46549: while( pSegment->iNext<pSegment->nEntry ){
46550: u32 iPg = pSegment->aPgno[pSegment->aIndex[pSegment->iNext]];
46551: if( iPg>iMin ){
46552: if( iPg<iRet ){
46553: iRet = iPg;
46554: *piFrame = pSegment->iZero + pSegment->aIndex[pSegment->iNext];
46555: }
46556: break;
46557: }
46558: pSegment->iNext++;
46559: }
46560: }
46561:
46562: *piPage = p->iPrior = iRet;
46563: return (iRet==0xFFFFFFFF);
46564: }
46565:
46566: /*
46567: ** This function merges two sorted lists into a single sorted list.
46568: **
46569: ** aLeft[] and aRight[] are arrays of indices. The sort key is
46570: ** aContent[aLeft[]] and aContent[aRight[]]. Upon entry, the following
46571: ** is guaranteed for all J<K:
46572: **
46573: ** aContent[aLeft[J]] < aContent[aLeft[K]]
46574: ** aContent[aRight[J]] < aContent[aRight[K]]
46575: **
46576: ** This routine overwrites aRight[] with a new (probably longer) sequence
46577: ** of indices such that the aRight[] contains every index that appears in
46578: ** either aLeft[] or the old aRight[] and such that the second condition
46579: ** above is still met.
46580: **
46581: ** The aContent[aLeft[X]] values will be unique for all X. And the
46582: ** aContent[aRight[X]] values will be unique too. But there might be
46583: ** one or more combinations of X and Y such that
46584: **
46585: ** aLeft[X]!=aRight[Y] && aContent[aLeft[X]] == aContent[aRight[Y]]
46586: **
46587: ** When that happens, omit the aLeft[X] and use the aRight[Y] index.
46588: */
46589: static void walMerge(
46590: const u32 *aContent, /* Pages in wal - keys for the sort */
46591: ht_slot *aLeft, /* IN: Left hand input list */
46592: int nLeft, /* IN: Elements in array *paLeft */
46593: ht_slot **paRight, /* IN/OUT: Right hand input list */
46594: int *pnRight, /* IN/OUT: Elements in *paRight */
46595: ht_slot *aTmp /* Temporary buffer */
46596: ){
46597: int iLeft = 0; /* Current index in aLeft */
46598: int iRight = 0; /* Current index in aRight */
46599: int iOut = 0; /* Current index in output buffer */
46600: int nRight = *pnRight;
46601: ht_slot *aRight = *paRight;
46602:
46603: assert( nLeft>0 && nRight>0 );
46604: while( iRight<nRight || iLeft<nLeft ){
46605: ht_slot logpage;
46606: Pgno dbpage;
46607:
46608: if( (iLeft<nLeft)
46609: && (iRight>=nRight || aContent[aLeft[iLeft]]<aContent[aRight[iRight]])
46610: ){
46611: logpage = aLeft[iLeft++];
46612: }else{
46613: logpage = aRight[iRight++];
46614: }
46615: dbpage = aContent[logpage];
46616:
46617: aTmp[iOut++] = logpage;
46618: if( iLeft<nLeft && aContent[aLeft[iLeft]]==dbpage ) iLeft++;
46619:
46620: assert( iLeft>=nLeft || aContent[aLeft[iLeft]]>dbpage );
46621: assert( iRight>=nRight || aContent[aRight[iRight]]>dbpage );
46622: }
46623:
46624: *paRight = aLeft;
46625: *pnRight = iOut;
46626: memcpy(aLeft, aTmp, sizeof(aTmp[0])*iOut);
46627: }
46628:
46629: /*
46630: ** Sort the elements in list aList using aContent[] as the sort key.
46631: ** Remove elements with duplicate keys, preferring to keep the
46632: ** larger aList[] values.
46633: **
46634: ** The aList[] entries are indices into aContent[]. The values in
46635: ** aList[] are to be sorted so that for all J<K:
46636: **
46637: ** aContent[aList[J]] < aContent[aList[K]]
46638: **
46639: ** For any X and Y such that
46640: **
46641: ** aContent[aList[X]] == aContent[aList[Y]]
46642: **
46643: ** Keep the larger of the two values aList[X] and aList[Y] and discard
46644: ** the smaller.
46645: */
46646: static void walMergesort(
46647: const u32 *aContent, /* Pages in wal */
46648: ht_slot *aBuffer, /* Buffer of at least *pnList items to use */
46649: ht_slot *aList, /* IN/OUT: List to sort */
46650: int *pnList /* IN/OUT: Number of elements in aList[] */
46651: ){
46652: struct Sublist {
46653: int nList; /* Number of elements in aList */
46654: ht_slot *aList; /* Pointer to sub-list content */
46655: };
46656:
46657: const int nList = *pnList; /* Size of input list */
46658: int nMerge = 0; /* Number of elements in list aMerge */
46659: ht_slot *aMerge = 0; /* List to be merged */
46660: int iList; /* Index into input list */
46661: int iSub = 0; /* Index into aSub array */
46662: struct Sublist aSub[13]; /* Array of sub-lists */
46663:
46664: memset(aSub, 0, sizeof(aSub));
46665: assert( nList<=HASHTABLE_NPAGE && nList>0 );
46666: assert( HASHTABLE_NPAGE==(1<<(ArraySize(aSub)-1)) );
46667:
46668: for(iList=0; iList<nList; iList++){
46669: nMerge = 1;
46670: aMerge = &aList[iList];
46671: for(iSub=0; iList & (1<<iSub); iSub++){
46672: struct Sublist *p = &aSub[iSub];
46673: assert( p->aList && p->nList<=(1<<iSub) );
46674: assert( p->aList==&aList[iList&~((2<<iSub)-1)] );
46675: walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
46676: }
46677: aSub[iSub].aList = aMerge;
46678: aSub[iSub].nList = nMerge;
46679: }
46680:
46681: for(iSub++; iSub<ArraySize(aSub); iSub++){
46682: if( nList & (1<<iSub) ){
46683: struct Sublist *p = &aSub[iSub];
46684: assert( p->nList<=(1<<iSub) );
46685: assert( p->aList==&aList[nList&~((2<<iSub)-1)] );
46686: walMerge(aContent, p->aList, p->nList, &aMerge, &nMerge, aBuffer);
46687: }
46688: }
46689: assert( aMerge==aList );
46690: *pnList = nMerge;
46691:
46692: #ifdef SQLITE_DEBUG
46693: {
46694: int i;
46695: for(i=1; i<*pnList; i++){
46696: assert( aContent[aList[i]] > aContent[aList[i-1]] );
46697: }
46698: }
46699: #endif
46700: }
46701:
46702: /*
46703: ** Free an iterator allocated by walIteratorInit().
46704: */
46705: static void walIteratorFree(WalIterator *p){
46706: sqlite3ScratchFree(p);
46707: }
46708:
46709: /*
46710: ** Construct a WalInterator object that can be used to loop over all
46711: ** pages in the WAL in ascending order. The caller must hold the checkpoint
46712: ** lock.
46713: **
46714: ** On success, make *pp point to the newly allocated WalInterator object
46715: ** return SQLITE_OK. Otherwise, return an error code. If this routine
46716: ** returns an error, the value of *pp is undefined.
46717: **
46718: ** The calling routine should invoke walIteratorFree() to destroy the
46719: ** WalIterator object when it has finished with it.
46720: */
46721: static int walIteratorInit(Wal *pWal, WalIterator **pp){
46722: WalIterator *p; /* Return value */
46723: int nSegment; /* Number of segments to merge */
46724: u32 iLast; /* Last frame in log */
46725: int nByte; /* Number of bytes to allocate */
46726: int i; /* Iterator variable */
46727: ht_slot *aTmp; /* Temp space used by merge-sort */
46728: int rc = SQLITE_OK; /* Return Code */
46729:
46730: /* This routine only runs while holding the checkpoint lock. And
46731: ** it only runs if there is actually content in the log (mxFrame>0).
46732: */
46733: assert( pWal->ckptLock && pWal->hdr.mxFrame>0 );
46734: iLast = pWal->hdr.mxFrame;
46735:
46736: /* Allocate space for the WalIterator object. */
46737: nSegment = walFramePage(iLast) + 1;
46738: nByte = sizeof(WalIterator)
46739: + (nSegment-1)*sizeof(struct WalSegment)
46740: + iLast*sizeof(ht_slot);
46741: p = (WalIterator *)sqlite3ScratchMalloc(nByte);
46742: if( !p ){
46743: return SQLITE_NOMEM;
46744: }
46745: memset(p, 0, nByte);
46746: p->nSegment = nSegment;
46747:
46748: /* Allocate temporary space used by the merge-sort routine. This block
46749: ** of memory will be freed before this function returns.
46750: */
46751: aTmp = (ht_slot *)sqlite3ScratchMalloc(
46752: sizeof(ht_slot) * (iLast>HASHTABLE_NPAGE?HASHTABLE_NPAGE:iLast)
46753: );
46754: if( !aTmp ){
46755: rc = SQLITE_NOMEM;
46756: }
46757:
46758: for(i=0; rc==SQLITE_OK && i<nSegment; i++){
46759: volatile ht_slot *aHash;
46760: u32 iZero;
46761: volatile u32 *aPgno;
46762:
46763: rc = walHashGet(pWal, i, &aHash, &aPgno, &iZero);
46764: if( rc==SQLITE_OK ){
46765: int j; /* Counter variable */
46766: int nEntry; /* Number of entries in this segment */
46767: ht_slot *aIndex; /* Sorted index for this segment */
46768:
46769: aPgno++;
46770: if( (i+1)==nSegment ){
46771: nEntry = (int)(iLast - iZero);
46772: }else{
46773: nEntry = (int)((u32*)aHash - (u32*)aPgno);
46774: }
46775: aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[iZero];
46776: iZero++;
46777:
46778: for(j=0; j<nEntry; j++){
46779: aIndex[j] = (ht_slot)j;
46780: }
46781: walMergesort((u32 *)aPgno, aTmp, aIndex, &nEntry);
46782: p->aSegment[i].iZero = iZero;
46783: p->aSegment[i].nEntry = nEntry;
46784: p->aSegment[i].aIndex = aIndex;
46785: p->aSegment[i].aPgno = (u32 *)aPgno;
46786: }
46787: }
46788: sqlite3ScratchFree(aTmp);
46789:
46790: if( rc!=SQLITE_OK ){
46791: walIteratorFree(p);
46792: }
46793: *pp = p;
46794: return rc;
46795: }
46796:
46797: /*
46798: ** Attempt to obtain the exclusive WAL lock defined by parameters lockIdx and
46799: ** n. If the attempt fails and parameter xBusy is not NULL, then it is a
46800: ** busy-handler function. Invoke it and retry the lock until either the
46801: ** lock is successfully obtained or the busy-handler returns 0.
46802: */
46803: static int walBusyLock(
46804: Wal *pWal, /* WAL connection */
46805: int (*xBusy)(void*), /* Function to call when busy */
46806: void *pBusyArg, /* Context argument for xBusyHandler */
46807: int lockIdx, /* Offset of first byte to lock */
46808: int n /* Number of bytes to lock */
46809: ){
46810: int rc;
46811: do {
46812: rc = walLockExclusive(pWal, lockIdx, n);
46813: }while( xBusy && rc==SQLITE_BUSY && xBusy(pBusyArg) );
46814: return rc;
46815: }
46816:
46817: /*
46818: ** The cache of the wal-index header must be valid to call this function.
46819: ** Return the page-size in bytes used by the database.
46820: */
46821: static int walPagesize(Wal *pWal){
46822: return (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
46823: }
46824:
46825: /*
46826: ** Copy as much content as we can from the WAL back into the database file
46827: ** in response to an sqlite3_wal_checkpoint() request or the equivalent.
46828: **
46829: ** The amount of information copies from WAL to database might be limited
46830: ** by active readers. This routine will never overwrite a database page
46831: ** that a concurrent reader might be using.
46832: **
46833: ** All I/O barrier operations (a.k.a fsyncs) occur in this routine when
46834: ** SQLite is in WAL-mode in synchronous=NORMAL. That means that if
46835: ** checkpoints are always run by a background thread or background
46836: ** process, foreground threads will never block on a lengthy fsync call.
46837: **
46838: ** Fsync is called on the WAL before writing content out of the WAL and
46839: ** into the database. This ensures that if the new content is persistent
46840: ** in the WAL and can be recovered following a power-loss or hard reset.
46841: **
46842: ** Fsync is also called on the database file if (and only if) the entire
46843: ** WAL content is copied into the database file. This second fsync makes
46844: ** it safe to delete the WAL since the new content will persist in the
46845: ** database file.
46846: **
46847: ** This routine uses and updates the nBackfill field of the wal-index header.
46848: ** This is the only routine tha will increase the value of nBackfill.
46849: ** (A WAL reset or recovery will revert nBackfill to zero, but not increase
46850: ** its value.)
46851: **
46852: ** The caller must be holding sufficient locks to ensure that no other
46853: ** checkpoint is running (in any other thread or process) at the same
46854: ** time.
46855: */
46856: static int walCheckpoint(
46857: Wal *pWal, /* Wal connection */
46858: int eMode, /* One of PASSIVE, FULL or RESTART */
46859: int (*xBusyCall)(void*), /* Function to call when busy */
46860: void *pBusyArg, /* Context argument for xBusyHandler */
46861: int sync_flags, /* Flags for OsSync() (or 0) */
46862: u8 *zBuf /* Temporary buffer to use */
46863: ){
46864: int rc; /* Return code */
46865: int szPage; /* Database page-size */
46866: WalIterator *pIter = 0; /* Wal iterator context */
46867: u32 iDbpage = 0; /* Next database page to write */
46868: u32 iFrame = 0; /* Wal frame containing data for iDbpage */
46869: u32 mxSafeFrame; /* Max frame that can be backfilled */
46870: u32 mxPage; /* Max database page to write */
46871: int i; /* Loop counter */
46872: volatile WalCkptInfo *pInfo; /* The checkpoint status information */
46873: int (*xBusy)(void*) = 0; /* Function to call when waiting for locks */
46874:
46875: szPage = walPagesize(pWal);
46876: testcase( szPage<=32768 );
46877: testcase( szPage>=65536 );
46878: pInfo = walCkptInfo(pWal);
46879: if( pInfo->nBackfill>=pWal->hdr.mxFrame ) return SQLITE_OK;
46880:
46881: /* Allocate the iterator */
46882: rc = walIteratorInit(pWal, &pIter);
46883: if( rc!=SQLITE_OK ){
46884: return rc;
46885: }
46886: assert( pIter );
46887:
46888: if( eMode!=SQLITE_CHECKPOINT_PASSIVE ) xBusy = xBusyCall;
46889:
46890: /* Compute in mxSafeFrame the index of the last frame of the WAL that is
46891: ** safe to write into the database. Frames beyond mxSafeFrame might
46892: ** overwrite database pages that are in use by active readers and thus
46893: ** cannot be backfilled from the WAL.
46894: */
46895: mxSafeFrame = pWal->hdr.mxFrame;
46896: mxPage = pWal->hdr.nPage;
46897: for(i=1; i<WAL_NREADER; i++){
46898: u32 y = pInfo->aReadMark[i];
46899: if( mxSafeFrame>y ){
46900: assert( y<=pWal->hdr.mxFrame );
46901: rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(i), 1);
46902: if( rc==SQLITE_OK ){
46903: pInfo->aReadMark[i] = READMARK_NOT_USED;
46904: walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
46905: }else if( rc==SQLITE_BUSY ){
46906: mxSafeFrame = y;
46907: xBusy = 0;
46908: }else{
46909: goto walcheckpoint_out;
46910: }
46911: }
46912: }
46913:
46914: if( pInfo->nBackfill<mxSafeFrame
46915: && (rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(0), 1))==SQLITE_OK
46916: ){
46917: i64 nSize; /* Current size of database file */
46918: u32 nBackfill = pInfo->nBackfill;
46919:
46920: /* Sync the WAL to disk */
46921: if( sync_flags ){
46922: rc = sqlite3OsSync(pWal->pWalFd, sync_flags);
46923: }
46924:
46925: /* If the database file may grow as a result of this checkpoint, hint
46926: ** about the eventual size of the db file to the VFS layer.
46927: */
46928: if( rc==SQLITE_OK ){
46929: i64 nReq = ((i64)mxPage * szPage);
46930: rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);
46931: if( rc==SQLITE_OK && nSize<nReq ){
46932: sqlite3OsFileControlHint(pWal->pDbFd, SQLITE_FCNTL_SIZE_HINT, &nReq);
46933: }
46934: }
46935:
46936: /* Iterate through the contents of the WAL, copying data to the db file. */
46937: while( rc==SQLITE_OK && 0==walIteratorNext(pIter, &iDbpage, &iFrame) ){
46938: i64 iOffset;
46939: assert( walFramePgno(pWal, iFrame)==iDbpage );
46940: if( iFrame<=nBackfill || iFrame>mxSafeFrame || iDbpage>mxPage ) continue;
46941: iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;
46942: /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
46943: rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
46944: if( rc!=SQLITE_OK ) break;
46945: iOffset = (iDbpage-1)*(i64)szPage;
46946: testcase( IS_BIG_INT(iOffset) );
46947: rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
46948: if( rc!=SQLITE_OK ) break;
46949: }
46950:
46951: /* If work was actually accomplished... */
46952: if( rc==SQLITE_OK ){
46953: if( mxSafeFrame==walIndexHdr(pWal)->mxFrame ){
46954: i64 szDb = pWal->hdr.nPage*(i64)szPage;
46955: testcase( IS_BIG_INT(szDb) );
46956: rc = sqlite3OsTruncate(pWal->pDbFd, szDb);
46957: if( rc==SQLITE_OK && sync_flags ){
46958: rc = sqlite3OsSync(pWal->pDbFd, sync_flags);
46959: }
46960: }
46961: if( rc==SQLITE_OK ){
46962: pInfo->nBackfill = mxSafeFrame;
46963: }
46964: }
46965:
46966: /* Release the reader lock held while backfilling */
46967: walUnlockExclusive(pWal, WAL_READ_LOCK(0), 1);
46968: }
46969:
46970: if( rc==SQLITE_BUSY ){
46971: /* Reset the return code so as not to report a checkpoint failure
46972: ** just because there are active readers. */
46973: rc = SQLITE_OK;
46974: }
46975:
46976: /* If this is an SQLITE_CHECKPOINT_RESTART operation, and the entire wal
46977: ** file has been copied into the database file, then block until all
46978: ** readers have finished using the wal file. This ensures that the next
46979: ** process to write to the database restarts the wal file.
46980: */
46981: if( rc==SQLITE_OK && eMode!=SQLITE_CHECKPOINT_PASSIVE ){
46982: assert( pWal->writeLock );
46983: if( pInfo->nBackfill<pWal->hdr.mxFrame ){
46984: rc = SQLITE_BUSY;
46985: }else if( eMode==SQLITE_CHECKPOINT_RESTART ){
46986: assert( mxSafeFrame==pWal->hdr.mxFrame );
46987: rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_READ_LOCK(1), WAL_NREADER-1);
46988: if( rc==SQLITE_OK ){
46989: walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
46990: }
46991: }
46992: }
46993:
46994: walcheckpoint_out:
46995: walIteratorFree(pIter);
46996: return rc;
46997: }
46998:
46999: /*
47000: ** If the WAL file is currently larger than nMax bytes in size, truncate
47001: ** it to exactly nMax bytes. If an error occurs while doing so, ignore it.
47002: */
47003: static void walLimitSize(Wal *pWal, i64 nMax){
47004: i64 sz;
47005: int rx;
47006: sqlite3BeginBenignMalloc();
47007: rx = sqlite3OsFileSize(pWal->pWalFd, &sz);
47008: if( rx==SQLITE_OK && (sz > nMax ) ){
47009: rx = sqlite3OsTruncate(pWal->pWalFd, nMax);
47010: }
47011: sqlite3EndBenignMalloc();
47012: if( rx ){
47013: sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);
47014: }
47015: }
47016:
47017: /*
47018: ** Close a connection to a log file.
47019: */
47020: SQLITE_PRIVATE int sqlite3WalClose(
47021: Wal *pWal, /* Wal to close */
47022: int sync_flags, /* Flags to pass to OsSync() (or 0) */
47023: int nBuf,
47024: u8 *zBuf /* Buffer of at least nBuf bytes */
47025: ){
47026: int rc = SQLITE_OK;
47027: if( pWal ){
47028: int isDelete = 0; /* True to unlink wal and wal-index files */
47029:
47030: /* If an EXCLUSIVE lock can be obtained on the database file (using the
47031: ** ordinary, rollback-mode locking methods, this guarantees that the
47032: ** connection associated with this log file is the only connection to
47033: ** the database. In this case checkpoint the database and unlink both
47034: ** the wal and wal-index files.
47035: **
47036: ** The EXCLUSIVE lock is not released before returning.
47037: */
47038: rc = sqlite3OsLock(pWal->pDbFd, SQLITE_LOCK_EXCLUSIVE);
47039: if( rc==SQLITE_OK ){
47040: if( pWal->exclusiveMode==WAL_NORMAL_MODE ){
47041: pWal->exclusiveMode = WAL_EXCLUSIVE_MODE;
47042: }
47043: rc = sqlite3WalCheckpoint(
47044: pWal, SQLITE_CHECKPOINT_PASSIVE, 0, 0, sync_flags, nBuf, zBuf, 0, 0
47045: );
47046: if( rc==SQLITE_OK ){
47047: int bPersist = -1;
47048: sqlite3OsFileControlHint(
47049: pWal->pDbFd, SQLITE_FCNTL_PERSIST_WAL, &bPersist
47050: );
47051: if( bPersist!=1 ){
47052: /* Try to delete the WAL file if the checkpoint completed and
47053: ** fsyned (rc==SQLITE_OK) and if we are not in persistent-wal
47054: ** mode (!bPersist) */
47055: isDelete = 1;
47056: }else if( pWal->mxWalSize>=0 ){
47057: /* Try to truncate the WAL file to zero bytes if the checkpoint
47058: ** completed and fsynced (rc==SQLITE_OK) and we are in persistent
47059: ** WAL mode (bPersist) and if the PRAGMA journal_size_limit is a
47060: ** non-negative value (pWal->mxWalSize>=0). Note that we truncate
47061: ** to zero bytes as truncating to the journal_size_limit might
47062: ** leave a corrupt WAL file on disk. */
47063: walLimitSize(pWal, 0);
47064: }
47065: }
47066: }
47067:
47068: walIndexClose(pWal, isDelete);
47069: sqlite3OsClose(pWal->pWalFd);
47070: if( isDelete ){
47071: sqlite3BeginBenignMalloc();
47072: sqlite3OsDelete(pWal->pVfs, pWal->zWalName, 0);
47073: sqlite3EndBenignMalloc();
47074: }
47075: WALTRACE(("WAL%p: closed\n", pWal));
47076: sqlite3_free((void *)pWal->apWiData);
47077: sqlite3_free(pWal);
47078: }
47079: return rc;
47080: }
47081:
47082: /*
47083: ** Try to read the wal-index header. Return 0 on success and 1 if
47084: ** there is a problem.
47085: **
47086: ** The wal-index is in shared memory. Another thread or process might
47087: ** be writing the header at the same time this procedure is trying to
47088: ** read it, which might result in inconsistency. A dirty read is detected
47089: ** by verifying that both copies of the header are the same and also by
47090: ** a checksum on the header.
47091: **
47092: ** If and only if the read is consistent and the header is different from
47093: ** pWal->hdr, then pWal->hdr is updated to the content of the new header
47094: ** and *pChanged is set to 1.
47095: **
47096: ** If the checksum cannot be verified return non-zero. If the header
47097: ** is read successfully and the checksum verified, return zero.
47098: */
47099: static int walIndexTryHdr(Wal *pWal, int *pChanged){
47100: u32 aCksum[2]; /* Checksum on the header content */
47101: WalIndexHdr h1, h2; /* Two copies of the header content */
47102: WalIndexHdr volatile *aHdr; /* Header in shared memory */
47103:
47104: /* The first page of the wal-index must be mapped at this point. */
47105: assert( pWal->nWiData>0 && pWal->apWiData[0] );
47106:
47107: /* Read the header. This might happen concurrently with a write to the
47108: ** same area of shared memory on a different CPU in a SMP,
47109: ** meaning it is possible that an inconsistent snapshot is read
47110: ** from the file. If this happens, return non-zero.
47111: **
47112: ** There are two copies of the header at the beginning of the wal-index.
47113: ** When reading, read [0] first then [1]. Writes are in the reverse order.
47114: ** Memory barriers are used to prevent the compiler or the hardware from
47115: ** reordering the reads and writes.
47116: */
47117: aHdr = walIndexHdr(pWal);
47118: memcpy(&h1, (void *)&aHdr[0], sizeof(h1));
47119: walShmBarrier(pWal);
47120: memcpy(&h2, (void *)&aHdr[1], sizeof(h2));
47121:
47122: if( memcmp(&h1, &h2, sizeof(h1))!=0 ){
47123: return 1; /* Dirty read */
47124: }
47125: if( h1.isInit==0 ){
47126: return 1; /* Malformed header - probably all zeros */
47127: }
47128: walChecksumBytes(1, (u8*)&h1, sizeof(h1)-sizeof(h1.aCksum), 0, aCksum);
47129: if( aCksum[0]!=h1.aCksum[0] || aCksum[1]!=h1.aCksum[1] ){
47130: return 1; /* Checksum does not match */
47131: }
47132:
47133: if( memcmp(&pWal->hdr, &h1, sizeof(WalIndexHdr)) ){
47134: *pChanged = 1;
47135: memcpy(&pWal->hdr, &h1, sizeof(WalIndexHdr));
47136: pWal->szPage = (pWal->hdr.szPage&0xfe00) + ((pWal->hdr.szPage&0x0001)<<16);
47137: testcase( pWal->szPage<=32768 );
47138: testcase( pWal->szPage>=65536 );
47139: }
47140:
47141: /* The header was successfully read. Return zero. */
47142: return 0;
47143: }
47144:
47145: /*
47146: ** Read the wal-index header from the wal-index and into pWal->hdr.
47147: ** If the wal-header appears to be corrupt, try to reconstruct the
47148: ** wal-index from the WAL before returning.
47149: **
47150: ** Set *pChanged to 1 if the wal-index header value in pWal->hdr is
47151: ** changed by this opertion. If pWal->hdr is unchanged, set *pChanged
47152: ** to 0.
47153: **
47154: ** If the wal-index header is successfully read, return SQLITE_OK.
47155: ** Otherwise an SQLite error code.
47156: */
47157: static int walIndexReadHdr(Wal *pWal, int *pChanged){
47158: int rc; /* Return code */
47159: int badHdr; /* True if a header read failed */
47160: volatile u32 *page0; /* Chunk of wal-index containing header */
47161:
47162: /* Ensure that page 0 of the wal-index (the page that contains the
47163: ** wal-index header) is mapped. Return early if an error occurs here.
47164: */
47165: assert( pChanged );
47166: rc = walIndexPage(pWal, 0, &page0);
47167: if( rc!=SQLITE_OK ){
47168: return rc;
47169: };
47170: assert( page0 || pWal->writeLock==0 );
47171:
47172: /* If the first page of the wal-index has been mapped, try to read the
47173: ** wal-index header immediately, without holding any lock. This usually
47174: ** works, but may fail if the wal-index header is corrupt or currently
47175: ** being modified by another thread or process.
47176: */
47177: badHdr = (page0 ? walIndexTryHdr(pWal, pChanged) : 1);
47178:
47179: /* If the first attempt failed, it might have been due to a race
47180: ** with a writer. So get a WRITE lock and try again.
47181: */
47182: assert( badHdr==0 || pWal->writeLock==0 );
47183: if( badHdr ){
47184: if( pWal->readOnly & WAL_SHM_RDONLY ){
47185: if( SQLITE_OK==(rc = walLockShared(pWal, WAL_WRITE_LOCK)) ){
47186: walUnlockShared(pWal, WAL_WRITE_LOCK);
47187: rc = SQLITE_READONLY_RECOVERY;
47188: }
47189: }else if( SQLITE_OK==(rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1)) ){
47190: pWal->writeLock = 1;
47191: if( SQLITE_OK==(rc = walIndexPage(pWal, 0, &page0)) ){
47192: badHdr = walIndexTryHdr(pWal, pChanged);
47193: if( badHdr ){
47194: /* If the wal-index header is still malformed even while holding
47195: ** a WRITE lock, it can only mean that the header is corrupted and
47196: ** needs to be reconstructed. So run recovery to do exactly that.
47197: */
47198: rc = walIndexRecover(pWal);
47199: *pChanged = 1;
47200: }
47201: }
47202: pWal->writeLock = 0;
47203: walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
47204: }
47205: }
47206:
47207: /* If the header is read successfully, check the version number to make
47208: ** sure the wal-index was not constructed with some future format that
47209: ** this version of SQLite cannot understand.
47210: */
47211: if( badHdr==0 && pWal->hdr.iVersion!=WALINDEX_MAX_VERSION ){
47212: rc = SQLITE_CANTOPEN_BKPT;
47213: }
47214:
47215: return rc;
47216: }
47217:
47218: /*
47219: ** This is the value that walTryBeginRead returns when it needs to
47220: ** be retried.
47221: */
47222: #define WAL_RETRY (-1)
47223:
47224: /*
47225: ** Attempt to start a read transaction. This might fail due to a race or
47226: ** other transient condition. When that happens, it returns WAL_RETRY to
47227: ** indicate to the caller that it is safe to retry immediately.
47228: **
47229: ** On success return SQLITE_OK. On a permanent failure (such an
47230: ** I/O error or an SQLITE_BUSY because another process is running
47231: ** recovery) return a positive error code.
47232: **
47233: ** The useWal parameter is true to force the use of the WAL and disable
47234: ** the case where the WAL is bypassed because it has been completely
47235: ** checkpointed. If useWal==0 then this routine calls walIndexReadHdr()
47236: ** to make a copy of the wal-index header into pWal->hdr. If the
47237: ** wal-index header has changed, *pChanged is set to 1 (as an indication
47238: ** to the caller that the local paget cache is obsolete and needs to be
47239: ** flushed.) When useWal==1, the wal-index header is assumed to already
47240: ** be loaded and the pChanged parameter is unused.
47241: **
47242: ** The caller must set the cnt parameter to the number of prior calls to
47243: ** this routine during the current read attempt that returned WAL_RETRY.
47244: ** This routine will start taking more aggressive measures to clear the
47245: ** race conditions after multiple WAL_RETRY returns, and after an excessive
47246: ** number of errors will ultimately return SQLITE_PROTOCOL. The
47247: ** SQLITE_PROTOCOL return indicates that some other process has gone rogue
47248: ** and is not honoring the locking protocol. There is a vanishingly small
47249: ** chance that SQLITE_PROTOCOL could be returned because of a run of really
47250: ** bad luck when there is lots of contention for the wal-index, but that
47251: ** possibility is so small that it can be safely neglected, we believe.
47252: **
47253: ** On success, this routine obtains a read lock on
47254: ** WAL_READ_LOCK(pWal->readLock). The pWal->readLock integer is
47255: ** in the range 0 <= pWal->readLock < WAL_NREADER. If pWal->readLock==(-1)
47256: ** that means the Wal does not hold any read lock. The reader must not
47257: ** access any database page that is modified by a WAL frame up to and
47258: ** including frame number aReadMark[pWal->readLock]. The reader will
47259: ** use WAL frames up to and including pWal->hdr.mxFrame if pWal->readLock>0
47260: ** Or if pWal->readLock==0, then the reader will ignore the WAL
47261: ** completely and get all content directly from the database file.
47262: ** If the useWal parameter is 1 then the WAL will never be ignored and
47263: ** this routine will always set pWal->readLock>0 on success.
47264: ** When the read transaction is completed, the caller must release the
47265: ** lock on WAL_READ_LOCK(pWal->readLock) and set pWal->readLock to -1.
47266: **
47267: ** This routine uses the nBackfill and aReadMark[] fields of the header
47268: ** to select a particular WAL_READ_LOCK() that strives to let the
47269: ** checkpoint process do as much work as possible. This routine might
47270: ** update values of the aReadMark[] array in the header, but if it does
47271: ** so it takes care to hold an exclusive lock on the corresponding
47272: ** WAL_READ_LOCK() while changing values.
47273: */
47274: static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int cnt){
47275: volatile WalCkptInfo *pInfo; /* Checkpoint information in wal-index */
47276: u32 mxReadMark; /* Largest aReadMark[] value */
47277: int mxI; /* Index of largest aReadMark[] value */
47278: int i; /* Loop counter */
47279: int rc = SQLITE_OK; /* Return code */
47280:
47281: assert( pWal->readLock<0 ); /* Not currently locked */
47282:
47283: /* Take steps to avoid spinning forever if there is a protocol error.
47284: **
47285: ** Circumstances that cause a RETRY should only last for the briefest
47286: ** instances of time. No I/O or other system calls are done while the
47287: ** locks are held, so the locks should not be held for very long. But
47288: ** if we are unlucky, another process that is holding a lock might get
47289: ** paged out or take a page-fault that is time-consuming to resolve,
47290: ** during the few nanoseconds that it is holding the lock. In that case,
47291: ** it might take longer than normal for the lock to free.
47292: **
47293: ** After 5 RETRYs, we begin calling sqlite3OsSleep(). The first few
47294: ** calls to sqlite3OsSleep() have a delay of 1 microsecond. Really this
47295: ** is more of a scheduler yield than an actual delay. But on the 10th
47296: ** an subsequent retries, the delays start becoming longer and longer,
47297: ** so that on the 100th (and last) RETRY we delay for 21 milliseconds.
47298: ** The total delay time before giving up is less than 1 second.
47299: */
47300: if( cnt>5 ){
47301: int nDelay = 1; /* Pause time in microseconds */
47302: if( cnt>100 ){
47303: VVA_ONLY( pWal->lockError = 1; )
47304: return SQLITE_PROTOCOL;
47305: }
47306: if( cnt>=10 ) nDelay = (cnt-9)*238; /* Max delay 21ms. Total delay 996ms */
47307: sqlite3OsSleep(pWal->pVfs, nDelay);
47308: }
47309:
47310: if( !useWal ){
47311: rc = walIndexReadHdr(pWal, pChanged);
47312: if( rc==SQLITE_BUSY ){
47313: /* If there is not a recovery running in another thread or process
47314: ** then convert BUSY errors to WAL_RETRY. If recovery is known to
47315: ** be running, convert BUSY to BUSY_RECOVERY. There is a race here
47316: ** which might cause WAL_RETRY to be returned even if BUSY_RECOVERY
47317: ** would be technically correct. But the race is benign since with
47318: ** WAL_RETRY this routine will be called again and will probably be
47319: ** right on the second iteration.
47320: */
47321: if( pWal->apWiData[0]==0 ){
47322: /* This branch is taken when the xShmMap() method returns SQLITE_BUSY.
47323: ** We assume this is a transient condition, so return WAL_RETRY. The
47324: ** xShmMap() implementation used by the default unix and win32 VFS
47325: ** modules may return SQLITE_BUSY due to a race condition in the
47326: ** code that determines whether or not the shared-memory region
47327: ** must be zeroed before the requested page is returned.
47328: */
47329: rc = WAL_RETRY;
47330: }else if( SQLITE_OK==(rc = walLockShared(pWal, WAL_RECOVER_LOCK)) ){
47331: walUnlockShared(pWal, WAL_RECOVER_LOCK);
47332: rc = WAL_RETRY;
47333: }else if( rc==SQLITE_BUSY ){
47334: rc = SQLITE_BUSY_RECOVERY;
47335: }
47336: }
47337: if( rc!=SQLITE_OK ){
47338: return rc;
47339: }
47340: }
47341:
47342: pInfo = walCkptInfo(pWal);
47343: if( !useWal && pInfo->nBackfill==pWal->hdr.mxFrame ){
47344: /* The WAL has been completely backfilled (or it is empty).
47345: ** and can be safely ignored.
47346: */
47347: rc = walLockShared(pWal, WAL_READ_LOCK(0));
47348: walShmBarrier(pWal);
47349: if( rc==SQLITE_OK ){
47350: if( memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr)) ){
47351: /* It is not safe to allow the reader to continue here if frames
47352: ** may have been appended to the log before READ_LOCK(0) was obtained.
47353: ** When holding READ_LOCK(0), the reader ignores the entire log file,
47354: ** which implies that the database file contains a trustworthy
47355: ** snapshoT. Since holding READ_LOCK(0) prevents a checkpoint from
47356: ** happening, this is usually correct.
47357: **
47358: ** However, if frames have been appended to the log (or if the log
47359: ** is wrapped and written for that matter) before the READ_LOCK(0)
47360: ** is obtained, that is not necessarily true. A checkpointer may
47361: ** have started to backfill the appended frames but crashed before
47362: ** it finished. Leaving a corrupt image in the database file.
47363: */
47364: walUnlockShared(pWal, WAL_READ_LOCK(0));
47365: return WAL_RETRY;
47366: }
47367: pWal->readLock = 0;
47368: return SQLITE_OK;
47369: }else if( rc!=SQLITE_BUSY ){
47370: return rc;
47371: }
47372: }
47373:
47374: /* If we get this far, it means that the reader will want to use
47375: ** the WAL to get at content from recent commits. The job now is
47376: ** to select one of the aReadMark[] entries that is closest to
47377: ** but not exceeding pWal->hdr.mxFrame and lock that entry.
47378: */
47379: mxReadMark = 0;
47380: mxI = 0;
47381: for(i=1; i<WAL_NREADER; i++){
47382: u32 thisMark = pInfo->aReadMark[i];
47383: if( mxReadMark<=thisMark && thisMark<=pWal->hdr.mxFrame ){
47384: assert( thisMark!=READMARK_NOT_USED );
47385: mxReadMark = thisMark;
47386: mxI = i;
47387: }
47388: }
47389: /* There was once an "if" here. The extra "{" is to preserve indentation. */
47390: {
47391: if( (pWal->readOnly & WAL_SHM_RDONLY)==0
47392: && (mxReadMark<pWal->hdr.mxFrame || mxI==0)
47393: ){
47394: for(i=1; i<WAL_NREADER; i++){
47395: rc = walLockExclusive(pWal, WAL_READ_LOCK(i), 1);
47396: if( rc==SQLITE_OK ){
47397: mxReadMark = pInfo->aReadMark[i] = pWal->hdr.mxFrame;
47398: mxI = i;
47399: walUnlockExclusive(pWal, WAL_READ_LOCK(i), 1);
47400: break;
47401: }else if( rc!=SQLITE_BUSY ){
47402: return rc;
47403: }
47404: }
47405: }
47406: if( mxI==0 ){
47407: assert( rc==SQLITE_BUSY || (pWal->readOnly & WAL_SHM_RDONLY)!=0 );
47408: return rc==SQLITE_BUSY ? WAL_RETRY : SQLITE_READONLY_CANTLOCK;
47409: }
47410:
47411: rc = walLockShared(pWal, WAL_READ_LOCK(mxI));
47412: if( rc ){
47413: return rc==SQLITE_BUSY ? WAL_RETRY : rc;
47414: }
47415: /* Now that the read-lock has been obtained, check that neither the
47416: ** value in the aReadMark[] array or the contents of the wal-index
47417: ** header have changed.
47418: **
47419: ** It is necessary to check that the wal-index header did not change
47420: ** between the time it was read and when the shared-lock was obtained
47421: ** on WAL_READ_LOCK(mxI) was obtained to account for the possibility
47422: ** that the log file may have been wrapped by a writer, or that frames
47423: ** that occur later in the log than pWal->hdr.mxFrame may have been
47424: ** copied into the database by a checkpointer. If either of these things
47425: ** happened, then reading the database with the current value of
47426: ** pWal->hdr.mxFrame risks reading a corrupted snapshot. So, retry
47427: ** instead.
47428: **
47429: ** This does not guarantee that the copy of the wal-index header is up to
47430: ** date before proceeding. That would not be possible without somehow
47431: ** blocking writers. It only guarantees that a dangerous checkpoint or
47432: ** log-wrap (either of which would require an exclusive lock on
47433: ** WAL_READ_LOCK(mxI)) has not occurred since the snapshot was valid.
47434: */
47435: walShmBarrier(pWal);
47436: if( pInfo->aReadMark[mxI]!=mxReadMark
47437: || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr))
47438: ){
47439: walUnlockShared(pWal, WAL_READ_LOCK(mxI));
47440: return WAL_RETRY;
47441: }else{
47442: assert( mxReadMark<=pWal->hdr.mxFrame );
47443: pWal->readLock = (i16)mxI;
47444: }
47445: }
47446: return rc;
47447: }
47448:
47449: /*
47450: ** Begin a read transaction on the database.
47451: **
47452: ** This routine used to be called sqlite3OpenSnapshot() and with good reason:
47453: ** it takes a snapshot of the state of the WAL and wal-index for the current
47454: ** instant in time. The current thread will continue to use this snapshot.
47455: ** Other threads might append new content to the WAL and wal-index but
47456: ** that extra content is ignored by the current thread.
47457: **
47458: ** If the database contents have changes since the previous read
47459: ** transaction, then *pChanged is set to 1 before returning. The
47460: ** Pager layer will use this to know that is cache is stale and
47461: ** needs to be flushed.
47462: */
47463: SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *pChanged){
47464: int rc; /* Return code */
47465: int cnt = 0; /* Number of TryBeginRead attempts */
47466:
47467: do{
47468: rc = walTryBeginRead(pWal, pChanged, 0, ++cnt);
47469: }while( rc==WAL_RETRY );
47470: testcase( (rc&0xff)==SQLITE_BUSY );
47471: testcase( (rc&0xff)==SQLITE_IOERR );
47472: testcase( rc==SQLITE_PROTOCOL );
47473: testcase( rc==SQLITE_OK );
47474: return rc;
47475: }
47476:
47477: /*
47478: ** Finish with a read transaction. All this does is release the
47479: ** read-lock.
47480: */
47481: SQLITE_PRIVATE void sqlite3WalEndReadTransaction(Wal *pWal){
47482: sqlite3WalEndWriteTransaction(pWal);
47483: if( pWal->readLock>=0 ){
47484: walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
47485: pWal->readLock = -1;
47486: }
47487: }
47488:
47489: /*
47490: ** Read a page from the WAL, if it is present in the WAL and if the
47491: ** current read transaction is configured to use the WAL.
47492: **
47493: ** The *pInWal is set to 1 if the requested page is in the WAL and
47494: ** has been loaded. Or *pInWal is set to 0 if the page was not in
47495: ** the WAL and needs to be read out of the database.
47496: */
47497: SQLITE_PRIVATE int sqlite3WalRead(
47498: Wal *pWal, /* WAL handle */
47499: Pgno pgno, /* Database page number to read data for */
47500: int *pInWal, /* OUT: True if data is read from WAL */
47501: int nOut, /* Size of buffer pOut in bytes */
47502: u8 *pOut /* Buffer to write page data to */
47503: ){
47504: u32 iRead = 0; /* If !=0, WAL frame to return data from */
47505: u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */
47506: int iHash; /* Used to loop through N hash tables */
47507:
47508: /* This routine is only be called from within a read transaction. */
47509: assert( pWal->readLock>=0 || pWal->lockError );
47510:
47511: /* If the "last page" field of the wal-index header snapshot is 0, then
47512: ** no data will be read from the wal under any circumstances. Return early
47513: ** in this case as an optimization. Likewise, if pWal->readLock==0,
47514: ** then the WAL is ignored by the reader so return early, as if the
47515: ** WAL were empty.
47516: */
47517: if( iLast==0 || pWal->readLock==0 ){
47518: *pInWal = 0;
47519: return SQLITE_OK;
47520: }
47521:
47522: /* Search the hash table or tables for an entry matching page number
47523: ** pgno. Each iteration of the following for() loop searches one
47524: ** hash table (each hash table indexes up to HASHTABLE_NPAGE frames).
47525: **
47526: ** This code might run concurrently to the code in walIndexAppend()
47527: ** that adds entries to the wal-index (and possibly to this hash
47528: ** table). This means the value just read from the hash
47529: ** slot (aHash[iKey]) may have been added before or after the
47530: ** current read transaction was opened. Values added after the
47531: ** read transaction was opened may have been written incorrectly -
47532: ** i.e. these slots may contain garbage data. However, we assume
47533: ** that any slots written before the current read transaction was
47534: ** opened remain unmodified.
47535: **
47536: ** For the reasons above, the if(...) condition featured in the inner
47537: ** loop of the following block is more stringent that would be required
47538: ** if we had exclusive access to the hash-table:
47539: **
47540: ** (aPgno[iFrame]==pgno):
47541: ** This condition filters out normal hash-table collisions.
47542: **
47543: ** (iFrame<=iLast):
47544: ** This condition filters out entries that were added to the hash
47545: ** table after the current read-transaction had started.
47546: */
47547: for(iHash=walFramePage(iLast); iHash>=0 && iRead==0; iHash--){
47548: volatile ht_slot *aHash; /* Pointer to hash table */
47549: volatile u32 *aPgno; /* Pointer to array of page numbers */
47550: u32 iZero; /* Frame number corresponding to aPgno[0] */
47551: int iKey; /* Hash slot index */
47552: int nCollide; /* Number of hash collisions remaining */
47553: int rc; /* Error code */
47554:
47555: rc = walHashGet(pWal, iHash, &aHash, &aPgno, &iZero);
47556: if( rc!=SQLITE_OK ){
47557: return rc;
47558: }
47559: nCollide = HASHTABLE_NSLOT;
47560: for(iKey=walHash(pgno); aHash[iKey]; iKey=walNextHash(iKey)){
47561: u32 iFrame = aHash[iKey] + iZero;
47562: if( iFrame<=iLast && aPgno[aHash[iKey]]==pgno ){
47563: /* assert( iFrame>iRead ); -- not true if there is corruption */
47564: iRead = iFrame;
47565: }
47566: if( (nCollide--)==0 ){
47567: return SQLITE_CORRUPT_BKPT;
47568: }
47569: }
47570: }
47571:
47572: #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
47573: /* If expensive assert() statements are available, do a linear search
47574: ** of the wal-index file content. Make sure the results agree with the
47575: ** result obtained using the hash indexes above. */
47576: {
47577: u32 iRead2 = 0;
47578: u32 iTest;
47579: for(iTest=iLast; iTest>0; iTest--){
47580: if( walFramePgno(pWal, iTest)==pgno ){
47581: iRead2 = iTest;
47582: break;
47583: }
47584: }
47585: assert( iRead==iRead2 );
47586: }
47587: #endif
47588:
47589: /* If iRead is non-zero, then it is the log frame number that contains the
47590: ** required page. Read and return data from the log file.
47591: */
47592: if( iRead ){
47593: int sz;
47594: i64 iOffset;
47595: sz = pWal->hdr.szPage;
47596: sz = (sz&0xfe00) + ((sz&0x0001)<<16);
47597: testcase( sz<=32768 );
47598: testcase( sz>=65536 );
47599: iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;
47600: *pInWal = 1;
47601: /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
47602: return sqlite3OsRead(pWal->pWalFd, pOut, nOut, iOffset);
47603: }
47604:
47605: *pInWal = 0;
47606: return SQLITE_OK;
47607: }
47608:
47609:
47610: /*
47611: ** Return the size of the database in pages (or zero, if unknown).
47612: */
47613: SQLITE_PRIVATE Pgno sqlite3WalDbsize(Wal *pWal){
47614: if( pWal && ALWAYS(pWal->readLock>=0) ){
47615: return pWal->hdr.nPage;
47616: }
47617: return 0;
47618: }
47619:
47620:
47621: /*
47622: ** This function starts a write transaction on the WAL.
47623: **
47624: ** A read transaction must have already been started by a prior call
47625: ** to sqlite3WalBeginReadTransaction().
47626: **
47627: ** If another thread or process has written into the database since
47628: ** the read transaction was started, then it is not possible for this
47629: ** thread to write as doing so would cause a fork. So this routine
47630: ** returns SQLITE_BUSY in that case and no write transaction is started.
47631: **
47632: ** There can only be a single writer active at a time.
47633: */
47634: SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal){
47635: int rc;
47636:
47637: /* Cannot start a write transaction without first holding a read
47638: ** transaction. */
47639: assert( pWal->readLock>=0 );
47640:
47641: if( pWal->readOnly ){
47642: return SQLITE_READONLY;
47643: }
47644:
47645: /* Only one writer allowed at a time. Get the write lock. Return
47646: ** SQLITE_BUSY if unable.
47647: */
47648: rc = walLockExclusive(pWal, WAL_WRITE_LOCK, 1);
47649: if( rc ){
47650: return rc;
47651: }
47652: pWal->writeLock = 1;
47653:
47654: /* If another connection has written to the database file since the
47655: ** time the read transaction on this connection was started, then
47656: ** the write is disallowed.
47657: */
47658: if( memcmp(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr))!=0 ){
47659: walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
47660: pWal->writeLock = 0;
47661: rc = SQLITE_BUSY;
47662: }
47663:
47664: return rc;
47665: }
47666:
47667: /*
47668: ** End a write transaction. The commit has already been done. This
47669: ** routine merely releases the lock.
47670: */
47671: SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){
47672: if( pWal->writeLock ){
47673: walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
47674: pWal->writeLock = 0;
47675: pWal->truncateOnCommit = 0;
47676: }
47677: return SQLITE_OK;
47678: }
47679:
47680: /*
47681: ** If any data has been written (but not committed) to the log file, this
47682: ** function moves the write-pointer back to the start of the transaction.
47683: **
47684: ** Additionally, the callback function is invoked for each frame written
47685: ** to the WAL since the start of the transaction. If the callback returns
47686: ** other than SQLITE_OK, it is not invoked again and the error code is
47687: ** returned to the caller.
47688: **
47689: ** Otherwise, if the callback function does not return an error, this
47690: ** function returns SQLITE_OK.
47691: */
47692: SQLITE_PRIVATE int sqlite3WalUndo(Wal *pWal, int (*xUndo)(void *, Pgno), void *pUndoCtx){
47693: int rc = SQLITE_OK;
47694: if( ALWAYS(pWal->writeLock) ){
47695: Pgno iMax = pWal->hdr.mxFrame;
47696: Pgno iFrame;
47697:
47698: /* Restore the clients cache of the wal-index header to the state it
47699: ** was in before the client began writing to the database.
47700: */
47701: memcpy(&pWal->hdr, (void *)walIndexHdr(pWal), sizeof(WalIndexHdr));
47702:
47703: for(iFrame=pWal->hdr.mxFrame+1;
47704: ALWAYS(rc==SQLITE_OK) && iFrame<=iMax;
47705: iFrame++
47706: ){
47707: /* This call cannot fail. Unless the page for which the page number
47708: ** is passed as the second argument is (a) in the cache and
47709: ** (b) has an outstanding reference, then xUndo is either a no-op
47710: ** (if (a) is false) or simply expels the page from the cache (if (b)
47711: ** is false).
47712: **
47713: ** If the upper layer is doing a rollback, it is guaranteed that there
47714: ** are no outstanding references to any page other than page 1. And
47715: ** page 1 is never written to the log until the transaction is
47716: ** committed. As a result, the call to xUndo may not fail.
47717: */
47718: assert( walFramePgno(pWal, iFrame)!=1 );
47719: rc = xUndo(pUndoCtx, walFramePgno(pWal, iFrame));
47720: }
47721: walCleanupHash(pWal);
47722: }
47723: assert( rc==SQLITE_OK );
47724: return rc;
47725: }
47726:
47727: /*
47728: ** Argument aWalData must point to an array of WAL_SAVEPOINT_NDATA u32
47729: ** values. This function populates the array with values required to
47730: ** "rollback" the write position of the WAL handle back to the current
47731: ** point in the event of a savepoint rollback (via WalSavepointUndo()).
47732: */
47733: SQLITE_PRIVATE void sqlite3WalSavepoint(Wal *pWal, u32 *aWalData){
47734: assert( pWal->writeLock );
47735: aWalData[0] = pWal->hdr.mxFrame;
47736: aWalData[1] = pWal->hdr.aFrameCksum[0];
47737: aWalData[2] = pWal->hdr.aFrameCksum[1];
47738: aWalData[3] = pWal->nCkpt;
47739: }
47740:
47741: /*
47742: ** Move the write position of the WAL back to the point identified by
47743: ** the values in the aWalData[] array. aWalData must point to an array
47744: ** of WAL_SAVEPOINT_NDATA u32 values that has been previously populated
47745: ** by a call to WalSavepoint().
47746: */
47747: SQLITE_PRIVATE int sqlite3WalSavepointUndo(Wal *pWal, u32 *aWalData){
47748: int rc = SQLITE_OK;
47749:
47750: assert( pWal->writeLock );
47751: assert( aWalData[3]!=pWal->nCkpt || aWalData[0]<=pWal->hdr.mxFrame );
47752:
47753: if( aWalData[3]!=pWal->nCkpt ){
47754: /* This savepoint was opened immediately after the write-transaction
47755: ** was started. Right after that, the writer decided to wrap around
47756: ** to the start of the log. Update the savepoint values to match.
47757: */
47758: aWalData[0] = 0;
47759: aWalData[3] = pWal->nCkpt;
47760: }
47761:
47762: if( aWalData[0]<pWal->hdr.mxFrame ){
47763: pWal->hdr.mxFrame = aWalData[0];
47764: pWal->hdr.aFrameCksum[0] = aWalData[1];
47765: pWal->hdr.aFrameCksum[1] = aWalData[2];
47766: walCleanupHash(pWal);
47767: }
47768:
47769: return rc;
47770: }
47771:
47772:
47773: /*
47774: ** This function is called just before writing a set of frames to the log
47775: ** file (see sqlite3WalFrames()). It checks to see if, instead of appending
47776: ** to the current log file, it is possible to overwrite the start of the
47777: ** existing log file with the new frames (i.e. "reset" the log). If so,
47778: ** it sets pWal->hdr.mxFrame to 0. Otherwise, pWal->hdr.mxFrame is left
47779: ** unchanged.
47780: **
47781: ** SQLITE_OK is returned if no error is encountered (regardless of whether
47782: ** or not pWal->hdr.mxFrame is modified). An SQLite error code is returned
47783: ** if an error occurs.
47784: */
47785: static int walRestartLog(Wal *pWal){
47786: int rc = SQLITE_OK;
47787: int cnt;
47788:
47789: if( pWal->readLock==0 ){
47790: volatile WalCkptInfo *pInfo = walCkptInfo(pWal);
47791: assert( pInfo->nBackfill==pWal->hdr.mxFrame );
47792: if( pInfo->nBackfill>0 ){
47793: u32 salt1;
47794: sqlite3_randomness(4, &salt1);
47795: rc = walLockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
47796: if( rc==SQLITE_OK ){
47797: /* If all readers are using WAL_READ_LOCK(0) (in other words if no
47798: ** readers are currently using the WAL), then the transactions
47799: ** frames will overwrite the start of the existing log. Update the
47800: ** wal-index header to reflect this.
47801: **
47802: ** In theory it would be Ok to update the cache of the header only
47803: ** at this point. But updating the actual wal-index header is also
47804: ** safe and means there is no special case for sqlite3WalUndo()
47805: ** to handle if this transaction is rolled back.
47806: */
47807: int i; /* Loop counter */
47808: u32 *aSalt = pWal->hdr.aSalt; /* Big-endian salt values */
47809:
47810: pWal->nCkpt++;
47811: pWal->hdr.mxFrame = 0;
47812: sqlite3Put4byte((u8*)&aSalt[0], 1 + sqlite3Get4byte((u8*)&aSalt[0]));
47813: aSalt[1] = salt1;
47814: walIndexWriteHdr(pWal);
47815: pInfo->nBackfill = 0;
47816: for(i=1; i<WAL_NREADER; i++) pInfo->aReadMark[i] = READMARK_NOT_USED;
47817: assert( pInfo->aReadMark[0]==0 );
47818: walUnlockExclusive(pWal, WAL_READ_LOCK(1), WAL_NREADER-1);
47819: }else if( rc!=SQLITE_BUSY ){
47820: return rc;
47821: }
47822: }
47823: walUnlockShared(pWal, WAL_READ_LOCK(0));
47824: pWal->readLock = -1;
47825: cnt = 0;
47826: do{
47827: int notUsed;
47828: rc = walTryBeginRead(pWal, ¬Used, 1, ++cnt);
47829: }while( rc==WAL_RETRY );
47830: assert( (rc&0xff)!=SQLITE_BUSY ); /* BUSY not possible when useWal==1 */
47831: testcase( (rc&0xff)==SQLITE_IOERR );
47832: testcase( rc==SQLITE_PROTOCOL );
47833: testcase( rc==SQLITE_OK );
47834: }
47835: return rc;
47836: }
47837:
47838: /*
47839: ** Information about the current state of the WAL file and where
47840: ** the next fsync should occur - passed from sqlite3WalFrames() into
47841: ** walWriteToLog().
47842: */
47843: typedef struct WalWriter {
47844: Wal *pWal; /* The complete WAL information */
47845: sqlite3_file *pFd; /* The WAL file to which we write */
47846: sqlite3_int64 iSyncPoint; /* Fsync at this offset */
47847: int syncFlags; /* Flags for the fsync */
47848: int szPage; /* Size of one page */
47849: } WalWriter;
47850:
47851: /*
47852: ** Write iAmt bytes of content into the WAL file beginning at iOffset.
47853: ** Do a sync when crossing the p->iSyncPoint boundary.
47854: **
47855: ** In other words, if iSyncPoint is in between iOffset and iOffset+iAmt,
47856: ** first write the part before iSyncPoint, then sync, then write the
47857: ** rest.
47858: */
47859: static int walWriteToLog(
47860: WalWriter *p, /* WAL to write to */
47861: void *pContent, /* Content to be written */
47862: int iAmt, /* Number of bytes to write */
47863: sqlite3_int64 iOffset /* Start writing at this offset */
47864: ){
47865: int rc;
47866: if( iOffset<p->iSyncPoint && iOffset+iAmt>=p->iSyncPoint ){
47867: int iFirstAmt = (int)(p->iSyncPoint - iOffset);
47868: rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset);
47869: if( rc ) return rc;
47870: iOffset += iFirstAmt;
47871: iAmt -= iFirstAmt;
47872: pContent = (void*)(iFirstAmt + (char*)pContent);
47873: assert( p->syncFlags & (SQLITE_SYNC_NORMAL|SQLITE_SYNC_FULL) );
47874: rc = sqlite3OsSync(p->pFd, p->syncFlags);
47875: if( iAmt==0 || rc ) return rc;
47876: }
47877: rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset);
47878: return rc;
47879: }
47880:
47881: /*
47882: ** Write out a single frame of the WAL
47883: */
47884: static int walWriteOneFrame(
47885: WalWriter *p, /* Where to write the frame */
47886: PgHdr *pPage, /* The page of the frame to be written */
47887: int nTruncate, /* The commit flag. Usually 0. >0 for commit */
47888: sqlite3_int64 iOffset /* Byte offset at which to write */
47889: ){
47890: int rc; /* Result code from subfunctions */
47891: void *pData; /* Data actually written */
47892: u8 aFrame[WAL_FRAME_HDRSIZE]; /* Buffer to assemble frame-header in */
47893: #if defined(SQLITE_HAS_CODEC)
47894: if( (pData = sqlite3PagerCodec(pPage))==0 ) return SQLITE_NOMEM;
47895: #else
47896: pData = pPage->pData;
47897: #endif
47898: walEncodeFrame(p->pWal, pPage->pgno, nTruncate, pData, aFrame);
47899: rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset);
47900: if( rc ) return rc;
47901: /* Write the page data */
47902: rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame));
47903: return rc;
47904: }
47905:
47906: /*
47907: ** Write a set of frames to the log. The caller must hold the write-lock
47908: ** on the log file (obtained using sqlite3WalBeginWriteTransaction()).
47909: */
47910: SQLITE_PRIVATE int sqlite3WalFrames(
47911: Wal *pWal, /* Wal handle to write to */
47912: int szPage, /* Database page-size in bytes */
47913: PgHdr *pList, /* List of dirty pages to write */
47914: Pgno nTruncate, /* Database size after this commit */
47915: int isCommit, /* True if this is a commit */
47916: int sync_flags /* Flags to pass to OsSync() (or 0) */
47917: ){
47918: int rc; /* Used to catch return codes */
47919: u32 iFrame; /* Next frame address */
47920: PgHdr *p; /* Iterator to run through pList with. */
47921: PgHdr *pLast = 0; /* Last frame in list */
47922: int nExtra = 0; /* Number of extra copies of last page */
47923: int szFrame; /* The size of a single frame */
47924: i64 iOffset; /* Next byte to write in WAL file */
47925: WalWriter w; /* The writer */
47926:
47927: assert( pList );
47928: assert( pWal->writeLock );
47929:
47930: /* If this frame set completes a transaction, then nTruncate>0. If
47931: ** nTruncate==0 then this frame set does not complete the transaction. */
47932: assert( (isCommit!=0)==(nTruncate!=0) );
47933:
47934: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
47935: { int cnt; for(cnt=0, p=pList; p; p=p->pDirty, cnt++){}
47936: WALTRACE(("WAL%p: frame write begin. %d frames. mxFrame=%d. %s\n",
47937: pWal, cnt, pWal->hdr.mxFrame, isCommit ? "Commit" : "Spill"));
47938: }
47939: #endif
47940:
47941: /* See if it is possible to write these frames into the start of the
47942: ** log file, instead of appending to it at pWal->hdr.mxFrame.
47943: */
47944: if( SQLITE_OK!=(rc = walRestartLog(pWal)) ){
47945: return rc;
47946: }
47947:
47948: /* If this is the first frame written into the log, write the WAL
47949: ** header to the start of the WAL file. See comments at the top of
47950: ** this source file for a description of the WAL header format.
47951: */
47952: iFrame = pWal->hdr.mxFrame;
47953: if( iFrame==0 ){
47954: u8 aWalHdr[WAL_HDRSIZE]; /* Buffer to assemble wal-header in */
47955: u32 aCksum[2]; /* Checksum for wal-header */
47956:
47957: sqlite3Put4byte(&aWalHdr[0], (WAL_MAGIC | SQLITE_BIGENDIAN));
47958: sqlite3Put4byte(&aWalHdr[4], WAL_MAX_VERSION);
47959: sqlite3Put4byte(&aWalHdr[8], szPage);
47960: sqlite3Put4byte(&aWalHdr[12], pWal->nCkpt);
47961: if( pWal->nCkpt==0 ) sqlite3_randomness(8, pWal->hdr.aSalt);
47962: memcpy(&aWalHdr[16], pWal->hdr.aSalt, 8);
47963: walChecksumBytes(1, aWalHdr, WAL_HDRSIZE-2*4, 0, aCksum);
47964: sqlite3Put4byte(&aWalHdr[24], aCksum[0]);
47965: sqlite3Put4byte(&aWalHdr[28], aCksum[1]);
47966:
47967: pWal->szPage = szPage;
47968: pWal->hdr.bigEndCksum = SQLITE_BIGENDIAN;
47969: pWal->hdr.aFrameCksum[0] = aCksum[0];
47970: pWal->hdr.aFrameCksum[1] = aCksum[1];
47971: pWal->truncateOnCommit = 1;
47972:
47973: rc = sqlite3OsWrite(pWal->pWalFd, aWalHdr, sizeof(aWalHdr), 0);
47974: WALTRACE(("WAL%p: wal-header write %s\n", pWal, rc ? "failed" : "ok"));
47975: if( rc!=SQLITE_OK ){
47976: return rc;
47977: }
47978:
47979: /* Sync the header (unless SQLITE_IOCAP_SEQUENTIAL is true or unless
47980: ** all syncing is turned off by PRAGMA synchronous=OFF). Otherwise
47981: ** an out-of-order write following a WAL restart could result in
47982: ** database corruption. See the ticket:
47983: **
47984: ** http://localhost:591/sqlite/info/ff5be73dee
47985: */
47986: if( pWal->syncHeader && sync_flags ){
47987: rc = sqlite3OsSync(pWal->pWalFd, sync_flags & SQLITE_SYNC_MASK);
47988: if( rc ) return rc;
47989: }
47990: }
47991: assert( (int)pWal->szPage==szPage );
47992:
47993: /* Setup information needed to write frames into the WAL */
47994: w.pWal = pWal;
47995: w.pFd = pWal->pWalFd;
47996: w.iSyncPoint = 0;
47997: w.syncFlags = sync_flags;
47998: w.szPage = szPage;
47999: iOffset = walFrameOffset(iFrame+1, szPage);
48000: szFrame = szPage + WAL_FRAME_HDRSIZE;
48001:
48002: /* Write all frames into the log file exactly once */
48003: for(p=pList; p; p=p->pDirty){
48004: int nDbSize; /* 0 normally. Positive == commit flag */
48005: iFrame++;
48006: assert( iOffset==walFrameOffset(iFrame, szPage) );
48007: nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0;
48008: rc = walWriteOneFrame(&w, p, nDbSize, iOffset);
48009: if( rc ) return rc;
48010: pLast = p;
48011: iOffset += szFrame;
48012: }
48013:
48014: /* If this is the end of a transaction, then we might need to pad
48015: ** the transaction and/or sync the WAL file.
48016: **
48017: ** Padding and syncing only occur if this set of frames complete a
48018: ** transaction and if PRAGMA synchronous=FULL. If synchronous==NORMAL
48019: ** or synchonous==OFF, then no padding or syncing are needed.
48020: **
48021: ** If SQLITE_IOCAP_POWERSAFE_OVERWRITE is defined, then padding is not
48022: ** needed and only the sync is done. If padding is needed, then the
48023: ** final frame is repeated (with its commit mark) until the next sector
48024: ** boundary is crossed. Only the part of the WAL prior to the last
48025: ** sector boundary is synced; the part of the last frame that extends
48026: ** past the sector boundary is written after the sync.
48027: */
48028: if( isCommit && (sync_flags & WAL_SYNC_TRANSACTIONS)!=0 ){
48029: if( pWal->padToSectorBoundary ){
48030: int sectorSize = sqlite3OsSectorSize(pWal->pWalFd);
48031: w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize;
48032: while( iOffset<w.iSyncPoint ){
48033: rc = walWriteOneFrame(&w, pLast, nTruncate, iOffset);
48034: if( rc ) return rc;
48035: iOffset += szFrame;
48036: nExtra++;
48037: }
48038: }else{
48039: rc = sqlite3OsSync(w.pFd, sync_flags & SQLITE_SYNC_MASK);
48040: }
48041: }
48042:
48043: /* If this frame set completes the first transaction in the WAL and
48044: ** if PRAGMA journal_size_limit is set, then truncate the WAL to the
48045: ** journal size limit, if possible.
48046: */
48047: if( isCommit && pWal->truncateOnCommit && pWal->mxWalSize>=0 ){
48048: i64 sz = pWal->mxWalSize;
48049: if( walFrameOffset(iFrame+nExtra+1, szPage)>pWal->mxWalSize ){
48050: sz = walFrameOffset(iFrame+nExtra+1, szPage);
48051: }
48052: walLimitSize(pWal, sz);
48053: pWal->truncateOnCommit = 0;
48054: }
48055:
48056: /* Append data to the wal-index. It is not necessary to lock the
48057: ** wal-index to do this as the SQLITE_SHM_WRITE lock held on the wal-index
48058: ** guarantees that there are no other writers, and no data that may
48059: ** be in use by existing readers is being overwritten.
48060: */
48061: iFrame = pWal->hdr.mxFrame;
48062: for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
48063: iFrame++;
48064: rc = walIndexAppend(pWal, iFrame, p->pgno);
48065: }
48066: while( rc==SQLITE_OK && nExtra>0 ){
48067: iFrame++;
48068: nExtra--;
48069: rc = walIndexAppend(pWal, iFrame, pLast->pgno);
48070: }
48071:
48072: if( rc==SQLITE_OK ){
48073: /* Update the private copy of the header. */
48074: pWal->hdr.szPage = (u16)((szPage&0xff00) | (szPage>>16));
48075: testcase( szPage<=32768 );
48076: testcase( szPage>=65536 );
48077: pWal->hdr.mxFrame = iFrame;
48078: if( isCommit ){
48079: pWal->hdr.iChange++;
48080: pWal->hdr.nPage = nTruncate;
48081: }
48082: /* If this is a commit, update the wal-index header too. */
48083: if( isCommit ){
48084: walIndexWriteHdr(pWal);
48085: pWal->iCallback = iFrame;
48086: }
48087: }
48088:
48089: WALTRACE(("WAL%p: frame write %s\n", pWal, rc ? "failed" : "ok"));
48090: return rc;
48091: }
48092:
48093: /*
48094: ** This routine is called to implement sqlite3_wal_checkpoint() and
48095: ** related interfaces.
48096: **
48097: ** Obtain a CHECKPOINT lock and then backfill as much information as
48098: ** we can from WAL into the database.
48099: **
48100: ** If parameter xBusy is not NULL, it is a pointer to a busy-handler
48101: ** callback. In this case this function runs a blocking checkpoint.
48102: */
48103: SQLITE_PRIVATE int sqlite3WalCheckpoint(
48104: Wal *pWal, /* Wal connection */
48105: int eMode, /* PASSIVE, FULL or RESTART */
48106: int (*xBusy)(void*), /* Function to call when busy */
48107: void *pBusyArg, /* Context argument for xBusyHandler */
48108: int sync_flags, /* Flags to sync db file with (or 0) */
48109: int nBuf, /* Size of temporary buffer */
48110: u8 *zBuf, /* Temporary buffer to use */
48111: int *pnLog, /* OUT: Number of frames in WAL */
48112: int *pnCkpt /* OUT: Number of backfilled frames in WAL */
48113: ){
48114: int rc; /* Return code */
48115: int isChanged = 0; /* True if a new wal-index header is loaded */
48116: int eMode2 = eMode; /* Mode to pass to walCheckpoint() */
48117:
48118: assert( pWal->ckptLock==0 );
48119: assert( pWal->writeLock==0 );
48120:
48121: if( pWal->readOnly ) return SQLITE_READONLY;
48122: WALTRACE(("WAL%p: checkpoint begins\n", pWal));
48123: rc = walLockExclusive(pWal, WAL_CKPT_LOCK, 1);
48124: if( rc ){
48125: /* Usually this is SQLITE_BUSY meaning that another thread or process
48126: ** is already running a checkpoint, or maybe a recovery. But it might
48127: ** also be SQLITE_IOERR. */
48128: return rc;
48129: }
48130: pWal->ckptLock = 1;
48131:
48132: /* If this is a blocking-checkpoint, then obtain the write-lock as well
48133: ** to prevent any writers from running while the checkpoint is underway.
48134: ** This has to be done before the call to walIndexReadHdr() below.
48135: **
48136: ** If the writer lock cannot be obtained, then a passive checkpoint is
48137: ** run instead. Since the checkpointer is not holding the writer lock,
48138: ** there is no point in blocking waiting for any readers. Assuming no
48139: ** other error occurs, this function will return SQLITE_BUSY to the caller.
48140: */
48141: if( eMode!=SQLITE_CHECKPOINT_PASSIVE ){
48142: rc = walBusyLock(pWal, xBusy, pBusyArg, WAL_WRITE_LOCK, 1);
48143: if( rc==SQLITE_OK ){
48144: pWal->writeLock = 1;
48145: }else if( rc==SQLITE_BUSY ){
48146: eMode2 = SQLITE_CHECKPOINT_PASSIVE;
48147: rc = SQLITE_OK;
48148: }
48149: }
48150:
48151: /* Read the wal-index header. */
48152: if( rc==SQLITE_OK ){
48153: rc = walIndexReadHdr(pWal, &isChanged);
48154: }
48155:
48156: /* Copy data from the log to the database file. */
48157: if( rc==SQLITE_OK ){
48158: if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){
48159: rc = SQLITE_CORRUPT_BKPT;
48160: }else{
48161: rc = walCheckpoint(pWal, eMode2, xBusy, pBusyArg, sync_flags, zBuf);
48162: }
48163:
48164: /* If no error occurred, set the output variables. */
48165: if( rc==SQLITE_OK || rc==SQLITE_BUSY ){
48166: if( pnLog ) *pnLog = (int)pWal->hdr.mxFrame;
48167: if( pnCkpt ) *pnCkpt = (int)(walCkptInfo(pWal)->nBackfill);
48168: }
48169: }
48170:
48171: if( isChanged ){
48172: /* If a new wal-index header was loaded before the checkpoint was
48173: ** performed, then the pager-cache associated with pWal is now
48174: ** out of date. So zero the cached wal-index header to ensure that
48175: ** next time the pager opens a snapshot on this database it knows that
48176: ** the cache needs to be reset.
48177: */
48178: memset(&pWal->hdr, 0, sizeof(WalIndexHdr));
48179: }
48180:
48181: /* Release the locks. */
48182: sqlite3WalEndWriteTransaction(pWal);
48183: walUnlockExclusive(pWal, WAL_CKPT_LOCK, 1);
48184: pWal->ckptLock = 0;
48185: WALTRACE(("WAL%p: checkpoint %s\n", pWal, rc ? "failed" : "ok"));
48186: return (rc==SQLITE_OK && eMode!=eMode2 ? SQLITE_BUSY : rc);
48187: }
48188:
48189: /* Return the value to pass to a sqlite3_wal_hook callback, the
48190: ** number of frames in the WAL at the point of the last commit since
48191: ** sqlite3WalCallback() was called. If no commits have occurred since
48192: ** the last call, then return 0.
48193: */
48194: SQLITE_PRIVATE int sqlite3WalCallback(Wal *pWal){
48195: u32 ret = 0;
48196: if( pWal ){
48197: ret = pWal->iCallback;
48198: pWal->iCallback = 0;
48199: }
48200: return (int)ret;
48201: }
48202:
48203: /*
48204: ** This function is called to change the WAL subsystem into or out
48205: ** of locking_mode=EXCLUSIVE.
48206: **
48207: ** If op is zero, then attempt to change from locking_mode=EXCLUSIVE
48208: ** into locking_mode=NORMAL. This means that we must acquire a lock
48209: ** on the pWal->readLock byte. If the WAL is already in locking_mode=NORMAL
48210: ** or if the acquisition of the lock fails, then return 0. If the
48211: ** transition out of exclusive-mode is successful, return 1. This
48212: ** operation must occur while the pager is still holding the exclusive
48213: ** lock on the main database file.
48214: **
48215: ** If op is one, then change from locking_mode=NORMAL into
48216: ** locking_mode=EXCLUSIVE. This means that the pWal->readLock must
48217: ** be released. Return 1 if the transition is made and 0 if the
48218: ** WAL is already in exclusive-locking mode - meaning that this
48219: ** routine is a no-op. The pager must already hold the exclusive lock
48220: ** on the main database file before invoking this operation.
48221: **
48222: ** If op is negative, then do a dry-run of the op==1 case but do
48223: ** not actually change anything. The pager uses this to see if it
48224: ** should acquire the database exclusive lock prior to invoking
48225: ** the op==1 case.
48226: */
48227: SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op){
48228: int rc;
48229: assert( pWal->writeLock==0 );
48230: assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 );
48231:
48232: /* pWal->readLock is usually set, but might be -1 if there was a
48233: ** prior error while attempting to acquire are read-lock. This cannot
48234: ** happen if the connection is actually in exclusive mode (as no xShmLock
48235: ** locks are taken in this case). Nor should the pager attempt to
48236: ** upgrade to exclusive-mode following such an error.
48237: */
48238: assert( pWal->readLock>=0 || pWal->lockError );
48239: assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
48240:
48241: if( op==0 ){
48242: if( pWal->exclusiveMode ){
48243: pWal->exclusiveMode = 0;
48244: if( walLockShared(pWal, WAL_READ_LOCK(pWal->readLock))!=SQLITE_OK ){
48245: pWal->exclusiveMode = 1;
48246: }
48247: rc = pWal->exclusiveMode==0;
48248: }else{
48249: /* Already in locking_mode=NORMAL */
48250: rc = 0;
48251: }
48252: }else if( op>0 ){
48253: assert( pWal->exclusiveMode==0 );
48254: assert( pWal->readLock>=0 );
48255: walUnlockShared(pWal, WAL_READ_LOCK(pWal->readLock));
48256: pWal->exclusiveMode = 1;
48257: rc = 1;
48258: }else{
48259: rc = pWal->exclusiveMode==0;
48260: }
48261: return rc;
48262: }
48263:
48264: /*
48265: ** Return true if the argument is non-NULL and the WAL module is using
48266: ** heap-memory for the wal-index. Otherwise, if the argument is NULL or the
48267: ** WAL module is using shared-memory, return false.
48268: */
48269: SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal){
48270: return (pWal && pWal->exclusiveMode==WAL_HEAPMEMORY_MODE );
48271: }
48272:
48273: #endif /* #ifndef SQLITE_OMIT_WAL */
48274:
48275: /************** End of wal.c *************************************************/
48276: /************** Begin file btmutex.c *****************************************/
48277: /*
48278: ** 2007 August 27
48279: **
48280: ** The author disclaims copyright to this source code. In place of
48281: ** a legal notice, here is a blessing:
48282: **
48283: ** May you do good and not evil.
48284: ** May you find forgiveness for yourself and forgive others.
48285: ** May you share freely, never taking more than you give.
48286: **
48287: *************************************************************************
48288: **
48289: ** This file contains code used to implement mutexes on Btree objects.
48290: ** This code really belongs in btree.c. But btree.c is getting too
48291: ** big and we want to break it down some. This packaged seemed like
48292: ** a good breakout.
48293: */
48294: /************** Include btreeInt.h in the middle of btmutex.c ****************/
48295: /************** Begin file btreeInt.h ****************************************/
48296: /*
48297: ** 2004 April 6
48298: **
48299: ** The author disclaims copyright to this source code. In place of
48300: ** a legal notice, here is a blessing:
48301: **
48302: ** May you do good and not evil.
48303: ** May you find forgiveness for yourself and forgive others.
48304: ** May you share freely, never taking more than you give.
48305: **
48306: *************************************************************************
48307: ** This file implements a external (disk-based) database using BTrees.
48308: ** For a detailed discussion of BTrees, refer to
48309: **
48310: ** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3:
48311: ** "Sorting And Searching", pages 473-480. Addison-Wesley
48312: ** Publishing Company, Reading, Massachusetts.
48313: **
48314: ** The basic idea is that each page of the file contains N database
48315: ** entries and N+1 pointers to subpages.
48316: **
48317: ** ----------------------------------------------------------------
48318: ** | Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N-1) | Ptr(N) |
48319: ** ----------------------------------------------------------------
48320: **
48321: ** All of the keys on the page that Ptr(0) points to have values less
48322: ** than Key(0). All of the keys on page Ptr(1) and its subpages have
48323: ** values greater than Key(0) and less than Key(1). All of the keys
48324: ** on Ptr(N) and its subpages have values greater than Key(N-1). And
48325: ** so forth.
48326: **
48327: ** Finding a particular key requires reading O(log(M)) pages from the
48328: ** disk where M is the number of entries in the tree.
48329: **
48330: ** In this implementation, a single file can hold one or more separate
48331: ** BTrees. Each BTree is identified by the index of its root page. The
48332: ** key and data for any entry are combined to form the "payload". A
48333: ** fixed amount of payload can be carried directly on the database
48334: ** page. If the payload is larger than the preset amount then surplus
48335: ** bytes are stored on overflow pages. The payload for an entry
48336: ** and the preceding pointer are combined to form a "Cell". Each
48337: ** page has a small header which contains the Ptr(N) pointer and other
48338: ** information such as the size of key and data.
48339: **
48340: ** FORMAT DETAILS
48341: **
48342: ** The file is divided into pages. The first page is called page 1,
48343: ** the second is page 2, and so forth. A page number of zero indicates
48344: ** "no such page". The page size can be any power of 2 between 512 and 65536.
48345: ** Each page can be either a btree page, a freelist page, an overflow
48346: ** page, or a pointer-map page.
48347: **
48348: ** The first page is always a btree page. The first 100 bytes of the first
48349: ** page contain a special header (the "file header") that describes the file.
48350: ** The format of the file header is as follows:
48351: **
48352: ** OFFSET SIZE DESCRIPTION
48353: ** 0 16 Header string: "SQLite format 3\000"
48354: ** 16 2 Page size in bytes.
48355: ** 18 1 File format write version
48356: ** 19 1 File format read version
48357: ** 20 1 Bytes of unused space at the end of each page
48358: ** 21 1 Max embedded payload fraction
48359: ** 22 1 Min embedded payload fraction
48360: ** 23 1 Min leaf payload fraction
48361: ** 24 4 File change counter
48362: ** 28 4 Reserved for future use
48363: ** 32 4 First freelist page
48364: ** 36 4 Number of freelist pages in the file
48365: ** 40 60 15 4-byte meta values passed to higher layers
48366: **
48367: ** 40 4 Schema cookie
48368: ** 44 4 File format of schema layer
48369: ** 48 4 Size of page cache
48370: ** 52 4 Largest root-page (auto/incr_vacuum)
48371: ** 56 4 1=UTF-8 2=UTF16le 3=UTF16be
48372: ** 60 4 User version
48373: ** 64 4 Incremental vacuum mode
48374: ** 68 4 unused
48375: ** 72 4 unused
48376: ** 76 4 unused
48377: **
48378: ** All of the integer values are big-endian (most significant byte first).
48379: **
48380: ** The file change counter is incremented when the database is changed
48381: ** This counter allows other processes to know when the file has changed
48382: ** and thus when they need to flush their cache.
48383: **
48384: ** The max embedded payload fraction is the amount of the total usable
48385: ** space in a page that can be consumed by a single cell for standard
48386: ** B-tree (non-LEAFDATA) tables. A value of 255 means 100%. The default
48387: ** is to limit the maximum cell size so that at least 4 cells will fit
48388: ** on one page. Thus the default max embedded payload fraction is 64.
48389: **
48390: ** If the payload for a cell is larger than the max payload, then extra
48391: ** payload is spilled to overflow pages. Once an overflow page is allocated,
48392: ** as many bytes as possible are moved into the overflow pages without letting
48393: ** the cell size drop below the min embedded payload fraction.
48394: **
48395: ** The min leaf payload fraction is like the min embedded payload fraction
48396: ** except that it applies to leaf nodes in a LEAFDATA tree. The maximum
48397: ** payload fraction for a LEAFDATA tree is always 100% (or 255) and it
48398: ** not specified in the header.
48399: **
48400: ** Each btree pages is divided into three sections: The header, the
48401: ** cell pointer array, and the cell content area. Page 1 also has a 100-byte
48402: ** file header that occurs before the page header.
48403: **
48404: ** |----------------|
48405: ** | file header | 100 bytes. Page 1 only.
48406: ** |----------------|
48407: ** | page header | 8 bytes for leaves. 12 bytes for interior nodes
48408: ** |----------------|
48409: ** | cell pointer | | 2 bytes per cell. Sorted order.
48410: ** | array | | Grows downward
48411: ** | | v
48412: ** |----------------|
48413: ** | unallocated |
48414: ** | space |
48415: ** |----------------| ^ Grows upwards
48416: ** | cell content | | Arbitrary order interspersed with freeblocks.
48417: ** | area | | and free space fragments.
48418: ** |----------------|
48419: **
48420: ** The page headers looks like this:
48421: **
48422: ** OFFSET SIZE DESCRIPTION
48423: ** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf
48424: ** 1 2 byte offset to the first freeblock
48425: ** 3 2 number of cells on this page
48426: ** 5 2 first byte of the cell content area
48427: ** 7 1 number of fragmented free bytes
48428: ** 8 4 Right child (the Ptr(N) value). Omitted on leaves.
48429: **
48430: ** The flags define the format of this btree page. The leaf flag means that
48431: ** this page has no children. The zerodata flag means that this page carries
48432: ** only keys and no data. The intkey flag means that the key is a integer
48433: ** which is stored in the key size entry of the cell header rather than in
48434: ** the payload area.
48435: **
48436: ** The cell pointer array begins on the first byte after the page header.
48437: ** The cell pointer array contains zero or more 2-byte numbers which are
48438: ** offsets from the beginning of the page to the cell content in the cell
48439: ** content area. The cell pointers occur in sorted order. The system strives
48440: ** to keep free space after the last cell pointer so that new cells can
48441: ** be easily added without having to defragment the page.
48442: **
48443: ** Cell content is stored at the very end of the page and grows toward the
48444: ** beginning of the page.
48445: **
48446: ** Unused space within the cell content area is collected into a linked list of
48447: ** freeblocks. Each freeblock is at least 4 bytes in size. The byte offset
48448: ** to the first freeblock is given in the header. Freeblocks occur in
48449: ** increasing order. Because a freeblock must be at least 4 bytes in size,
48450: ** any group of 3 or fewer unused bytes in the cell content area cannot
48451: ** exist on the freeblock chain. A group of 3 or fewer free bytes is called
48452: ** a fragment. The total number of bytes in all fragments is recorded.
48453: ** in the page header at offset 7.
48454: **
48455: ** SIZE DESCRIPTION
48456: ** 2 Byte offset of the next freeblock
48457: ** 2 Bytes in this freeblock
48458: **
48459: ** Cells are of variable length. Cells are stored in the cell content area at
48460: ** the end of the page. Pointers to the cells are in the cell pointer array
48461: ** that immediately follows the page header. Cells is not necessarily
48462: ** contiguous or in order, but cell pointers are contiguous and in order.
48463: **
48464: ** Cell content makes use of variable length integers. A variable
48465: ** length integer is 1 to 9 bytes where the lower 7 bits of each
48466: ** byte are used. The integer consists of all bytes that have bit 8 set and
48467: ** the first byte with bit 8 clear. The most significant byte of the integer
48468: ** appears first. A variable-length integer may not be more than 9 bytes long.
48469: ** As a special case, all 8 bytes of the 9th byte are used as data. This
48470: ** allows a 64-bit integer to be encoded in 9 bytes.
48471: **
48472: ** 0x00 becomes 0x00000000
48473: ** 0x7f becomes 0x0000007f
48474: ** 0x81 0x00 becomes 0x00000080
48475: ** 0x82 0x00 becomes 0x00000100
48476: ** 0x80 0x7f becomes 0x0000007f
48477: ** 0x8a 0x91 0xd1 0xac 0x78 becomes 0x12345678
48478: ** 0x81 0x81 0x81 0x81 0x01 becomes 0x10204081
48479: **
48480: ** Variable length integers are used for rowids and to hold the number of
48481: ** bytes of key and data in a btree cell.
48482: **
48483: ** The content of a cell looks like this:
48484: **
48485: ** SIZE DESCRIPTION
48486: ** 4 Page number of the left child. Omitted if leaf flag is set.
48487: ** var Number of bytes of data. Omitted if the zerodata flag is set.
48488: ** var Number of bytes of key. Or the key itself if intkey flag is set.
48489: ** * Payload
48490: ** 4 First page of the overflow chain. Omitted if no overflow
48491: **
48492: ** Overflow pages form a linked list. Each page except the last is completely
48493: ** filled with data (pagesize - 4 bytes). The last page can have as little
48494: ** as 1 byte of data.
48495: **
48496: ** SIZE DESCRIPTION
48497: ** 4 Page number of next overflow page
48498: ** * Data
48499: **
48500: ** Freelist pages come in two subtypes: trunk pages and leaf pages. The
48501: ** file header points to the first in a linked list of trunk page. Each trunk
48502: ** page points to multiple leaf pages. The content of a leaf page is
48503: ** unspecified. A trunk page looks like this:
48504: **
48505: ** SIZE DESCRIPTION
48506: ** 4 Page number of next trunk page
48507: ** 4 Number of leaf pointers on this page
48508: ** * zero or more pages numbers of leaves
48509: */
48510:
48511:
48512: /* The following value is the maximum cell size assuming a maximum page
48513: ** size give above.
48514: */
48515: #define MX_CELL_SIZE(pBt) ((int)(pBt->pageSize-8))
48516:
48517: /* The maximum number of cells on a single page of the database. This
48518: ** assumes a minimum cell size of 6 bytes (4 bytes for the cell itself
48519: ** plus 2 bytes for the index to the cell in the page header). Such
48520: ** small cells will be rare, but they are possible.
48521: */
48522: #define MX_CELL(pBt) ((pBt->pageSize-8)/6)
48523:
48524: /* Forward declarations */
48525: typedef struct MemPage MemPage;
48526: typedef struct BtLock BtLock;
48527:
48528: /*
48529: ** This is a magic string that appears at the beginning of every
48530: ** SQLite database in order to identify the file as a real database.
48531: **
48532: ** You can change this value at compile-time by specifying a
48533: ** -DSQLITE_FILE_HEADER="..." on the compiler command-line. The
48534: ** header must be exactly 16 bytes including the zero-terminator so
48535: ** the string itself should be 15 characters long. If you change
48536: ** the header, then your custom library will not be able to read
48537: ** databases generated by the standard tools and the standard tools
48538: ** will not be able to read databases created by your custom library.
48539: */
48540: #ifndef SQLITE_FILE_HEADER /* 123456789 123456 */
48541: # define SQLITE_FILE_HEADER "SQLite format 3"
48542: #endif
48543:
48544: /*
48545: ** Page type flags. An ORed combination of these flags appear as the
48546: ** first byte of on-disk image of every BTree page.
48547: */
48548: #define PTF_INTKEY 0x01
48549: #define PTF_ZERODATA 0x02
48550: #define PTF_LEAFDATA 0x04
48551: #define PTF_LEAF 0x08
48552:
48553: /*
48554: ** As each page of the file is loaded into memory, an instance of the following
48555: ** structure is appended and initialized to zero. This structure stores
48556: ** information about the page that is decoded from the raw file page.
48557: **
48558: ** The pParent field points back to the parent page. This allows us to
48559: ** walk up the BTree from any leaf to the root. Care must be taken to
48560: ** unref() the parent page pointer when this page is no longer referenced.
48561: ** The pageDestructor() routine handles that chore.
48562: **
48563: ** Access to all fields of this structure is controlled by the mutex
48564: ** stored in MemPage.pBt->mutex.
48565: */
48566: struct MemPage {
48567: u8 isInit; /* True if previously initialized. MUST BE FIRST! */
48568: u8 nOverflow; /* Number of overflow cell bodies in aCell[] */
48569: u8 intKey; /* True if intkey flag is set */
48570: u8 leaf; /* True if leaf flag is set */
48571: u8 hasData; /* True if this page stores data */
48572: u8 hdrOffset; /* 100 for page 1. 0 otherwise */
48573: u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */
48574: u8 max1bytePayload; /* min(maxLocal,127) */
48575: u16 maxLocal; /* Copy of BtShared.maxLocal or BtShared.maxLeaf */
48576: u16 minLocal; /* Copy of BtShared.minLocal or BtShared.minLeaf */
48577: u16 cellOffset; /* Index in aData of first cell pointer */
48578: u16 nFree; /* Number of free bytes on the page */
48579: u16 nCell; /* Number of cells on this page, local and ovfl */
48580: u16 maskPage; /* Mask for page offset */
48581: struct _OvflCell { /* Cells that will not fit on aData[] */
48582: u8 *pCell; /* Pointers to the body of the overflow cell */
48583: u16 idx; /* Insert this cell before idx-th non-overflow cell */
48584: } aOvfl[5];
48585: BtShared *pBt; /* Pointer to BtShared that this page is part of */
48586: u8 *aData; /* Pointer to disk image of the page data */
48587: u8 *aDataEnd; /* One byte past the end of usable data */
48588: u8 *aCellIdx; /* The cell index area */
48589: DbPage *pDbPage; /* Pager page handle */
48590: Pgno pgno; /* Page number for this page */
48591: };
48592:
48593: /*
48594: ** The in-memory image of a disk page has the auxiliary information appended
48595: ** to the end. EXTRA_SIZE is the number of bytes of space needed to hold
48596: ** that extra information.
48597: */
48598: #define EXTRA_SIZE sizeof(MemPage)
48599:
48600: /*
48601: ** A linked list of the following structures is stored at BtShared.pLock.
48602: ** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor
48603: ** is opened on the table with root page BtShared.iTable. Locks are removed
48604: ** from this list when a transaction is committed or rolled back, or when
48605: ** a btree handle is closed.
48606: */
48607: struct BtLock {
48608: Btree *pBtree; /* Btree handle holding this lock */
48609: Pgno iTable; /* Root page of table */
48610: u8 eLock; /* READ_LOCK or WRITE_LOCK */
48611: BtLock *pNext; /* Next in BtShared.pLock list */
48612: };
48613:
48614: /* Candidate values for BtLock.eLock */
48615: #define READ_LOCK 1
48616: #define WRITE_LOCK 2
48617:
48618: /* A Btree handle
48619: **
48620: ** A database connection contains a pointer to an instance of
48621: ** this object for every database file that it has open. This structure
48622: ** is opaque to the database connection. The database connection cannot
48623: ** see the internals of this structure and only deals with pointers to
48624: ** this structure.
48625: **
48626: ** For some database files, the same underlying database cache might be
48627: ** shared between multiple connections. In that case, each connection
48628: ** has it own instance of this object. But each instance of this object
48629: ** points to the same BtShared object. The database cache and the
48630: ** schema associated with the database file are all contained within
48631: ** the BtShared object.
48632: **
48633: ** All fields in this structure are accessed under sqlite3.mutex.
48634: ** The pBt pointer itself may not be changed while there exists cursors
48635: ** in the referenced BtShared that point back to this Btree since those
48636: ** cursors have to go through this Btree to find their BtShared and
48637: ** they often do so without holding sqlite3.mutex.
48638: */
48639: struct Btree {
48640: sqlite3 *db; /* The database connection holding this btree */
48641: BtShared *pBt; /* Sharable content of this btree */
48642: u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */
48643: u8 sharable; /* True if we can share pBt with another db */
48644: u8 locked; /* True if db currently has pBt locked */
48645: int wantToLock; /* Number of nested calls to sqlite3BtreeEnter() */
48646: int nBackup; /* Number of backup operations reading this btree */
48647: Btree *pNext; /* List of other sharable Btrees from the same db */
48648: Btree *pPrev; /* Back pointer of the same list */
48649: #ifndef SQLITE_OMIT_SHARED_CACHE
48650: BtLock lock; /* Object used to lock page 1 */
48651: #endif
48652: };
48653:
48654: /*
48655: ** Btree.inTrans may take one of the following values.
48656: **
48657: ** If the shared-data extension is enabled, there may be multiple users
48658: ** of the Btree structure. At most one of these may open a write transaction,
48659: ** but any number may have active read transactions.
48660: */
48661: #define TRANS_NONE 0
48662: #define TRANS_READ 1
48663: #define TRANS_WRITE 2
48664:
48665: /*
48666: ** An instance of this object represents a single database file.
48667: **
48668: ** A single database file can be in use at the same time by two
48669: ** or more database connections. When two or more connections are
48670: ** sharing the same database file, each connection has it own
48671: ** private Btree object for the file and each of those Btrees points
48672: ** to this one BtShared object. BtShared.nRef is the number of
48673: ** connections currently sharing this database file.
48674: **
48675: ** Fields in this structure are accessed under the BtShared.mutex
48676: ** mutex, except for nRef and pNext which are accessed under the
48677: ** global SQLITE_MUTEX_STATIC_MASTER mutex. The pPager field
48678: ** may not be modified once it is initially set as long as nRef>0.
48679: ** The pSchema field may be set once under BtShared.mutex and
48680: ** thereafter is unchanged as long as nRef>0.
48681: **
48682: ** isPending:
48683: **
48684: ** If a BtShared client fails to obtain a write-lock on a database
48685: ** table (because there exists one or more read-locks on the table),
48686: ** the shared-cache enters 'pending-lock' state and isPending is
48687: ** set to true.
48688: **
48689: ** The shared-cache leaves the 'pending lock' state when either of
48690: ** the following occur:
48691: **
48692: ** 1) The current writer (BtShared.pWriter) concludes its transaction, OR
48693: ** 2) The number of locks held by other connections drops to zero.
48694: **
48695: ** while in the 'pending-lock' state, no connection may start a new
48696: ** transaction.
48697: **
48698: ** This feature is included to help prevent writer-starvation.
48699: */
48700: struct BtShared {
48701: Pager *pPager; /* The page cache */
48702: sqlite3 *db; /* Database connection currently using this Btree */
48703: BtCursor *pCursor; /* A list of all open cursors */
48704: MemPage *pPage1; /* First page of the database */
48705: u8 openFlags; /* Flags to sqlite3BtreeOpen() */
48706: #ifndef SQLITE_OMIT_AUTOVACUUM
48707: u8 autoVacuum; /* True if auto-vacuum is enabled */
48708: u8 incrVacuum; /* True if incr-vacuum is enabled */
48709: #endif
48710: u8 inTransaction; /* Transaction state */
48711: u8 max1bytePayload; /* Maximum first byte of cell for a 1-byte payload */
48712: u16 btsFlags; /* Boolean parameters. See BTS_* macros below */
48713: u16 maxLocal; /* Maximum local payload in non-LEAFDATA tables */
48714: u16 minLocal; /* Minimum local payload in non-LEAFDATA tables */
48715: u16 maxLeaf; /* Maximum local payload in a LEAFDATA table */
48716: u16 minLeaf; /* Minimum local payload in a LEAFDATA table */
48717: u32 pageSize; /* Total number of bytes on a page */
48718: u32 usableSize; /* Number of usable bytes on each page */
48719: int nTransaction; /* Number of open transactions (read + write) */
48720: u32 nPage; /* Number of pages in the database */
48721: void *pSchema; /* Pointer to space allocated by sqlite3BtreeSchema() */
48722: void (*xFreeSchema)(void*); /* Destructor for BtShared.pSchema */
48723: sqlite3_mutex *mutex; /* Non-recursive mutex required to access this object */
48724: Bitvec *pHasContent; /* Set of pages moved to free-list this transaction */
48725: #ifndef SQLITE_OMIT_SHARED_CACHE
48726: int nRef; /* Number of references to this structure */
48727: BtShared *pNext; /* Next on a list of sharable BtShared structs */
48728: BtLock *pLock; /* List of locks held on this shared-btree struct */
48729: Btree *pWriter; /* Btree with currently open write transaction */
48730: #endif
48731: u8 *pTmpSpace; /* BtShared.pageSize bytes of space for tmp use */
48732: };
48733:
48734: /*
48735: ** Allowed values for BtShared.btsFlags
48736: */
48737: #define BTS_READ_ONLY 0x0001 /* Underlying file is readonly */
48738: #define BTS_PAGESIZE_FIXED 0x0002 /* Page size can no longer be changed */
48739: #define BTS_SECURE_DELETE 0x0004 /* PRAGMA secure_delete is enabled */
48740: #define BTS_INITIALLY_EMPTY 0x0008 /* Database was empty at trans start */
48741: #define BTS_NO_WAL 0x0010 /* Do not open write-ahead-log files */
48742: #define BTS_EXCLUSIVE 0x0020 /* pWriter has an exclusive lock */
48743: #define BTS_PENDING 0x0040 /* Waiting for read-locks to clear */
48744:
48745: /*
48746: ** An instance of the following structure is used to hold information
48747: ** about a cell. The parseCellPtr() function fills in this structure
48748: ** based on information extract from the raw disk page.
48749: */
48750: typedef struct CellInfo CellInfo;
48751: struct CellInfo {
48752: i64 nKey; /* The key for INTKEY tables, or number of bytes in key */
48753: u8 *pCell; /* Pointer to the start of cell content */
48754: u32 nData; /* Number of bytes of data */
48755: u32 nPayload; /* Total amount of payload */
48756: u16 nHeader; /* Size of the cell content header in bytes */
48757: u16 nLocal; /* Amount of payload held locally */
48758: u16 iOverflow; /* Offset to overflow page number. Zero if no overflow */
48759: u16 nSize; /* Size of the cell content on the main b-tree page */
48760: };
48761:
48762: /*
48763: ** Maximum depth of an SQLite B-Tree structure. Any B-Tree deeper than
48764: ** this will be declared corrupt. This value is calculated based on a
48765: ** maximum database size of 2^31 pages a minimum fanout of 2 for a
48766: ** root-node and 3 for all other internal nodes.
48767: **
48768: ** If a tree that appears to be taller than this is encountered, it is
48769: ** assumed that the database is corrupt.
48770: */
48771: #define BTCURSOR_MAX_DEPTH 20
48772:
48773: /*
48774: ** A cursor is a pointer to a particular entry within a particular
48775: ** b-tree within a database file.
48776: **
48777: ** The entry is identified by its MemPage and the index in
48778: ** MemPage.aCell[] of the entry.
48779: **
48780: ** A single database file can be shared by two more database connections,
48781: ** but cursors cannot be shared. Each cursor is associated with a
48782: ** particular database connection identified BtCursor.pBtree.db.
48783: **
48784: ** Fields in this structure are accessed under the BtShared.mutex
48785: ** found at self->pBt->mutex.
48786: */
48787: struct BtCursor {
48788: Btree *pBtree; /* The Btree to which this cursor belongs */
48789: BtShared *pBt; /* The BtShared this cursor points to */
48790: BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */
48791: struct KeyInfo *pKeyInfo; /* Argument passed to comparison function */
48792: Pgno pgnoRoot; /* The root page of this tree */
48793: sqlite3_int64 cachedRowid; /* Next rowid cache. 0 means not valid */
48794: CellInfo info; /* A parse of the cell we are pointing at */
48795: i64 nKey; /* Size of pKey, or last integer key */
48796: void *pKey; /* Saved key that was cursor's last known position */
48797: int skipNext; /* Prev() is noop if negative. Next() is noop if positive */
48798: u8 wrFlag; /* True if writable */
48799: u8 atLast; /* Cursor pointing to the last entry */
48800: u8 validNKey; /* True if info.nKey is valid */
48801: u8 eState; /* One of the CURSOR_XXX constants (see below) */
48802: #ifndef SQLITE_OMIT_INCRBLOB
48803: Pgno *aOverflow; /* Cache of overflow page locations */
48804: u8 isIncrblobHandle; /* True if this cursor is an incr. io handle */
48805: #endif
48806: i16 iPage; /* Index of current page in apPage */
48807: u16 aiIdx[BTCURSOR_MAX_DEPTH]; /* Current index in apPage[i] */
48808: MemPage *apPage[BTCURSOR_MAX_DEPTH]; /* Pages from root to current page */
48809: };
48810:
48811: /*
48812: ** Potential values for BtCursor.eState.
48813: **
48814: ** CURSOR_VALID:
48815: ** Cursor points to a valid entry. getPayload() etc. may be called.
48816: **
48817: ** CURSOR_INVALID:
48818: ** Cursor does not point to a valid entry. This can happen (for example)
48819: ** because the table is empty or because BtreeCursorFirst() has not been
48820: ** called.
48821: **
48822: ** CURSOR_REQUIRESEEK:
48823: ** The table that this cursor was opened on still exists, but has been
48824: ** modified since the cursor was last used. The cursor position is saved
48825: ** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
48826: ** this state, restoreCursorPosition() can be called to attempt to
48827: ** seek the cursor to the saved position.
48828: **
48829: ** CURSOR_FAULT:
48830: ** A unrecoverable error (an I/O error or a malloc failure) has occurred
48831: ** on a different connection that shares the BtShared cache with this
48832: ** cursor. The error has left the cache in an inconsistent state.
48833: ** Do nothing else with this cursor. Any attempt to use the cursor
48834: ** should return the error code stored in BtCursor.skip
48835: */
48836: #define CURSOR_INVALID 0
48837: #define CURSOR_VALID 1
48838: #define CURSOR_REQUIRESEEK 2
48839: #define CURSOR_FAULT 3
48840:
48841: /*
48842: ** The database page the PENDING_BYTE occupies. This page is never used.
48843: */
48844: # define PENDING_BYTE_PAGE(pBt) PAGER_MJ_PGNO(pBt)
48845:
48846: /*
48847: ** These macros define the location of the pointer-map entry for a
48848: ** database page. The first argument to each is the number of usable
48849: ** bytes on each page of the database (often 1024). The second is the
48850: ** page number to look up in the pointer map.
48851: **
48852: ** PTRMAP_PAGENO returns the database page number of the pointer-map
48853: ** page that stores the required pointer. PTRMAP_PTROFFSET returns
48854: ** the offset of the requested map entry.
48855: **
48856: ** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
48857: ** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
48858: ** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
48859: ** this test.
48860: */
48861: #define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
48862: #define PTRMAP_PTROFFSET(pgptrmap, pgno) (5*(pgno-pgptrmap-1))
48863: #define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
48864:
48865: /*
48866: ** The pointer map is a lookup table that identifies the parent page for
48867: ** each child page in the database file. The parent page is the page that
48868: ** contains a pointer to the child. Every page in the database contains
48869: ** 0 or 1 parent pages. (In this context 'database page' refers
48870: ** to any page that is not part of the pointer map itself.) Each pointer map
48871: ** entry consists of a single byte 'type' and a 4 byte parent page number.
48872: ** The PTRMAP_XXX identifiers below are the valid types.
48873: **
48874: ** The purpose of the pointer map is to facility moving pages from one
48875: ** position in the file to another as part of autovacuum. When a page
48876: ** is moved, the pointer in its parent must be updated to point to the
48877: ** new location. The pointer map is used to locate the parent page quickly.
48878: **
48879: ** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not
48880: ** used in this case.
48881: **
48882: ** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number
48883: ** is not used in this case.
48884: **
48885: ** PTRMAP_OVERFLOW1: The database page is the first page in a list of
48886: ** overflow pages. The page number identifies the page that
48887: ** contains the cell with a pointer to this overflow page.
48888: **
48889: ** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of
48890: ** overflow pages. The page-number identifies the previous
48891: ** page in the overflow page list.
48892: **
48893: ** PTRMAP_BTREE: The database page is a non-root btree page. The page number
48894: ** identifies the parent page in the btree.
48895: */
48896: #define PTRMAP_ROOTPAGE 1
48897: #define PTRMAP_FREEPAGE 2
48898: #define PTRMAP_OVERFLOW1 3
48899: #define PTRMAP_OVERFLOW2 4
48900: #define PTRMAP_BTREE 5
48901:
48902: /* A bunch of assert() statements to check the transaction state variables
48903: ** of handle p (type Btree*) are internally consistent.
48904: */
48905: #define btreeIntegrity(p) \
48906: assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
48907: assert( p->pBt->inTransaction>=p->inTrans );
48908:
48909:
48910: /*
48911: ** The ISAUTOVACUUM macro is used within balance_nonroot() to determine
48912: ** if the database supports auto-vacuum or not. Because it is used
48913: ** within an expression that is an argument to another macro
48914: ** (sqliteMallocRaw), it is not possible to use conditional compilation.
48915: ** So, this macro is defined instead.
48916: */
48917: #ifndef SQLITE_OMIT_AUTOVACUUM
48918: #define ISAUTOVACUUM (pBt->autoVacuum)
48919: #else
48920: #define ISAUTOVACUUM 0
48921: #endif
48922:
48923:
48924: /*
48925: ** This structure is passed around through all the sanity checking routines
48926: ** in order to keep track of some global state information.
48927: */
48928: typedef struct IntegrityCk IntegrityCk;
48929: struct IntegrityCk {
48930: BtShared *pBt; /* The tree being checked out */
48931: Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
48932: Pgno nPage; /* Number of pages in the database */
48933: int *anRef; /* Number of times each page is referenced */
48934: int mxErr; /* Stop accumulating errors when this reaches zero */
48935: int nErr; /* Number of messages written to zErrMsg so far */
48936: int mallocFailed; /* A memory allocation error has occurred */
48937: StrAccum errMsg; /* Accumulate the error message text here */
48938: };
48939:
48940: /*
48941: ** Routines to read or write a two- and four-byte big-endian integer values.
48942: */
48943: #define get2byte(x) ((x)[0]<<8 | (x)[1])
48944: #define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))
48945: #define get4byte sqlite3Get4byte
48946: #define put4byte sqlite3Put4byte
48947:
48948: /************** End of btreeInt.h ********************************************/
48949: /************** Continuing where we left off in btmutex.c ********************/
48950: #ifndef SQLITE_OMIT_SHARED_CACHE
48951: #if SQLITE_THREADSAFE
48952:
48953: /*
48954: ** Obtain the BtShared mutex associated with B-Tree handle p. Also,
48955: ** set BtShared.db to the database handle associated with p and the
48956: ** p->locked boolean to true.
48957: */
48958: static void lockBtreeMutex(Btree *p){
48959: assert( p->locked==0 );
48960: assert( sqlite3_mutex_notheld(p->pBt->mutex) );
48961: assert( sqlite3_mutex_held(p->db->mutex) );
48962:
48963: sqlite3_mutex_enter(p->pBt->mutex);
48964: p->pBt->db = p->db;
48965: p->locked = 1;
48966: }
48967:
48968: /*
48969: ** Release the BtShared mutex associated with B-Tree handle p and
48970: ** clear the p->locked boolean.
48971: */
48972: static void unlockBtreeMutex(Btree *p){
48973: BtShared *pBt = p->pBt;
48974: assert( p->locked==1 );
48975: assert( sqlite3_mutex_held(pBt->mutex) );
48976: assert( sqlite3_mutex_held(p->db->mutex) );
48977: assert( p->db==pBt->db );
48978:
48979: sqlite3_mutex_leave(pBt->mutex);
48980: p->locked = 0;
48981: }
48982:
48983: /*
48984: ** Enter a mutex on the given BTree object.
48985: **
48986: ** If the object is not sharable, then no mutex is ever required
48987: ** and this routine is a no-op. The underlying mutex is non-recursive.
48988: ** But we keep a reference count in Btree.wantToLock so the behavior
48989: ** of this interface is recursive.
48990: **
48991: ** To avoid deadlocks, multiple Btrees are locked in the same order
48992: ** by all database connections. The p->pNext is a list of other
48993: ** Btrees belonging to the same database connection as the p Btree
48994: ** which need to be locked after p. If we cannot get a lock on
48995: ** p, then first unlock all of the others on p->pNext, then wait
48996: ** for the lock to become available on p, then relock all of the
48997: ** subsequent Btrees that desire a lock.
48998: */
48999: SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
49000: Btree *pLater;
49001:
49002: /* Some basic sanity checking on the Btree. The list of Btrees
49003: ** connected by pNext and pPrev should be in sorted order by
49004: ** Btree.pBt value. All elements of the list should belong to
49005: ** the same connection. Only shared Btrees are on the list. */
49006: assert( p->pNext==0 || p->pNext->pBt>p->pBt );
49007: assert( p->pPrev==0 || p->pPrev->pBt<p->pBt );
49008: assert( p->pNext==0 || p->pNext->db==p->db );
49009: assert( p->pPrev==0 || p->pPrev->db==p->db );
49010: assert( p->sharable || (p->pNext==0 && p->pPrev==0) );
49011:
49012: /* Check for locking consistency */
49013: assert( !p->locked || p->wantToLock>0 );
49014: assert( p->sharable || p->wantToLock==0 );
49015:
49016: /* We should already hold a lock on the database connection */
49017: assert( sqlite3_mutex_held(p->db->mutex) );
49018:
49019: /* Unless the database is sharable and unlocked, then BtShared.db
49020: ** should already be set correctly. */
49021: assert( (p->locked==0 && p->sharable) || p->pBt->db==p->db );
49022:
49023: if( !p->sharable ) return;
49024: p->wantToLock++;
49025: if( p->locked ) return;
49026:
49027: /* In most cases, we should be able to acquire the lock we
49028: ** want without having to go throught the ascending lock
49029: ** procedure that follows. Just be sure not to block.
49030: */
49031: if( sqlite3_mutex_try(p->pBt->mutex)==SQLITE_OK ){
49032: p->pBt->db = p->db;
49033: p->locked = 1;
49034: return;
49035: }
49036:
49037: /* To avoid deadlock, first release all locks with a larger
49038: ** BtShared address. Then acquire our lock. Then reacquire
49039: ** the other BtShared locks that we used to hold in ascending
49040: ** order.
49041: */
49042: for(pLater=p->pNext; pLater; pLater=pLater->pNext){
49043: assert( pLater->sharable );
49044: assert( pLater->pNext==0 || pLater->pNext->pBt>pLater->pBt );
49045: assert( !pLater->locked || pLater->wantToLock>0 );
49046: if( pLater->locked ){
49047: unlockBtreeMutex(pLater);
49048: }
49049: }
49050: lockBtreeMutex(p);
49051: for(pLater=p->pNext; pLater; pLater=pLater->pNext){
49052: if( pLater->wantToLock ){
49053: lockBtreeMutex(pLater);
49054: }
49055: }
49056: }
49057:
49058: /*
49059: ** Exit the recursive mutex on a Btree.
49060: */
49061: SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){
49062: if( p->sharable ){
49063: assert( p->wantToLock>0 );
49064: p->wantToLock--;
49065: if( p->wantToLock==0 ){
49066: unlockBtreeMutex(p);
49067: }
49068: }
49069: }
49070:
49071: #ifndef NDEBUG
49072: /*
49073: ** Return true if the BtShared mutex is held on the btree, or if the
49074: ** B-Tree is not marked as sharable.
49075: **
49076: ** This routine is used only from within assert() statements.
49077: */
49078: SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree *p){
49079: assert( p->sharable==0 || p->locked==0 || p->wantToLock>0 );
49080: assert( p->sharable==0 || p->locked==0 || p->db==p->pBt->db );
49081: assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->pBt->mutex) );
49082: assert( p->sharable==0 || p->locked==0 || sqlite3_mutex_held(p->db->mutex) );
49083:
49084: return (p->sharable==0 || p->locked);
49085: }
49086: #endif
49087:
49088:
49089: #ifndef SQLITE_OMIT_INCRBLOB
49090: /*
49091: ** Enter and leave a mutex on a Btree given a cursor owned by that
49092: ** Btree. These entry points are used by incremental I/O and can be
49093: ** omitted if that module is not used.
49094: */
49095: SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
49096: sqlite3BtreeEnter(pCur->pBtree);
49097: }
49098: SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
49099: sqlite3BtreeLeave(pCur->pBtree);
49100: }
49101: #endif /* SQLITE_OMIT_INCRBLOB */
49102:
49103:
49104: /*
49105: ** Enter the mutex on every Btree associated with a database
49106: ** connection. This is needed (for example) prior to parsing
49107: ** a statement since we will be comparing table and column names
49108: ** against all schemas and we do not want those schemas being
49109: ** reset out from under us.
49110: **
49111: ** There is a corresponding leave-all procedures.
49112: **
49113: ** Enter the mutexes in accending order by BtShared pointer address
49114: ** to avoid the possibility of deadlock when two threads with
49115: ** two or more btrees in common both try to lock all their btrees
49116: ** at the same instant.
49117: */
49118: SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
49119: int i;
49120: Btree *p;
49121: assert( sqlite3_mutex_held(db->mutex) );
49122: for(i=0; i<db->nDb; i++){
49123: p = db->aDb[i].pBt;
49124: if( p ) sqlite3BtreeEnter(p);
49125: }
49126: }
49127: SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){
49128: int i;
49129: Btree *p;
49130: assert( sqlite3_mutex_held(db->mutex) );
49131: for(i=0; i<db->nDb; i++){
49132: p = db->aDb[i].pBt;
49133: if( p ) sqlite3BtreeLeave(p);
49134: }
49135: }
49136:
49137: /*
49138: ** Return true if a particular Btree requires a lock. Return FALSE if
49139: ** no lock is ever required since it is not sharable.
49140: */
49141: SQLITE_PRIVATE int sqlite3BtreeSharable(Btree *p){
49142: return p->sharable;
49143: }
49144:
49145: #ifndef NDEBUG
49146: /*
49147: ** Return true if the current thread holds the database connection
49148: ** mutex and all required BtShared mutexes.
49149: **
49150: ** This routine is used inside assert() statements only.
49151: */
49152: SQLITE_PRIVATE int sqlite3BtreeHoldsAllMutexes(sqlite3 *db){
49153: int i;
49154: if( !sqlite3_mutex_held(db->mutex) ){
49155: return 0;
49156: }
49157: for(i=0; i<db->nDb; i++){
49158: Btree *p;
49159: p = db->aDb[i].pBt;
49160: if( p && p->sharable &&
49161: (p->wantToLock==0 || !sqlite3_mutex_held(p->pBt->mutex)) ){
49162: return 0;
49163: }
49164: }
49165: return 1;
49166: }
49167: #endif /* NDEBUG */
49168:
49169: #ifndef NDEBUG
49170: /*
49171: ** Return true if the correct mutexes are held for accessing the
49172: ** db->aDb[iDb].pSchema structure. The mutexes required for schema
49173: ** access are:
49174: **
49175: ** (1) The mutex on db
49176: ** (2) if iDb!=1, then the mutex on db->aDb[iDb].pBt.
49177: **
49178: ** If pSchema is not NULL, then iDb is computed from pSchema and
49179: ** db using sqlite3SchemaToIndex().
49180: */
49181: SQLITE_PRIVATE int sqlite3SchemaMutexHeld(sqlite3 *db, int iDb, Schema *pSchema){
49182: Btree *p;
49183: assert( db!=0 );
49184: if( pSchema ) iDb = sqlite3SchemaToIndex(db, pSchema);
49185: assert( iDb>=0 && iDb<db->nDb );
49186: if( !sqlite3_mutex_held(db->mutex) ) return 0;
49187: if( iDb==1 ) return 1;
49188: p = db->aDb[iDb].pBt;
49189: assert( p!=0 );
49190: return p->sharable==0 || p->locked==1;
49191: }
49192: #endif /* NDEBUG */
49193:
49194: #else /* SQLITE_THREADSAFE>0 above. SQLITE_THREADSAFE==0 below */
49195: /*
49196: ** The following are special cases for mutex enter routines for use
49197: ** in single threaded applications that use shared cache. Except for
49198: ** these two routines, all mutex operations are no-ops in that case and
49199: ** are null #defines in btree.h.
49200: **
49201: ** If shared cache is disabled, then all btree mutex routines, including
49202: ** the ones below, are no-ops and are null #defines in btree.h.
49203: */
49204:
49205: SQLITE_PRIVATE void sqlite3BtreeEnter(Btree *p){
49206: p->pBt->db = p->db;
49207: }
49208: SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
49209: int i;
49210: for(i=0; i<db->nDb; i++){
49211: Btree *p = db->aDb[i].pBt;
49212: if( p ){
49213: p->pBt->db = p->db;
49214: }
49215: }
49216: }
49217: #endif /* if SQLITE_THREADSAFE */
49218: #endif /* ifndef SQLITE_OMIT_SHARED_CACHE */
49219:
49220: /************** End of btmutex.c *********************************************/
49221: /************** Begin file btree.c *******************************************/
49222: /*
49223: ** 2004 April 6
49224: **
49225: ** The author disclaims copyright to this source code. In place of
49226: ** a legal notice, here is a blessing:
49227: **
49228: ** May you do good and not evil.
49229: ** May you find forgiveness for yourself and forgive others.
49230: ** May you share freely, never taking more than you give.
49231: **
49232: *************************************************************************
49233: ** This file implements a external (disk-based) database using BTrees.
49234: ** See the header comment on "btreeInt.h" for additional information.
49235: ** Including a description of file format and an overview of operation.
49236: */
49237:
49238: /*
49239: ** The header string that appears at the beginning of every
49240: ** SQLite database.
49241: */
49242: static const char zMagicHeader[] = SQLITE_FILE_HEADER;
49243:
49244: /*
49245: ** Set this global variable to 1 to enable tracing using the TRACE
49246: ** macro.
49247: */
49248: #if 0
49249: int sqlite3BtreeTrace=1; /* True to enable tracing */
49250: # define TRACE(X) if(sqlite3BtreeTrace){printf X;fflush(stdout);}
49251: #else
49252: # define TRACE(X)
49253: #endif
49254:
49255: /*
49256: ** Extract a 2-byte big-endian integer from an array of unsigned bytes.
49257: ** But if the value is zero, make it 65536.
49258: **
49259: ** This routine is used to extract the "offset to cell content area" value
49260: ** from the header of a btree page. If the page size is 65536 and the page
49261: ** is empty, the offset should be 65536, but the 2-byte value stores zero.
49262: ** This routine makes the necessary adjustment to 65536.
49263: */
49264: #define get2byteNotZero(X) (((((int)get2byte(X))-1)&0xffff)+1)
49265:
49266: #ifndef SQLITE_OMIT_SHARED_CACHE
49267: /*
49268: ** A list of BtShared objects that are eligible for participation
49269: ** in shared cache. This variable has file scope during normal builds,
49270: ** but the test harness needs to access it so we make it global for
49271: ** test builds.
49272: **
49273: ** Access to this variable is protected by SQLITE_MUTEX_STATIC_MASTER.
49274: */
49275: #ifdef SQLITE_TEST
49276: SQLITE_PRIVATE BtShared *SQLITE_WSD sqlite3SharedCacheList = 0;
49277: #else
49278: static BtShared *SQLITE_WSD sqlite3SharedCacheList = 0;
49279: #endif
49280: #endif /* SQLITE_OMIT_SHARED_CACHE */
49281:
49282: #ifndef SQLITE_OMIT_SHARED_CACHE
49283: /*
49284: ** Enable or disable the shared pager and schema features.
49285: **
49286: ** This routine has no effect on existing database connections.
49287: ** The shared cache setting effects only future calls to
49288: ** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2().
49289: */
49290: SQLITE_API int sqlite3_enable_shared_cache(int enable){
49291: sqlite3GlobalConfig.sharedCacheEnabled = enable;
49292: return SQLITE_OK;
49293: }
49294: #endif
49295:
49296:
49297:
49298: #ifdef SQLITE_OMIT_SHARED_CACHE
49299: /*
49300: ** The functions querySharedCacheTableLock(), setSharedCacheTableLock(),
49301: ** and clearAllSharedCacheTableLocks()
49302: ** manipulate entries in the BtShared.pLock linked list used to store
49303: ** shared-cache table level locks. If the library is compiled with the
49304: ** shared-cache feature disabled, then there is only ever one user
49305: ** of each BtShared structure and so this locking is not necessary.
49306: ** So define the lock related functions as no-ops.
49307: */
49308: #define querySharedCacheTableLock(a,b,c) SQLITE_OK
49309: #define setSharedCacheTableLock(a,b,c) SQLITE_OK
49310: #define clearAllSharedCacheTableLocks(a)
49311: #define downgradeAllSharedCacheTableLocks(a)
49312: #define hasSharedCacheTableLock(a,b,c,d) 1
49313: #define hasReadConflicts(a, b) 0
49314: #endif
49315:
49316: #ifndef SQLITE_OMIT_SHARED_CACHE
49317:
49318: #ifdef SQLITE_DEBUG
49319: /*
49320: **** This function is only used as part of an assert() statement. ***
49321: **
49322: ** Check to see if pBtree holds the required locks to read or write to the
49323: ** table with root page iRoot. Return 1 if it does and 0 if not.
49324: **
49325: ** For example, when writing to a table with root-page iRoot via
49326: ** Btree connection pBtree:
49327: **
49328: ** assert( hasSharedCacheTableLock(pBtree, iRoot, 0, WRITE_LOCK) );
49329: **
49330: ** When writing to an index that resides in a sharable database, the
49331: ** caller should have first obtained a lock specifying the root page of
49332: ** the corresponding table. This makes things a bit more complicated,
49333: ** as this module treats each table as a separate structure. To determine
49334: ** the table corresponding to the index being written, this
49335: ** function has to search through the database schema.
49336: **
49337: ** Instead of a lock on the table/index rooted at page iRoot, the caller may
49338: ** hold a write-lock on the schema table (root page 1). This is also
49339: ** acceptable.
49340: */
49341: static int hasSharedCacheTableLock(
49342: Btree *pBtree, /* Handle that must hold lock */
49343: Pgno iRoot, /* Root page of b-tree */
49344: int isIndex, /* True if iRoot is the root of an index b-tree */
49345: int eLockType /* Required lock type (READ_LOCK or WRITE_LOCK) */
49346: ){
49347: Schema *pSchema = (Schema *)pBtree->pBt->pSchema;
49348: Pgno iTab = 0;
49349: BtLock *pLock;
49350:
49351: /* If this database is not shareable, or if the client is reading
49352: ** and has the read-uncommitted flag set, then no lock is required.
49353: ** Return true immediately.
49354: */
49355: if( (pBtree->sharable==0)
49356: || (eLockType==READ_LOCK && (pBtree->db->flags & SQLITE_ReadUncommitted))
49357: ){
49358: return 1;
49359: }
49360:
49361: /* If the client is reading or writing an index and the schema is
49362: ** not loaded, then it is too difficult to actually check to see if
49363: ** the correct locks are held. So do not bother - just return true.
49364: ** This case does not come up very often anyhow.
49365: */
49366: if( isIndex && (!pSchema || (pSchema->flags&DB_SchemaLoaded)==0) ){
49367: return 1;
49368: }
49369:
49370: /* Figure out the root-page that the lock should be held on. For table
49371: ** b-trees, this is just the root page of the b-tree being read or
49372: ** written. For index b-trees, it is the root page of the associated
49373: ** table. */
49374: if( isIndex ){
49375: HashElem *p;
49376: for(p=sqliteHashFirst(&pSchema->idxHash); p; p=sqliteHashNext(p)){
49377: Index *pIdx = (Index *)sqliteHashData(p);
49378: if( pIdx->tnum==(int)iRoot ){
49379: iTab = pIdx->pTable->tnum;
49380: }
49381: }
49382: }else{
49383: iTab = iRoot;
49384: }
49385:
49386: /* Search for the required lock. Either a write-lock on root-page iTab, a
49387: ** write-lock on the schema table, or (if the client is reading) a
49388: ** read-lock on iTab will suffice. Return 1 if any of these are found. */
49389: for(pLock=pBtree->pBt->pLock; pLock; pLock=pLock->pNext){
49390: if( pLock->pBtree==pBtree
49391: && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1))
49392: && pLock->eLock>=eLockType
49393: ){
49394: return 1;
49395: }
49396: }
49397:
49398: /* Failed to find the required lock. */
49399: return 0;
49400: }
49401: #endif /* SQLITE_DEBUG */
49402:
49403: #ifdef SQLITE_DEBUG
49404: /*
49405: **** This function may be used as part of assert() statements only. ****
49406: **
49407: ** Return true if it would be illegal for pBtree to write into the
49408: ** table or index rooted at iRoot because other shared connections are
49409: ** simultaneously reading that same table or index.
49410: **
49411: ** It is illegal for pBtree to write if some other Btree object that
49412: ** shares the same BtShared object is currently reading or writing
49413: ** the iRoot table. Except, if the other Btree object has the
49414: ** read-uncommitted flag set, then it is OK for the other object to
49415: ** have a read cursor.
49416: **
49417: ** For example, before writing to any part of the table or index
49418: ** rooted at page iRoot, one should call:
49419: **
49420: ** assert( !hasReadConflicts(pBtree, iRoot) );
49421: */
49422: static int hasReadConflicts(Btree *pBtree, Pgno iRoot){
49423: BtCursor *p;
49424: for(p=pBtree->pBt->pCursor; p; p=p->pNext){
49425: if( p->pgnoRoot==iRoot
49426: && p->pBtree!=pBtree
49427: && 0==(p->pBtree->db->flags & SQLITE_ReadUncommitted)
49428: ){
49429: return 1;
49430: }
49431: }
49432: return 0;
49433: }
49434: #endif /* #ifdef SQLITE_DEBUG */
49435:
49436: /*
49437: ** Query to see if Btree handle p may obtain a lock of type eLock
49438: ** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return
49439: ** SQLITE_OK if the lock may be obtained (by calling
49440: ** setSharedCacheTableLock()), or SQLITE_LOCKED if not.
49441: */
49442: static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
49443: BtShared *pBt = p->pBt;
49444: BtLock *pIter;
49445:
49446: assert( sqlite3BtreeHoldsMutex(p) );
49447: assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
49448: assert( p->db!=0 );
49449: assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 );
49450:
49451: /* If requesting a write-lock, then the Btree must have an open write
49452: ** transaction on this file. And, obviously, for this to be so there
49453: ** must be an open write transaction on the file itself.
49454: */
49455: assert( eLock==READ_LOCK || (p==pBt->pWriter && p->inTrans==TRANS_WRITE) );
49456: assert( eLock==READ_LOCK || pBt->inTransaction==TRANS_WRITE );
49457:
49458: /* This routine is a no-op if the shared-cache is not enabled */
49459: if( !p->sharable ){
49460: return SQLITE_OK;
49461: }
49462:
49463: /* If some other connection is holding an exclusive lock, the
49464: ** requested lock may not be obtained.
49465: */
49466: if( pBt->pWriter!=p && (pBt->btsFlags & BTS_EXCLUSIVE)!=0 ){
49467: sqlite3ConnectionBlocked(p->db, pBt->pWriter->db);
49468: return SQLITE_LOCKED_SHAREDCACHE;
49469: }
49470:
49471: for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
49472: /* The condition (pIter->eLock!=eLock) in the following if(...)
49473: ** statement is a simplification of:
49474: **
49475: ** (eLock==WRITE_LOCK || pIter->eLock==WRITE_LOCK)
49476: **
49477: ** since we know that if eLock==WRITE_LOCK, then no other connection
49478: ** may hold a WRITE_LOCK on any table in this file (since there can
49479: ** only be a single writer).
49480: */
49481: assert( pIter->eLock==READ_LOCK || pIter->eLock==WRITE_LOCK );
49482: assert( eLock==READ_LOCK || pIter->pBtree==p || pIter->eLock==READ_LOCK);
49483: if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
49484: sqlite3ConnectionBlocked(p->db, pIter->pBtree->db);
49485: if( eLock==WRITE_LOCK ){
49486: assert( p==pBt->pWriter );
49487: pBt->btsFlags |= BTS_PENDING;
49488: }
49489: return SQLITE_LOCKED_SHAREDCACHE;
49490: }
49491: }
49492: return SQLITE_OK;
49493: }
49494: #endif /* !SQLITE_OMIT_SHARED_CACHE */
49495:
49496: #ifndef SQLITE_OMIT_SHARED_CACHE
49497: /*
49498: ** Add a lock on the table with root-page iTable to the shared-btree used
49499: ** by Btree handle p. Parameter eLock must be either READ_LOCK or
49500: ** WRITE_LOCK.
49501: **
49502: ** This function assumes the following:
49503: **
49504: ** (a) The specified Btree object p is connected to a sharable
49505: ** database (one with the BtShared.sharable flag set), and
49506: **
49507: ** (b) No other Btree objects hold a lock that conflicts
49508: ** with the requested lock (i.e. querySharedCacheTableLock() has
49509: ** already been called and returned SQLITE_OK).
49510: **
49511: ** SQLITE_OK is returned if the lock is added successfully. SQLITE_NOMEM
49512: ** is returned if a malloc attempt fails.
49513: */
49514: static int setSharedCacheTableLock(Btree *p, Pgno iTable, u8 eLock){
49515: BtShared *pBt = p->pBt;
49516: BtLock *pLock = 0;
49517: BtLock *pIter;
49518:
49519: assert( sqlite3BtreeHoldsMutex(p) );
49520: assert( eLock==READ_LOCK || eLock==WRITE_LOCK );
49521: assert( p->db!=0 );
49522:
49523: /* A connection with the read-uncommitted flag set will never try to
49524: ** obtain a read-lock using this function. The only read-lock obtained
49525: ** by a connection in read-uncommitted mode is on the sqlite_master
49526: ** table, and that lock is obtained in BtreeBeginTrans(). */
49527: assert( 0==(p->db->flags&SQLITE_ReadUncommitted) || eLock==WRITE_LOCK );
49528:
49529: /* This function should only be called on a sharable b-tree after it
49530: ** has been determined that no other b-tree holds a conflicting lock. */
49531: assert( p->sharable );
49532: assert( SQLITE_OK==querySharedCacheTableLock(p, iTable, eLock) );
49533:
49534: /* First search the list for an existing lock on this table. */
49535: for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
49536: if( pIter->iTable==iTable && pIter->pBtree==p ){
49537: pLock = pIter;
49538: break;
49539: }
49540: }
49541:
49542: /* If the above search did not find a BtLock struct associating Btree p
49543: ** with table iTable, allocate one and link it into the list.
49544: */
49545: if( !pLock ){
49546: pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock));
49547: if( !pLock ){
49548: return SQLITE_NOMEM;
49549: }
49550: pLock->iTable = iTable;
49551: pLock->pBtree = p;
49552: pLock->pNext = pBt->pLock;
49553: pBt->pLock = pLock;
49554: }
49555:
49556: /* Set the BtLock.eLock variable to the maximum of the current lock
49557: ** and the requested lock. This means if a write-lock was already held
49558: ** and a read-lock requested, we don't incorrectly downgrade the lock.
49559: */
49560: assert( WRITE_LOCK>READ_LOCK );
49561: if( eLock>pLock->eLock ){
49562: pLock->eLock = eLock;
49563: }
49564:
49565: return SQLITE_OK;
49566: }
49567: #endif /* !SQLITE_OMIT_SHARED_CACHE */
49568:
49569: #ifndef SQLITE_OMIT_SHARED_CACHE
49570: /*
49571: ** Release all the table locks (locks obtained via calls to
49572: ** the setSharedCacheTableLock() procedure) held by Btree object p.
49573: **
49574: ** This function assumes that Btree p has an open read or write
49575: ** transaction. If it does not, then the BTS_PENDING flag
49576: ** may be incorrectly cleared.
49577: */
49578: static void clearAllSharedCacheTableLocks(Btree *p){
49579: BtShared *pBt = p->pBt;
49580: BtLock **ppIter = &pBt->pLock;
49581:
49582: assert( sqlite3BtreeHoldsMutex(p) );
49583: assert( p->sharable || 0==*ppIter );
49584: assert( p->inTrans>0 );
49585:
49586: while( *ppIter ){
49587: BtLock *pLock = *ppIter;
49588: assert( (pBt->btsFlags & BTS_EXCLUSIVE)==0 || pBt->pWriter==pLock->pBtree );
49589: assert( pLock->pBtree->inTrans>=pLock->eLock );
49590: if( pLock->pBtree==p ){
49591: *ppIter = pLock->pNext;
49592: assert( pLock->iTable!=1 || pLock==&p->lock );
49593: if( pLock->iTable!=1 ){
49594: sqlite3_free(pLock);
49595: }
49596: }else{
49597: ppIter = &pLock->pNext;
49598: }
49599: }
49600:
49601: assert( (pBt->btsFlags & BTS_PENDING)==0 || pBt->pWriter );
49602: if( pBt->pWriter==p ){
49603: pBt->pWriter = 0;
49604: pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
49605: }else if( pBt->nTransaction==2 ){
49606: /* This function is called when Btree p is concluding its
49607: ** transaction. If there currently exists a writer, and p is not
49608: ** that writer, then the number of locks held by connections other
49609: ** than the writer must be about to drop to zero. In this case
49610: ** set the BTS_PENDING flag to 0.
49611: **
49612: ** If there is not currently a writer, then BTS_PENDING must
49613: ** be zero already. So this next line is harmless in that case.
49614: */
49615: pBt->btsFlags &= ~BTS_PENDING;
49616: }
49617: }
49618:
49619: /*
49620: ** This function changes all write-locks held by Btree p into read-locks.
49621: */
49622: static void downgradeAllSharedCacheTableLocks(Btree *p){
49623: BtShared *pBt = p->pBt;
49624: if( pBt->pWriter==p ){
49625: BtLock *pLock;
49626: pBt->pWriter = 0;
49627: pBt->btsFlags &= ~(BTS_EXCLUSIVE|BTS_PENDING);
49628: for(pLock=pBt->pLock; pLock; pLock=pLock->pNext){
49629: assert( pLock->eLock==READ_LOCK || pLock->pBtree==p );
49630: pLock->eLock = READ_LOCK;
49631: }
49632: }
49633: }
49634:
49635: #endif /* SQLITE_OMIT_SHARED_CACHE */
49636:
49637: static void releasePage(MemPage *pPage); /* Forward reference */
49638:
49639: /*
49640: ***** This routine is used inside of assert() only ****
49641: **
49642: ** Verify that the cursor holds the mutex on its BtShared
49643: */
49644: #ifdef SQLITE_DEBUG
49645: static int cursorHoldsMutex(BtCursor *p){
49646: return sqlite3_mutex_held(p->pBt->mutex);
49647: }
49648: #endif
49649:
49650:
49651: #ifndef SQLITE_OMIT_INCRBLOB
49652: /*
49653: ** Invalidate the overflow page-list cache for cursor pCur, if any.
49654: */
49655: static void invalidateOverflowCache(BtCursor *pCur){
49656: assert( cursorHoldsMutex(pCur) );
49657: sqlite3_free(pCur->aOverflow);
49658: pCur->aOverflow = 0;
49659: }
49660:
49661: /*
49662: ** Invalidate the overflow page-list cache for all cursors opened
49663: ** on the shared btree structure pBt.
49664: */
49665: static void invalidateAllOverflowCache(BtShared *pBt){
49666: BtCursor *p;
49667: assert( sqlite3_mutex_held(pBt->mutex) );
49668: for(p=pBt->pCursor; p; p=p->pNext){
49669: invalidateOverflowCache(p);
49670: }
49671: }
49672:
49673: /*
49674: ** This function is called before modifying the contents of a table
49675: ** to invalidate any incrblob cursors that are open on the
49676: ** row or one of the rows being modified.
49677: **
49678: ** If argument isClearTable is true, then the entire contents of the
49679: ** table is about to be deleted. In this case invalidate all incrblob
49680: ** cursors open on any row within the table with root-page pgnoRoot.
49681: **
49682: ** Otherwise, if argument isClearTable is false, then the row with
49683: ** rowid iRow is being replaced or deleted. In this case invalidate
49684: ** only those incrblob cursors open on that specific row.
49685: */
49686: static void invalidateIncrblobCursors(
49687: Btree *pBtree, /* The database file to check */
49688: i64 iRow, /* The rowid that might be changing */
49689: int isClearTable /* True if all rows are being deleted */
49690: ){
49691: BtCursor *p;
49692: BtShared *pBt = pBtree->pBt;
49693: assert( sqlite3BtreeHoldsMutex(pBtree) );
49694: for(p=pBt->pCursor; p; p=p->pNext){
49695: if( p->isIncrblobHandle && (isClearTable || p->info.nKey==iRow) ){
49696: p->eState = CURSOR_INVALID;
49697: }
49698: }
49699: }
49700:
49701: #else
49702: /* Stub functions when INCRBLOB is omitted */
49703: #define invalidateOverflowCache(x)
49704: #define invalidateAllOverflowCache(x)
49705: #define invalidateIncrblobCursors(x,y,z)
49706: #endif /* SQLITE_OMIT_INCRBLOB */
49707:
49708: /*
49709: ** Set bit pgno of the BtShared.pHasContent bitvec. This is called
49710: ** when a page that previously contained data becomes a free-list leaf
49711: ** page.
49712: **
49713: ** The BtShared.pHasContent bitvec exists to work around an obscure
49714: ** bug caused by the interaction of two useful IO optimizations surrounding
49715: ** free-list leaf pages:
49716: **
49717: ** 1) When all data is deleted from a page and the page becomes
49718: ** a free-list leaf page, the page is not written to the database
49719: ** (as free-list leaf pages contain no meaningful data). Sometimes
49720: ** such a page is not even journalled (as it will not be modified,
49721: ** why bother journalling it?).
49722: **
49723: ** 2) When a free-list leaf page is reused, its content is not read
49724: ** from the database or written to the journal file (why should it
49725: ** be, if it is not at all meaningful?).
49726: **
49727: ** By themselves, these optimizations work fine and provide a handy
49728: ** performance boost to bulk delete or insert operations. However, if
49729: ** a page is moved to the free-list and then reused within the same
49730: ** transaction, a problem comes up. If the page is not journalled when
49731: ** it is moved to the free-list and it is also not journalled when it
49732: ** is extracted from the free-list and reused, then the original data
49733: ** may be lost. In the event of a rollback, it may not be possible
49734: ** to restore the database to its original configuration.
49735: **
49736: ** The solution is the BtShared.pHasContent bitvec. Whenever a page is
49737: ** moved to become a free-list leaf page, the corresponding bit is
49738: ** set in the bitvec. Whenever a leaf page is extracted from the free-list,
49739: ** optimization 2 above is omitted if the corresponding bit is already
49740: ** set in BtShared.pHasContent. The contents of the bitvec are cleared
49741: ** at the end of every transaction.
49742: */
49743: static int btreeSetHasContent(BtShared *pBt, Pgno pgno){
49744: int rc = SQLITE_OK;
49745: if( !pBt->pHasContent ){
49746: assert( pgno<=pBt->nPage );
49747: pBt->pHasContent = sqlite3BitvecCreate(pBt->nPage);
49748: if( !pBt->pHasContent ){
49749: rc = SQLITE_NOMEM;
49750: }
49751: }
49752: if( rc==SQLITE_OK && pgno<=sqlite3BitvecSize(pBt->pHasContent) ){
49753: rc = sqlite3BitvecSet(pBt->pHasContent, pgno);
49754: }
49755: return rc;
49756: }
49757:
49758: /*
49759: ** Query the BtShared.pHasContent vector.
49760: **
49761: ** This function is called when a free-list leaf page is removed from the
49762: ** free-list for reuse. It returns false if it is safe to retrieve the
49763: ** page from the pager layer with the 'no-content' flag set. True otherwise.
49764: */
49765: static int btreeGetHasContent(BtShared *pBt, Pgno pgno){
49766: Bitvec *p = pBt->pHasContent;
49767: return (p && (pgno>sqlite3BitvecSize(p) || sqlite3BitvecTest(p, pgno)));
49768: }
49769:
49770: /*
49771: ** Clear (destroy) the BtShared.pHasContent bitvec. This should be
49772: ** invoked at the conclusion of each write-transaction.
49773: */
49774: static void btreeClearHasContent(BtShared *pBt){
49775: sqlite3BitvecDestroy(pBt->pHasContent);
49776: pBt->pHasContent = 0;
49777: }
49778:
49779: /*
49780: ** Save the current cursor position in the variables BtCursor.nKey
49781: ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
49782: **
49783: ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
49784: ** prior to calling this routine.
49785: */
49786: static int saveCursorPosition(BtCursor *pCur){
49787: int rc;
49788:
49789: assert( CURSOR_VALID==pCur->eState );
49790: assert( 0==pCur->pKey );
49791: assert( cursorHoldsMutex(pCur) );
49792:
49793: rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
49794: assert( rc==SQLITE_OK ); /* KeySize() cannot fail */
49795:
49796: /* If this is an intKey table, then the above call to BtreeKeySize()
49797: ** stores the integer key in pCur->nKey. In this case this value is
49798: ** all that is required. Otherwise, if pCur is not open on an intKey
49799: ** table, then malloc space for and store the pCur->nKey bytes of key
49800: ** data.
49801: */
49802: if( 0==pCur->apPage[0]->intKey ){
49803: void *pKey = sqlite3Malloc( (int)pCur->nKey );
49804: if( pKey ){
49805: rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
49806: if( rc==SQLITE_OK ){
49807: pCur->pKey = pKey;
49808: }else{
49809: sqlite3_free(pKey);
49810: }
49811: }else{
49812: rc = SQLITE_NOMEM;
49813: }
49814: }
49815: assert( !pCur->apPage[0]->intKey || !pCur->pKey );
49816:
49817: if( rc==SQLITE_OK ){
49818: int i;
49819: for(i=0; i<=pCur->iPage; i++){
49820: releasePage(pCur->apPage[i]);
49821: pCur->apPage[i] = 0;
49822: }
49823: pCur->iPage = -1;
49824: pCur->eState = CURSOR_REQUIRESEEK;
49825: }
49826:
49827: invalidateOverflowCache(pCur);
49828: return rc;
49829: }
49830:
49831: /*
49832: ** Save the positions of all cursors (except pExcept) that are open on
49833: ** the table with root-page iRoot. Usually, this is called just before cursor
49834: ** pExcept is used to modify the table (BtreeDelete() or BtreeInsert()).
49835: */
49836: static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
49837: BtCursor *p;
49838: assert( sqlite3_mutex_held(pBt->mutex) );
49839: assert( pExcept==0 || pExcept->pBt==pBt );
49840: for(p=pBt->pCursor; p; p=p->pNext){
49841: if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) &&
49842: p->eState==CURSOR_VALID ){
49843: int rc = saveCursorPosition(p);
49844: if( SQLITE_OK!=rc ){
49845: return rc;
49846: }
49847: }
49848: }
49849: return SQLITE_OK;
49850: }
49851:
49852: /*
49853: ** Clear the current cursor position.
49854: */
49855: SQLITE_PRIVATE void sqlite3BtreeClearCursor(BtCursor *pCur){
49856: assert( cursorHoldsMutex(pCur) );
49857: sqlite3_free(pCur->pKey);
49858: pCur->pKey = 0;
49859: pCur->eState = CURSOR_INVALID;
49860: }
49861:
49862: /*
49863: ** In this version of BtreeMoveto, pKey is a packed index record
49864: ** such as is generated by the OP_MakeRecord opcode. Unpack the
49865: ** record and then call BtreeMovetoUnpacked() to do the work.
49866: */
49867: static int btreeMoveto(
49868: BtCursor *pCur, /* Cursor open on the btree to be searched */
49869: const void *pKey, /* Packed key if the btree is an index */
49870: i64 nKey, /* Integer key for tables. Size of pKey for indices */
49871: int bias, /* Bias search to the high end */
49872: int *pRes /* Write search results here */
49873: ){
49874: int rc; /* Status code */
49875: UnpackedRecord *pIdxKey; /* Unpacked index key */
49876: char aSpace[150]; /* Temp space for pIdxKey - to avoid a malloc */
49877: char *pFree = 0;
49878:
49879: if( pKey ){
49880: assert( nKey==(i64)(int)nKey );
49881: pIdxKey = sqlite3VdbeAllocUnpackedRecord(
49882: pCur->pKeyInfo, aSpace, sizeof(aSpace), &pFree
49883: );
49884: if( pIdxKey==0 ) return SQLITE_NOMEM;
49885: sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
49886: }else{
49887: pIdxKey = 0;
49888: }
49889: rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
49890: if( pFree ){
49891: sqlite3DbFree(pCur->pKeyInfo->db, pFree);
49892: }
49893: return rc;
49894: }
49895:
49896: /*
49897: ** Restore the cursor to the position it was in (or as close to as possible)
49898: ** when saveCursorPosition() was called. Note that this call deletes the
49899: ** saved position info stored by saveCursorPosition(), so there can be
49900: ** at most one effective restoreCursorPosition() call after each
49901: ** saveCursorPosition().
49902: */
49903: static int btreeRestoreCursorPosition(BtCursor *pCur){
49904: int rc;
49905: assert( cursorHoldsMutex(pCur) );
49906: assert( pCur->eState>=CURSOR_REQUIRESEEK );
49907: if( pCur->eState==CURSOR_FAULT ){
49908: return pCur->skipNext;
49909: }
49910: pCur->eState = CURSOR_INVALID;
49911: rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
49912: if( rc==SQLITE_OK ){
49913: sqlite3_free(pCur->pKey);
49914: pCur->pKey = 0;
49915: assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
49916: }
49917: return rc;
49918: }
49919:
49920: #define restoreCursorPosition(p) \
49921: (p->eState>=CURSOR_REQUIRESEEK ? \
49922: btreeRestoreCursorPosition(p) : \
49923: SQLITE_OK)
49924:
49925: /*
49926: ** Determine whether or not a cursor has moved from the position it
49927: ** was last placed at. Cursors can move when the row they are pointing
49928: ** at is deleted out from under them.
49929: **
49930: ** This routine returns an error code if something goes wrong. The
49931: ** integer *pHasMoved is set to one if the cursor has moved and 0 if not.
49932: */
49933: SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur, int *pHasMoved){
49934: int rc;
49935:
49936: rc = restoreCursorPosition(pCur);
49937: if( rc ){
49938: *pHasMoved = 1;
49939: return rc;
49940: }
49941: if( pCur->eState!=CURSOR_VALID || pCur->skipNext!=0 ){
49942: *pHasMoved = 1;
49943: }else{
49944: *pHasMoved = 0;
49945: }
49946: return SQLITE_OK;
49947: }
49948:
49949: #ifndef SQLITE_OMIT_AUTOVACUUM
49950: /*
49951: ** Given a page number of a regular database page, return the page
49952: ** number for the pointer-map page that contains the entry for the
49953: ** input page number.
49954: **
49955: ** Return 0 (not a valid page) for pgno==1 since there is
49956: ** no pointer map associated with page 1. The integrity_check logic
49957: ** requires that ptrmapPageno(*,1)!=1.
49958: */
49959: static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
49960: int nPagesPerMapPage;
49961: Pgno iPtrMap, ret;
49962: assert( sqlite3_mutex_held(pBt->mutex) );
49963: if( pgno<2 ) return 0;
49964: nPagesPerMapPage = (pBt->usableSize/5)+1;
49965: iPtrMap = (pgno-2)/nPagesPerMapPage;
49966: ret = (iPtrMap*nPagesPerMapPage) + 2;
49967: if( ret==PENDING_BYTE_PAGE(pBt) ){
49968: ret++;
49969: }
49970: return ret;
49971: }
49972:
49973: /*
49974: ** Write an entry into the pointer map.
49975: **
49976: ** This routine updates the pointer map entry for page number 'key'
49977: ** so that it maps to type 'eType' and parent page number 'pgno'.
49978: **
49979: ** If *pRC is initially non-zero (non-SQLITE_OK) then this routine is
49980: ** a no-op. If an error occurs, the appropriate error code is written
49981: ** into *pRC.
49982: */
49983: static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
49984: DbPage *pDbPage; /* The pointer map page */
49985: u8 *pPtrmap; /* The pointer map data */
49986: Pgno iPtrmap; /* The pointer map page number */
49987: int offset; /* Offset in pointer map page */
49988: int rc; /* Return code from subfunctions */
49989:
49990: if( *pRC ) return;
49991:
49992: assert( sqlite3_mutex_held(pBt->mutex) );
49993: /* The master-journal page number must never be used as a pointer map page */
49994: assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
49995:
49996: assert( pBt->autoVacuum );
49997: if( key==0 ){
49998: *pRC = SQLITE_CORRUPT_BKPT;
49999: return;
50000: }
50001: iPtrmap = PTRMAP_PAGENO(pBt, key);
50002: rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
50003: if( rc!=SQLITE_OK ){
50004: *pRC = rc;
50005: return;
50006: }
50007: offset = PTRMAP_PTROFFSET(iPtrmap, key);
50008: if( offset<0 ){
50009: *pRC = SQLITE_CORRUPT_BKPT;
50010: goto ptrmap_exit;
50011: }
50012: assert( offset <= (int)pBt->usableSize-5 );
50013: pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
50014:
50015: if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){
50016: TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
50017: *pRC= rc = sqlite3PagerWrite(pDbPage);
50018: if( rc==SQLITE_OK ){
50019: pPtrmap[offset] = eType;
50020: put4byte(&pPtrmap[offset+1], parent);
50021: }
50022: }
50023:
50024: ptrmap_exit:
50025: sqlite3PagerUnref(pDbPage);
50026: }
50027:
50028: /*
50029: ** Read an entry from the pointer map.
50030: **
50031: ** This routine retrieves the pointer map entry for page 'key', writing
50032: ** the type and parent page number to *pEType and *pPgno respectively.
50033: ** An error code is returned if something goes wrong, otherwise SQLITE_OK.
50034: */
50035: static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
50036: DbPage *pDbPage; /* The pointer map page */
50037: int iPtrmap; /* Pointer map page index */
50038: u8 *pPtrmap; /* Pointer map page data */
50039: int offset; /* Offset of entry in pointer map */
50040: int rc;
50041:
50042: assert( sqlite3_mutex_held(pBt->mutex) );
50043:
50044: iPtrmap = PTRMAP_PAGENO(pBt, key);
50045: rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
50046: if( rc!=0 ){
50047: return rc;
50048: }
50049: pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
50050:
50051: offset = PTRMAP_PTROFFSET(iPtrmap, key);
50052: if( offset<0 ){
50053: sqlite3PagerUnref(pDbPage);
50054: return SQLITE_CORRUPT_BKPT;
50055: }
50056: assert( offset <= (int)pBt->usableSize-5 );
50057: assert( pEType!=0 );
50058: *pEType = pPtrmap[offset];
50059: if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]);
50060:
50061: sqlite3PagerUnref(pDbPage);
50062: if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_BKPT;
50063: return SQLITE_OK;
50064: }
50065:
50066: #else /* if defined SQLITE_OMIT_AUTOVACUUM */
50067: #define ptrmapPut(w,x,y,z,rc)
50068: #define ptrmapGet(w,x,y,z) SQLITE_OK
50069: #define ptrmapPutOvflPtr(x, y, rc)
50070: #endif
50071:
50072: /*
50073: ** Given a btree page and a cell index (0 means the first cell on
50074: ** the page, 1 means the second cell, and so forth) return a pointer
50075: ** to the cell content.
50076: **
50077: ** This routine works only for pages that do not contain overflow cells.
50078: */
50079: #define findCell(P,I) \
50080: ((P)->aData + ((P)->maskPage & get2byte(&(P)->aCellIdx[2*(I)])))
50081: #define findCellv2(D,M,O,I) (D+(M&get2byte(D+(O+2*(I)))))
50082:
50083:
50084: /*
50085: ** This a more complex version of findCell() that works for
50086: ** pages that do contain overflow cells.
50087: */
50088: static u8 *findOverflowCell(MemPage *pPage, int iCell){
50089: int i;
50090: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50091: for(i=pPage->nOverflow-1; i>=0; i--){
50092: int k;
50093: struct _OvflCell *pOvfl;
50094: pOvfl = &pPage->aOvfl[i];
50095: k = pOvfl->idx;
50096: if( k<=iCell ){
50097: if( k==iCell ){
50098: return pOvfl->pCell;
50099: }
50100: iCell--;
50101: }
50102: }
50103: return findCell(pPage, iCell);
50104: }
50105:
50106: /*
50107: ** Parse a cell content block and fill in the CellInfo structure. There
50108: ** are two versions of this function. btreeParseCell() takes a
50109: ** cell index as the second argument and btreeParseCellPtr()
50110: ** takes a pointer to the body of the cell as its second argument.
50111: **
50112: ** Within this file, the parseCell() macro can be called instead of
50113: ** btreeParseCellPtr(). Using some compilers, this will be faster.
50114: */
50115: static void btreeParseCellPtr(
50116: MemPage *pPage, /* Page containing the cell */
50117: u8 *pCell, /* Pointer to the cell text. */
50118: CellInfo *pInfo /* Fill in this structure */
50119: ){
50120: u16 n; /* Number bytes in cell content header */
50121: u32 nPayload; /* Number of bytes of cell payload */
50122:
50123: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50124:
50125: pInfo->pCell = pCell;
50126: assert( pPage->leaf==0 || pPage->leaf==1 );
50127: n = pPage->childPtrSize;
50128: assert( n==4-4*pPage->leaf );
50129: if( pPage->intKey ){
50130: if( pPage->hasData ){
50131: n += getVarint32(&pCell[n], nPayload);
50132: }else{
50133: nPayload = 0;
50134: }
50135: n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
50136: pInfo->nData = nPayload;
50137: }else{
50138: pInfo->nData = 0;
50139: n += getVarint32(&pCell[n], nPayload);
50140: pInfo->nKey = nPayload;
50141: }
50142: pInfo->nPayload = nPayload;
50143: pInfo->nHeader = n;
50144: testcase( nPayload==pPage->maxLocal );
50145: testcase( nPayload==pPage->maxLocal+1 );
50146: if( likely(nPayload<=pPage->maxLocal) ){
50147: /* This is the (easy) common case where the entire payload fits
50148: ** on the local page. No overflow is required.
50149: */
50150: if( (pInfo->nSize = (u16)(n+nPayload))<4 ) pInfo->nSize = 4;
50151: pInfo->nLocal = (u16)nPayload;
50152: pInfo->iOverflow = 0;
50153: }else{
50154: /* If the payload will not fit completely on the local page, we have
50155: ** to decide how much to store locally and how much to spill onto
50156: ** overflow pages. The strategy is to minimize the amount of unused
50157: ** space on overflow pages while keeping the amount of local storage
50158: ** in between minLocal and maxLocal.
50159: **
50160: ** Warning: changing the way overflow payload is distributed in any
50161: ** way will result in an incompatible file format.
50162: */
50163: int minLocal; /* Minimum amount of payload held locally */
50164: int maxLocal; /* Maximum amount of payload held locally */
50165: int surplus; /* Overflow payload available for local storage */
50166:
50167: minLocal = pPage->minLocal;
50168: maxLocal = pPage->maxLocal;
50169: surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4);
50170: testcase( surplus==maxLocal );
50171: testcase( surplus==maxLocal+1 );
50172: if( surplus <= maxLocal ){
50173: pInfo->nLocal = (u16)surplus;
50174: }else{
50175: pInfo->nLocal = (u16)minLocal;
50176: }
50177: pInfo->iOverflow = (u16)(pInfo->nLocal + n);
50178: pInfo->nSize = pInfo->iOverflow + 4;
50179: }
50180: }
50181: #define parseCell(pPage, iCell, pInfo) \
50182: btreeParseCellPtr((pPage), findCell((pPage), (iCell)), (pInfo))
50183: static void btreeParseCell(
50184: MemPage *pPage, /* Page containing the cell */
50185: int iCell, /* The cell index. First cell is 0 */
50186: CellInfo *pInfo /* Fill in this structure */
50187: ){
50188: parseCell(pPage, iCell, pInfo);
50189: }
50190:
50191: /*
50192: ** Compute the total number of bytes that a Cell needs in the cell
50193: ** data area of the btree-page. The return number includes the cell
50194: ** data header and the local payload, but not any overflow page or
50195: ** the space used by the cell pointer.
50196: */
50197: static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
50198: u8 *pIter = &pCell[pPage->childPtrSize];
50199: u32 nSize;
50200:
50201: #ifdef SQLITE_DEBUG
50202: /* The value returned by this function should always be the same as
50203: ** the (CellInfo.nSize) value found by doing a full parse of the
50204: ** cell. If SQLITE_DEBUG is defined, an assert() at the bottom of
50205: ** this function verifies that this invariant is not violated. */
50206: CellInfo debuginfo;
50207: btreeParseCellPtr(pPage, pCell, &debuginfo);
50208: #endif
50209:
50210: if( pPage->intKey ){
50211: u8 *pEnd;
50212: if( pPage->hasData ){
50213: pIter += getVarint32(pIter, nSize);
50214: }else{
50215: nSize = 0;
50216: }
50217:
50218: /* pIter now points at the 64-bit integer key value, a variable length
50219: ** integer. The following block moves pIter to point at the first byte
50220: ** past the end of the key value. */
50221: pEnd = &pIter[9];
50222: while( (*pIter++)&0x80 && pIter<pEnd );
50223: }else{
50224: pIter += getVarint32(pIter, nSize);
50225: }
50226:
50227: testcase( nSize==pPage->maxLocal );
50228: testcase( nSize==pPage->maxLocal+1 );
50229: if( nSize>pPage->maxLocal ){
50230: int minLocal = pPage->minLocal;
50231: nSize = minLocal + (nSize - minLocal) % (pPage->pBt->usableSize - 4);
50232: testcase( nSize==pPage->maxLocal );
50233: testcase( nSize==pPage->maxLocal+1 );
50234: if( nSize>pPage->maxLocal ){
50235: nSize = minLocal;
50236: }
50237: nSize += 4;
50238: }
50239: nSize += (u32)(pIter - pCell);
50240:
50241: /* The minimum size of any cell is 4 bytes. */
50242: if( nSize<4 ){
50243: nSize = 4;
50244: }
50245:
50246: assert( nSize==debuginfo.nSize );
50247: return (u16)nSize;
50248: }
50249:
50250: #ifdef SQLITE_DEBUG
50251: /* This variation on cellSizePtr() is used inside of assert() statements
50252: ** only. */
50253: static u16 cellSize(MemPage *pPage, int iCell){
50254: return cellSizePtr(pPage, findCell(pPage, iCell));
50255: }
50256: #endif
50257:
50258: #ifndef SQLITE_OMIT_AUTOVACUUM
50259: /*
50260: ** If the cell pCell, part of page pPage contains a pointer
50261: ** to an overflow page, insert an entry into the pointer-map
50262: ** for the overflow page.
50263: */
50264: static void ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell, int *pRC){
50265: CellInfo info;
50266: if( *pRC ) return;
50267: assert( pCell!=0 );
50268: btreeParseCellPtr(pPage, pCell, &info);
50269: assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
50270: if( info.iOverflow ){
50271: Pgno ovfl = get4byte(&pCell[info.iOverflow]);
50272: ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
50273: }
50274: }
50275: #endif
50276:
50277:
50278: /*
50279: ** Defragment the page given. All Cells are moved to the
50280: ** end of the page and all free space is collected into one
50281: ** big FreeBlk that occurs in between the header and cell
50282: ** pointer array and the cell content area.
50283: */
50284: static int defragmentPage(MemPage *pPage){
50285: int i; /* Loop counter */
50286: int pc; /* Address of a i-th cell */
50287: int hdr; /* Offset to the page header */
50288: int size; /* Size of a cell */
50289: int usableSize; /* Number of usable bytes on a page */
50290: int cellOffset; /* Offset to the cell pointer array */
50291: int cbrk; /* Offset to the cell content area */
50292: int nCell; /* Number of cells on the page */
50293: unsigned char *data; /* The page data */
50294: unsigned char *temp; /* Temp area for cell content */
50295: int iCellFirst; /* First allowable cell index */
50296: int iCellLast; /* Last possible cell index */
50297:
50298:
50299: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
50300: assert( pPage->pBt!=0 );
50301: assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
50302: assert( pPage->nOverflow==0 );
50303: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50304: temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
50305: data = pPage->aData;
50306: hdr = pPage->hdrOffset;
50307: cellOffset = pPage->cellOffset;
50308: nCell = pPage->nCell;
50309: assert( nCell==get2byte(&data[hdr+3]) );
50310: usableSize = pPage->pBt->usableSize;
50311: cbrk = get2byte(&data[hdr+5]);
50312: memcpy(&temp[cbrk], &data[cbrk], usableSize - cbrk);
50313: cbrk = usableSize;
50314: iCellFirst = cellOffset + 2*nCell;
50315: iCellLast = usableSize - 4;
50316: for(i=0; i<nCell; i++){
50317: u8 *pAddr; /* The i-th cell pointer */
50318: pAddr = &data[cellOffset + i*2];
50319: pc = get2byte(pAddr);
50320: testcase( pc==iCellFirst );
50321: testcase( pc==iCellLast );
50322: #if !defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
50323: /* These conditions have already been verified in btreeInitPage()
50324: ** if SQLITE_ENABLE_OVERSIZE_CELL_CHECK is defined
50325: */
50326: if( pc<iCellFirst || pc>iCellLast ){
50327: return SQLITE_CORRUPT_BKPT;
50328: }
50329: #endif
50330: assert( pc>=iCellFirst && pc<=iCellLast );
50331: size = cellSizePtr(pPage, &temp[pc]);
50332: cbrk -= size;
50333: #if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
50334: if( cbrk<iCellFirst ){
50335: return SQLITE_CORRUPT_BKPT;
50336: }
50337: #else
50338: if( cbrk<iCellFirst || pc+size>usableSize ){
50339: return SQLITE_CORRUPT_BKPT;
50340: }
50341: #endif
50342: assert( cbrk+size<=usableSize && cbrk>=iCellFirst );
50343: testcase( cbrk+size==usableSize );
50344: testcase( pc+size==usableSize );
50345: memcpy(&data[cbrk], &temp[pc], size);
50346: put2byte(pAddr, cbrk);
50347: }
50348: assert( cbrk>=iCellFirst );
50349: put2byte(&data[hdr+5], cbrk);
50350: data[hdr+1] = 0;
50351: data[hdr+2] = 0;
50352: data[hdr+7] = 0;
50353: memset(&data[iCellFirst], 0, cbrk-iCellFirst);
50354: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
50355: if( cbrk-iCellFirst!=pPage->nFree ){
50356: return SQLITE_CORRUPT_BKPT;
50357: }
50358: return SQLITE_OK;
50359: }
50360:
50361: /*
50362: ** Allocate nByte bytes of space from within the B-Tree page passed
50363: ** as the first argument. Write into *pIdx the index into pPage->aData[]
50364: ** of the first byte of allocated space. Return either SQLITE_OK or
50365: ** an error code (usually SQLITE_CORRUPT).
50366: **
50367: ** The caller guarantees that there is sufficient space to make the
50368: ** allocation. This routine might need to defragment in order to bring
50369: ** all the space together, however. This routine will avoid using
50370: ** the first two bytes past the cell pointer area since presumably this
50371: ** allocation is being made in order to insert a new cell, so we will
50372: ** also end up needing a new cell pointer.
50373: */
50374: static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
50375: const int hdr = pPage->hdrOffset; /* Local cache of pPage->hdrOffset */
50376: u8 * const data = pPage->aData; /* Local cache of pPage->aData */
50377: int nFrag; /* Number of fragmented bytes on pPage */
50378: int top; /* First byte of cell content area */
50379: int gap; /* First byte of gap between cell pointers and cell content */
50380: int rc; /* Integer return code */
50381: int usableSize; /* Usable size of the page */
50382:
50383: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
50384: assert( pPage->pBt );
50385: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50386: assert( nByte>=0 ); /* Minimum cell size is 4 */
50387: assert( pPage->nFree>=nByte );
50388: assert( pPage->nOverflow==0 );
50389: usableSize = pPage->pBt->usableSize;
50390: assert( nByte < usableSize-8 );
50391:
50392: nFrag = data[hdr+7];
50393: assert( pPage->cellOffset == hdr + 12 - 4*pPage->leaf );
50394: gap = pPage->cellOffset + 2*pPage->nCell;
50395: top = get2byteNotZero(&data[hdr+5]);
50396: if( gap>top ) return SQLITE_CORRUPT_BKPT;
50397: testcase( gap+2==top );
50398: testcase( gap+1==top );
50399: testcase( gap==top );
50400:
50401: if( nFrag>=60 ){
50402: /* Always defragment highly fragmented pages */
50403: rc = defragmentPage(pPage);
50404: if( rc ) return rc;
50405: top = get2byteNotZero(&data[hdr+5]);
50406: }else if( gap+2<=top ){
50407: /* Search the freelist looking for a free slot big enough to satisfy
50408: ** the request. The allocation is made from the first free slot in
50409: ** the list that is large enough to accomadate it.
50410: */
50411: int pc, addr;
50412: for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){
50413: int size; /* Size of the free slot */
50414: if( pc>usableSize-4 || pc<addr+4 ){
50415: return SQLITE_CORRUPT_BKPT;
50416: }
50417: size = get2byte(&data[pc+2]);
50418: if( size>=nByte ){
50419: int x = size - nByte;
50420: testcase( x==4 );
50421: testcase( x==3 );
50422: if( x<4 ){
50423: /* Remove the slot from the free-list. Update the number of
50424: ** fragmented bytes within the page. */
50425: memcpy(&data[addr], &data[pc], 2);
50426: data[hdr+7] = (u8)(nFrag + x);
50427: }else if( size+pc > usableSize ){
50428: return SQLITE_CORRUPT_BKPT;
50429: }else{
50430: /* The slot remains on the free-list. Reduce its size to account
50431: ** for the portion used by the new allocation. */
50432: put2byte(&data[pc+2], x);
50433: }
50434: *pIdx = pc + x;
50435: return SQLITE_OK;
50436: }
50437: }
50438: }
50439:
50440: /* Check to make sure there is enough space in the gap to satisfy
50441: ** the allocation. If not, defragment.
50442: */
50443: testcase( gap+2+nByte==top );
50444: if( gap+2+nByte>top ){
50445: rc = defragmentPage(pPage);
50446: if( rc ) return rc;
50447: top = get2byteNotZero(&data[hdr+5]);
50448: assert( gap+nByte<=top );
50449: }
50450:
50451:
50452: /* Allocate memory from the gap in between the cell pointer array
50453: ** and the cell content area. The btreeInitPage() call has already
50454: ** validated the freelist. Given that the freelist is valid, there
50455: ** is no way that the allocation can extend off the end of the page.
50456: ** The assert() below verifies the previous sentence.
50457: */
50458: top -= nByte;
50459: put2byte(&data[hdr+5], top);
50460: assert( top+nByte <= (int)pPage->pBt->usableSize );
50461: *pIdx = top;
50462: return SQLITE_OK;
50463: }
50464:
50465: /*
50466: ** Return a section of the pPage->aData to the freelist.
50467: ** The first byte of the new free block is pPage->aDisk[start]
50468: ** and the size of the block is "size" bytes.
50469: **
50470: ** Most of the effort here is involved in coalesing adjacent
50471: ** free blocks into a single big free block.
50472: */
50473: static int freeSpace(MemPage *pPage, int start, int size){
50474: int addr, pbegin, hdr;
50475: int iLast; /* Largest possible freeblock offset */
50476: unsigned char *data = pPage->aData;
50477:
50478: assert( pPage->pBt!=0 );
50479: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
50480: assert( start>=pPage->hdrOffset+6+pPage->childPtrSize );
50481: assert( (start + size) <= (int)pPage->pBt->usableSize );
50482: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50483: assert( size>=0 ); /* Minimum cell size is 4 */
50484:
50485: if( pPage->pBt->btsFlags & BTS_SECURE_DELETE ){
50486: /* Overwrite deleted information with zeros when the secure_delete
50487: ** option is enabled */
50488: memset(&data[start], 0, size);
50489: }
50490:
50491: /* Add the space back into the linked list of freeblocks. Note that
50492: ** even though the freeblock list was checked by btreeInitPage(),
50493: ** btreeInitPage() did not detect overlapping cells or
50494: ** freeblocks that overlapped cells. Nor does it detect when the
50495: ** cell content area exceeds the value in the page header. If these
50496: ** situations arise, then subsequent insert operations might corrupt
50497: ** the freelist. So we do need to check for corruption while scanning
50498: ** the freelist.
50499: */
50500: hdr = pPage->hdrOffset;
50501: addr = hdr + 1;
50502: iLast = pPage->pBt->usableSize - 4;
50503: assert( start<=iLast );
50504: while( (pbegin = get2byte(&data[addr]))<start && pbegin>0 ){
50505: if( pbegin<addr+4 ){
50506: return SQLITE_CORRUPT_BKPT;
50507: }
50508: addr = pbegin;
50509: }
50510: if( pbegin>iLast ){
50511: return SQLITE_CORRUPT_BKPT;
50512: }
50513: assert( pbegin>addr || pbegin==0 );
50514: put2byte(&data[addr], start);
50515: put2byte(&data[start], pbegin);
50516: put2byte(&data[start+2], size);
50517: pPage->nFree = pPage->nFree + (u16)size;
50518:
50519: /* Coalesce adjacent free blocks */
50520: addr = hdr + 1;
50521: while( (pbegin = get2byte(&data[addr]))>0 ){
50522: int pnext, psize, x;
50523: assert( pbegin>addr );
50524: assert( pbegin <= (int)pPage->pBt->usableSize-4 );
50525: pnext = get2byte(&data[pbegin]);
50526: psize = get2byte(&data[pbegin+2]);
50527: if( pbegin + psize + 3 >= pnext && pnext>0 ){
50528: int frag = pnext - (pbegin+psize);
50529: if( (frag<0) || (frag>(int)data[hdr+7]) ){
50530: return SQLITE_CORRUPT_BKPT;
50531: }
50532: data[hdr+7] -= (u8)frag;
50533: x = get2byte(&data[pnext]);
50534: put2byte(&data[pbegin], x);
50535: x = pnext + get2byte(&data[pnext+2]) - pbegin;
50536: put2byte(&data[pbegin+2], x);
50537: }else{
50538: addr = pbegin;
50539: }
50540: }
50541:
50542: /* If the cell content area begins with a freeblock, remove it. */
50543: if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){
50544: int top;
50545: pbegin = get2byte(&data[hdr+1]);
50546: memcpy(&data[hdr+1], &data[pbegin], 2);
50547: top = get2byte(&data[hdr+5]) + get2byte(&data[pbegin+2]);
50548: put2byte(&data[hdr+5], top);
50549: }
50550: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
50551: return SQLITE_OK;
50552: }
50553:
50554: /*
50555: ** Decode the flags byte (the first byte of the header) for a page
50556: ** and initialize fields of the MemPage structure accordingly.
50557: **
50558: ** Only the following combinations are supported. Anything different
50559: ** indicates a corrupt database files:
50560: **
50561: ** PTF_ZERODATA
50562: ** PTF_ZERODATA | PTF_LEAF
50563: ** PTF_LEAFDATA | PTF_INTKEY
50564: ** PTF_LEAFDATA | PTF_INTKEY | PTF_LEAF
50565: */
50566: static int decodeFlags(MemPage *pPage, int flagByte){
50567: BtShared *pBt; /* A copy of pPage->pBt */
50568:
50569: assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
50570: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50571: pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
50572: flagByte &= ~PTF_LEAF;
50573: pPage->childPtrSize = 4-4*pPage->leaf;
50574: pBt = pPage->pBt;
50575: if( flagByte==(PTF_LEAFDATA | PTF_INTKEY) ){
50576: pPage->intKey = 1;
50577: pPage->hasData = pPage->leaf;
50578: pPage->maxLocal = pBt->maxLeaf;
50579: pPage->minLocal = pBt->minLeaf;
50580: }else if( flagByte==PTF_ZERODATA ){
50581: pPage->intKey = 0;
50582: pPage->hasData = 0;
50583: pPage->maxLocal = pBt->maxLocal;
50584: pPage->minLocal = pBt->minLocal;
50585: }else{
50586: return SQLITE_CORRUPT_BKPT;
50587: }
50588: pPage->max1bytePayload = pBt->max1bytePayload;
50589: return SQLITE_OK;
50590: }
50591:
50592: /*
50593: ** Initialize the auxiliary information for a disk block.
50594: **
50595: ** Return SQLITE_OK on success. If we see that the page does
50596: ** not contain a well-formed database page, then return
50597: ** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
50598: ** guarantee that the page is well-formed. It only shows that
50599: ** we failed to detect any corruption.
50600: */
50601: static int btreeInitPage(MemPage *pPage){
50602:
50603: assert( pPage->pBt!=0 );
50604: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50605: assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
50606: assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
50607: assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
50608:
50609: if( !pPage->isInit ){
50610: u16 pc; /* Address of a freeblock within pPage->aData[] */
50611: u8 hdr; /* Offset to beginning of page header */
50612: u8 *data; /* Equal to pPage->aData */
50613: BtShared *pBt; /* The main btree structure */
50614: int usableSize; /* Amount of usable space on each page */
50615: u16 cellOffset; /* Offset from start of page to first cell pointer */
50616: int nFree; /* Number of unused bytes on the page */
50617: int top; /* First byte of the cell content area */
50618: int iCellFirst; /* First allowable cell or freeblock offset */
50619: int iCellLast; /* Last possible cell or freeblock offset */
50620:
50621: pBt = pPage->pBt;
50622:
50623: hdr = pPage->hdrOffset;
50624: data = pPage->aData;
50625: if( decodeFlags(pPage, data[hdr]) ) return SQLITE_CORRUPT_BKPT;
50626: assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
50627: pPage->maskPage = (u16)(pBt->pageSize - 1);
50628: pPage->nOverflow = 0;
50629: usableSize = pBt->usableSize;
50630: pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
50631: pPage->aDataEnd = &data[usableSize];
50632: pPage->aCellIdx = &data[cellOffset];
50633: top = get2byteNotZero(&data[hdr+5]);
50634: pPage->nCell = get2byte(&data[hdr+3]);
50635: if( pPage->nCell>MX_CELL(pBt) ){
50636: /* To many cells for a single page. The page must be corrupt */
50637: return SQLITE_CORRUPT_BKPT;
50638: }
50639: testcase( pPage->nCell==MX_CELL(pBt) );
50640:
50641: /* A malformed database page might cause us to read past the end
50642: ** of page when parsing a cell.
50643: **
50644: ** The following block of code checks early to see if a cell extends
50645: ** past the end of a page boundary and causes SQLITE_CORRUPT to be
50646: ** returned if it does.
50647: */
50648: iCellFirst = cellOffset + 2*pPage->nCell;
50649: iCellLast = usableSize - 4;
50650: #if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
50651: {
50652: int i; /* Index into the cell pointer array */
50653: int sz; /* Size of a cell */
50654:
50655: if( !pPage->leaf ) iCellLast--;
50656: for(i=0; i<pPage->nCell; i++){
50657: pc = get2byte(&data[cellOffset+i*2]);
50658: testcase( pc==iCellFirst );
50659: testcase( pc==iCellLast );
50660: if( pc<iCellFirst || pc>iCellLast ){
50661: return SQLITE_CORRUPT_BKPT;
50662: }
50663: sz = cellSizePtr(pPage, &data[pc]);
50664: testcase( pc+sz==usableSize );
50665: if( pc+sz>usableSize ){
50666: return SQLITE_CORRUPT_BKPT;
50667: }
50668: }
50669: if( !pPage->leaf ) iCellLast++;
50670: }
50671: #endif
50672:
50673: /* Compute the total free space on the page */
50674: pc = get2byte(&data[hdr+1]);
50675: nFree = data[hdr+7] + top;
50676: while( pc>0 ){
50677: u16 next, size;
50678: if( pc<iCellFirst || pc>iCellLast ){
50679: /* Start of free block is off the page */
50680: return SQLITE_CORRUPT_BKPT;
50681: }
50682: next = get2byte(&data[pc]);
50683: size = get2byte(&data[pc+2]);
50684: if( (next>0 && next<=pc+size+3) || pc+size>usableSize ){
50685: /* Free blocks must be in ascending order. And the last byte of
50686: ** the free-block must lie on the database page. */
50687: return SQLITE_CORRUPT_BKPT;
50688: }
50689: nFree = nFree + size;
50690: pc = next;
50691: }
50692:
50693: /* At this point, nFree contains the sum of the offset to the start
50694: ** of the cell-content area plus the number of free bytes within
50695: ** the cell-content area. If this is greater than the usable-size
50696: ** of the page, then the page must be corrupted. This check also
50697: ** serves to verify that the offset to the start of the cell-content
50698: ** area, according to the page header, lies within the page.
50699: */
50700: if( nFree>usableSize ){
50701: return SQLITE_CORRUPT_BKPT;
50702: }
50703: pPage->nFree = (u16)(nFree - iCellFirst);
50704: pPage->isInit = 1;
50705: }
50706: return SQLITE_OK;
50707: }
50708:
50709: /*
50710: ** Set up a raw page so that it looks like a database page holding
50711: ** no entries.
50712: */
50713: static void zeroPage(MemPage *pPage, int flags){
50714: unsigned char *data = pPage->aData;
50715: BtShared *pBt = pPage->pBt;
50716: u8 hdr = pPage->hdrOffset;
50717: u16 first;
50718:
50719: assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
50720: assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
50721: assert( sqlite3PagerGetData(pPage->pDbPage) == data );
50722: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
50723: assert( sqlite3_mutex_held(pBt->mutex) );
50724: if( pBt->btsFlags & BTS_SECURE_DELETE ){
50725: memset(&data[hdr], 0, pBt->usableSize - hdr);
50726: }
50727: data[hdr] = (char)flags;
50728: first = hdr + 8 + 4*((flags&PTF_LEAF)==0 ?1:0);
50729: memset(&data[hdr+1], 0, 4);
50730: data[hdr+7] = 0;
50731: put2byte(&data[hdr+5], pBt->usableSize);
50732: pPage->nFree = (u16)(pBt->usableSize - first);
50733: decodeFlags(pPage, flags);
50734: pPage->hdrOffset = hdr;
50735: pPage->cellOffset = first;
50736: pPage->aDataEnd = &data[pBt->usableSize];
50737: pPage->aCellIdx = &data[first];
50738: pPage->nOverflow = 0;
50739: assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
50740: pPage->maskPage = (u16)(pBt->pageSize - 1);
50741: pPage->nCell = 0;
50742: pPage->isInit = 1;
50743: }
50744:
50745:
50746: /*
50747: ** Convert a DbPage obtained from the pager into a MemPage used by
50748: ** the btree layer.
50749: */
50750: static MemPage *btreePageFromDbPage(DbPage *pDbPage, Pgno pgno, BtShared *pBt){
50751: MemPage *pPage = (MemPage*)sqlite3PagerGetExtra(pDbPage);
50752: pPage->aData = sqlite3PagerGetData(pDbPage);
50753: pPage->pDbPage = pDbPage;
50754: pPage->pBt = pBt;
50755: pPage->pgno = pgno;
50756: pPage->hdrOffset = pPage->pgno==1 ? 100 : 0;
50757: return pPage;
50758: }
50759:
50760: /*
50761: ** Get a page from the pager. Initialize the MemPage.pBt and
50762: ** MemPage.aData elements if needed.
50763: **
50764: ** If the noContent flag is set, it means that we do not care about
50765: ** the content of the page at this time. So do not go to the disk
50766: ** to fetch the content. Just fill in the content with zeros for now.
50767: ** If in the future we call sqlite3PagerWrite() on this page, that
50768: ** means we have started to be concerned about content and the disk
50769: ** read should occur at that point.
50770: */
50771: static int btreeGetPage(
50772: BtShared *pBt, /* The btree */
50773: Pgno pgno, /* Number of the page to fetch */
50774: MemPage **ppPage, /* Return the page in this parameter */
50775: int noContent /* Do not load page content if true */
50776: ){
50777: int rc;
50778: DbPage *pDbPage;
50779:
50780: assert( sqlite3_mutex_held(pBt->mutex) );
50781: rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
50782: if( rc ) return rc;
50783: *ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
50784: return SQLITE_OK;
50785: }
50786:
50787: /*
50788: ** Retrieve a page from the pager cache. If the requested page is not
50789: ** already in the pager cache return NULL. Initialize the MemPage.pBt and
50790: ** MemPage.aData elements if needed.
50791: */
50792: static MemPage *btreePageLookup(BtShared *pBt, Pgno pgno){
50793: DbPage *pDbPage;
50794: assert( sqlite3_mutex_held(pBt->mutex) );
50795: pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
50796: if( pDbPage ){
50797: return btreePageFromDbPage(pDbPage, pgno, pBt);
50798: }
50799: return 0;
50800: }
50801:
50802: /*
50803: ** Return the size of the database file in pages. If there is any kind of
50804: ** error, return ((unsigned int)-1).
50805: */
50806: static Pgno btreePagecount(BtShared *pBt){
50807: return pBt->nPage;
50808: }
50809: SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree *p){
50810: assert( sqlite3BtreeHoldsMutex(p) );
50811: assert( ((p->pBt->nPage)&0x8000000)==0 );
50812: return (int)btreePagecount(p->pBt);
50813: }
50814:
50815: /*
50816: ** Get a page from the pager and initialize it. This routine is just a
50817: ** convenience wrapper around separate calls to btreeGetPage() and
50818: ** btreeInitPage().
50819: **
50820: ** If an error occurs, then the value *ppPage is set to is undefined. It
50821: ** may remain unchanged, or it may be set to an invalid value.
50822: */
50823: static int getAndInitPage(
50824: BtShared *pBt, /* The database file */
50825: Pgno pgno, /* Number of the page to get */
50826: MemPage **ppPage /* Write the page pointer here */
50827: ){
50828: int rc;
50829: assert( sqlite3_mutex_held(pBt->mutex) );
50830:
50831: if( pgno>btreePagecount(pBt) ){
50832: rc = SQLITE_CORRUPT_BKPT;
50833: }else{
50834: rc = btreeGetPage(pBt, pgno, ppPage, 0);
50835: if( rc==SQLITE_OK ){
50836: rc = btreeInitPage(*ppPage);
50837: if( rc!=SQLITE_OK ){
50838: releasePage(*ppPage);
50839: }
50840: }
50841: }
50842:
50843: testcase( pgno==0 );
50844: assert( pgno!=0 || rc==SQLITE_CORRUPT );
50845: return rc;
50846: }
50847:
50848: /*
50849: ** Release a MemPage. This should be called once for each prior
50850: ** call to btreeGetPage.
50851: */
50852: static void releasePage(MemPage *pPage){
50853: if( pPage ){
50854: assert( pPage->aData );
50855: assert( pPage->pBt );
50856: assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
50857: assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
50858: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50859: sqlite3PagerUnref(pPage->pDbPage);
50860: }
50861: }
50862:
50863: /*
50864: ** During a rollback, when the pager reloads information into the cache
50865: ** so that the cache is restored to its original state at the start of
50866: ** the transaction, for each page restored this routine is called.
50867: **
50868: ** This routine needs to reset the extra data section at the end of the
50869: ** page to agree with the restored data.
50870: */
50871: static void pageReinit(DbPage *pData){
50872: MemPage *pPage;
50873: pPage = (MemPage *)sqlite3PagerGetExtra(pData);
50874: assert( sqlite3PagerPageRefcount(pData)>0 );
50875: if( pPage->isInit ){
50876: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
50877: pPage->isInit = 0;
50878: if( sqlite3PagerPageRefcount(pData)>1 ){
50879: /* pPage might not be a btree page; it might be an overflow page
50880: ** or ptrmap page or a free page. In those cases, the following
50881: ** call to btreeInitPage() will likely return SQLITE_CORRUPT.
50882: ** But no harm is done by this. And it is very important that
50883: ** btreeInitPage() be called on every btree page so we make
50884: ** the call for every page that comes in for re-initing. */
50885: btreeInitPage(pPage);
50886: }
50887: }
50888: }
50889:
50890: /*
50891: ** Invoke the busy handler for a btree.
50892: */
50893: static int btreeInvokeBusyHandler(void *pArg){
50894: BtShared *pBt = (BtShared*)pArg;
50895: assert( pBt->db );
50896: assert( sqlite3_mutex_held(pBt->db->mutex) );
50897: return sqlite3InvokeBusyHandler(&pBt->db->busyHandler);
50898: }
50899:
50900: /*
50901: ** Open a database file.
50902: **
50903: ** zFilename is the name of the database file. If zFilename is NULL
50904: ** then an ephemeral database is created. The ephemeral database might
50905: ** be exclusively in memory, or it might use a disk-based memory cache.
50906: ** Either way, the ephemeral database will be automatically deleted
50907: ** when sqlite3BtreeClose() is called.
50908: **
50909: ** If zFilename is ":memory:" then an in-memory database is created
50910: ** that is automatically destroyed when it is closed.
50911: **
50912: ** The "flags" parameter is a bitmask that might contain bits
50913: ** BTREE_OMIT_JOURNAL and/or BTREE_NO_READLOCK. The BTREE_NO_READLOCK
50914: ** bit is also set if the SQLITE_NoReadlock flags is set in db->flags.
50915: ** These flags are passed through into sqlite3PagerOpen() and must
50916: ** be the same values as PAGER_OMIT_JOURNAL and PAGER_NO_READLOCK.
50917: **
50918: ** If the database is already opened in the same database connection
50919: ** and we are in shared cache mode, then the open will fail with an
50920: ** SQLITE_CONSTRAINT error. We cannot allow two or more BtShared
50921: ** objects in the same database connection since doing so will lead
50922: ** to problems with locking.
50923: */
50924: SQLITE_PRIVATE int sqlite3BtreeOpen(
50925: sqlite3_vfs *pVfs, /* VFS to use for this b-tree */
50926: const char *zFilename, /* Name of the file containing the BTree database */
50927: sqlite3 *db, /* Associated database handle */
50928: Btree **ppBtree, /* Pointer to new Btree object written here */
50929: int flags, /* Options */
50930: int vfsFlags /* Flags passed through to sqlite3_vfs.xOpen() */
50931: ){
50932: BtShared *pBt = 0; /* Shared part of btree structure */
50933: Btree *p; /* Handle to return */
50934: sqlite3_mutex *mutexOpen = 0; /* Prevents a race condition. Ticket #3537 */
50935: int rc = SQLITE_OK; /* Result code from this function */
50936: u8 nReserve; /* Byte of unused space on each page */
50937: unsigned char zDbHeader[100]; /* Database header content */
50938:
50939: /* True if opening an ephemeral, temporary database */
50940: const int isTempDb = zFilename==0 || zFilename[0]==0;
50941:
50942: /* Set the variable isMemdb to true for an in-memory database, or
50943: ** false for a file-based database.
50944: */
50945: #ifdef SQLITE_OMIT_MEMORYDB
50946: const int isMemdb = 0;
50947: #else
50948: const int isMemdb = (zFilename && strcmp(zFilename, ":memory:")==0)
50949: || (isTempDb && sqlite3TempInMemory(db));
50950: #endif
50951:
50952: assert( db!=0 );
50953: assert( pVfs!=0 );
50954: assert( sqlite3_mutex_held(db->mutex) );
50955: assert( (flags&0xff)==flags ); /* flags fit in 8 bits */
50956:
50957: /* Only a BTREE_SINGLE database can be BTREE_UNORDERED */
50958: assert( (flags & BTREE_UNORDERED)==0 || (flags & BTREE_SINGLE)!=0 );
50959:
50960: /* A BTREE_SINGLE database is always a temporary and/or ephemeral */
50961: assert( (flags & BTREE_SINGLE)==0 || isTempDb );
50962:
50963: if( db->flags & SQLITE_NoReadlock ){
50964: flags |= BTREE_NO_READLOCK;
50965: }
50966: if( isMemdb ){
50967: flags |= BTREE_MEMORY;
50968: }
50969: if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (isMemdb || isTempDb) ){
50970: vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
50971: }
50972: p = sqlite3MallocZero(sizeof(Btree));
50973: if( !p ){
50974: return SQLITE_NOMEM;
50975: }
50976: p->inTrans = TRANS_NONE;
50977: p->db = db;
50978: #ifndef SQLITE_OMIT_SHARED_CACHE
50979: p->lock.pBtree = p;
50980: p->lock.iTable = 1;
50981: #endif
50982:
50983: #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
50984: /*
50985: ** If this Btree is a candidate for shared cache, try to find an
50986: ** existing BtShared object that we can share with
50987: */
50988: if( isMemdb==0 && isTempDb==0 ){
50989: if( vfsFlags & SQLITE_OPEN_SHAREDCACHE ){
50990: int nFullPathname = pVfs->mxPathname+1;
50991: char *zFullPathname = sqlite3Malloc(nFullPathname);
50992: MUTEX_LOGIC( sqlite3_mutex *mutexShared; )
50993: p->sharable = 1;
50994: if( !zFullPathname ){
50995: sqlite3_free(p);
50996: return SQLITE_NOMEM;
50997: }
50998: rc = sqlite3OsFullPathname(pVfs, zFilename, nFullPathname, zFullPathname);
50999: if( rc ){
51000: sqlite3_free(zFullPathname);
51001: sqlite3_free(p);
51002: return rc;
51003: }
51004: #if SQLITE_THREADSAFE
51005: mutexOpen = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_OPEN);
51006: sqlite3_mutex_enter(mutexOpen);
51007: mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
51008: sqlite3_mutex_enter(mutexShared);
51009: #endif
51010: for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
51011: assert( pBt->nRef>0 );
51012: if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager))
51013: && sqlite3PagerVfs(pBt->pPager)==pVfs ){
51014: int iDb;
51015: for(iDb=db->nDb-1; iDb>=0; iDb--){
51016: Btree *pExisting = db->aDb[iDb].pBt;
51017: if( pExisting && pExisting->pBt==pBt ){
51018: sqlite3_mutex_leave(mutexShared);
51019: sqlite3_mutex_leave(mutexOpen);
51020: sqlite3_free(zFullPathname);
51021: sqlite3_free(p);
51022: return SQLITE_CONSTRAINT;
51023: }
51024: }
51025: p->pBt = pBt;
51026: pBt->nRef++;
51027: break;
51028: }
51029: }
51030: sqlite3_mutex_leave(mutexShared);
51031: sqlite3_free(zFullPathname);
51032: }
51033: #ifdef SQLITE_DEBUG
51034: else{
51035: /* In debug mode, we mark all persistent databases as sharable
51036: ** even when they are not. This exercises the locking code and
51037: ** gives more opportunity for asserts(sqlite3_mutex_held())
51038: ** statements to find locking problems.
51039: */
51040: p->sharable = 1;
51041: }
51042: #endif
51043: }
51044: #endif
51045: if( pBt==0 ){
51046: /*
51047: ** The following asserts make sure that structures used by the btree are
51048: ** the right size. This is to guard against size changes that result
51049: ** when compiling on a different architecture.
51050: */
51051: assert( sizeof(i64)==8 || sizeof(i64)==4 );
51052: assert( sizeof(u64)==8 || sizeof(u64)==4 );
51053: assert( sizeof(u32)==4 );
51054: assert( sizeof(u16)==2 );
51055: assert( sizeof(Pgno)==4 );
51056:
51057: pBt = sqlite3MallocZero( sizeof(*pBt) );
51058: if( pBt==0 ){
51059: rc = SQLITE_NOMEM;
51060: goto btree_open_out;
51061: }
51062: rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
51063: EXTRA_SIZE, flags, vfsFlags, pageReinit);
51064: if( rc==SQLITE_OK ){
51065: rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
51066: }
51067: if( rc!=SQLITE_OK ){
51068: goto btree_open_out;
51069: }
51070: pBt->openFlags = (u8)flags;
51071: pBt->db = db;
51072: sqlite3PagerSetBusyhandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
51073: p->pBt = pBt;
51074:
51075: pBt->pCursor = 0;
51076: pBt->pPage1 = 0;
51077: if( sqlite3PagerIsreadonly(pBt->pPager) ) pBt->btsFlags |= BTS_READ_ONLY;
51078: #ifdef SQLITE_SECURE_DELETE
51079: pBt->btsFlags |= BTS_SECURE_DELETE;
51080: #endif
51081: pBt->pageSize = (zDbHeader[16]<<8) | (zDbHeader[17]<<16);
51082: if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
51083: || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
51084: pBt->pageSize = 0;
51085: #ifndef SQLITE_OMIT_AUTOVACUUM
51086: /* If the magic name ":memory:" will create an in-memory database, then
51087: ** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
51088: ** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if
51089: ** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a
51090: ** regular file-name. In this case the auto-vacuum applies as per normal.
51091: */
51092: if( zFilename && !isMemdb ){
51093: pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0);
51094: pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
51095: }
51096: #endif
51097: nReserve = 0;
51098: }else{
51099: nReserve = zDbHeader[20];
51100: pBt->btsFlags |= BTS_PAGESIZE_FIXED;
51101: #ifndef SQLITE_OMIT_AUTOVACUUM
51102: pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
51103: pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
51104: #endif
51105: }
51106: rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
51107: if( rc ) goto btree_open_out;
51108: pBt->usableSize = pBt->pageSize - nReserve;
51109: assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
51110:
51111: #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
51112: /* Add the new BtShared object to the linked list sharable BtShareds.
51113: */
51114: if( p->sharable ){
51115: MUTEX_LOGIC( sqlite3_mutex *mutexShared; )
51116: pBt->nRef = 1;
51117: MUTEX_LOGIC( mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);)
51118: if( SQLITE_THREADSAFE && sqlite3GlobalConfig.bCoreMutex ){
51119: pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
51120: if( pBt->mutex==0 ){
51121: rc = SQLITE_NOMEM;
51122: db->mallocFailed = 0;
51123: goto btree_open_out;
51124: }
51125: }
51126: sqlite3_mutex_enter(mutexShared);
51127: pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
51128: GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt;
51129: sqlite3_mutex_leave(mutexShared);
51130: }
51131: #endif
51132: }
51133:
51134: #if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
51135: /* If the new Btree uses a sharable pBtShared, then link the new
51136: ** Btree into the list of all sharable Btrees for the same connection.
51137: ** The list is kept in ascending order by pBt address.
51138: */
51139: if( p->sharable ){
51140: int i;
51141: Btree *pSib;
51142: for(i=0; i<db->nDb; i++){
51143: if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
51144: while( pSib->pPrev ){ pSib = pSib->pPrev; }
51145: if( p->pBt<pSib->pBt ){
51146: p->pNext = pSib;
51147: p->pPrev = 0;
51148: pSib->pPrev = p;
51149: }else{
51150: while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
51151: pSib = pSib->pNext;
51152: }
51153: p->pNext = pSib->pNext;
51154: p->pPrev = pSib;
51155: if( p->pNext ){
51156: p->pNext->pPrev = p;
51157: }
51158: pSib->pNext = p;
51159: }
51160: break;
51161: }
51162: }
51163: }
51164: #endif
51165: *ppBtree = p;
51166:
51167: btree_open_out:
51168: if( rc!=SQLITE_OK ){
51169: if( pBt && pBt->pPager ){
51170: sqlite3PagerClose(pBt->pPager);
51171: }
51172: sqlite3_free(pBt);
51173: sqlite3_free(p);
51174: *ppBtree = 0;
51175: }else{
51176: /* If the B-Tree was successfully opened, set the pager-cache size to the
51177: ** default value. Except, when opening on an existing shared pager-cache,
51178: ** do not change the pager-cache size.
51179: */
51180: if( sqlite3BtreeSchema(p, 0, 0)==0 ){
51181: sqlite3PagerSetCachesize(p->pBt->pPager, SQLITE_DEFAULT_CACHE_SIZE);
51182: }
51183: }
51184: if( mutexOpen ){
51185: assert( sqlite3_mutex_held(mutexOpen) );
51186: sqlite3_mutex_leave(mutexOpen);
51187: }
51188: return rc;
51189: }
51190:
51191: /*
51192: ** Decrement the BtShared.nRef counter. When it reaches zero,
51193: ** remove the BtShared structure from the sharing list. Return
51194: ** true if the BtShared.nRef counter reaches zero and return
51195: ** false if it is still positive.
51196: */
51197: static int removeFromSharingList(BtShared *pBt){
51198: #ifndef SQLITE_OMIT_SHARED_CACHE
51199: MUTEX_LOGIC( sqlite3_mutex *pMaster; )
51200: BtShared *pList;
51201: int removed = 0;
51202:
51203: assert( sqlite3_mutex_notheld(pBt->mutex) );
51204: MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
51205: sqlite3_mutex_enter(pMaster);
51206: pBt->nRef--;
51207: if( pBt->nRef<=0 ){
51208: if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){
51209: GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
51210: }else{
51211: pList = GLOBAL(BtShared*,sqlite3SharedCacheList);
51212: while( ALWAYS(pList) && pList->pNext!=pBt ){
51213: pList=pList->pNext;
51214: }
51215: if( ALWAYS(pList) ){
51216: pList->pNext = pBt->pNext;
51217: }
51218: }
51219: if( SQLITE_THREADSAFE ){
51220: sqlite3_mutex_free(pBt->mutex);
51221: }
51222: removed = 1;
51223: }
51224: sqlite3_mutex_leave(pMaster);
51225: return removed;
51226: #else
51227: return 1;
51228: #endif
51229: }
51230:
51231: /*
51232: ** Make sure pBt->pTmpSpace points to an allocation of
51233: ** MX_CELL_SIZE(pBt) bytes.
51234: */
51235: static void allocateTempSpace(BtShared *pBt){
51236: if( !pBt->pTmpSpace ){
51237: pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize );
51238: }
51239: }
51240:
51241: /*
51242: ** Free the pBt->pTmpSpace allocation
51243: */
51244: static void freeTempSpace(BtShared *pBt){
51245: sqlite3PageFree( pBt->pTmpSpace);
51246: pBt->pTmpSpace = 0;
51247: }
51248:
51249: /*
51250: ** Close an open database and invalidate all cursors.
51251: */
51252: SQLITE_PRIVATE int sqlite3BtreeClose(Btree *p){
51253: BtShared *pBt = p->pBt;
51254: BtCursor *pCur;
51255:
51256: /* Close all cursors opened via this handle. */
51257: assert( sqlite3_mutex_held(p->db->mutex) );
51258: sqlite3BtreeEnter(p);
51259: pCur = pBt->pCursor;
51260: while( pCur ){
51261: BtCursor *pTmp = pCur;
51262: pCur = pCur->pNext;
51263: if( pTmp->pBtree==p ){
51264: sqlite3BtreeCloseCursor(pTmp);
51265: }
51266: }
51267:
51268: /* Rollback any active transaction and free the handle structure.
51269: ** The call to sqlite3BtreeRollback() drops any table-locks held by
51270: ** this handle.
51271: */
51272: sqlite3BtreeRollback(p);
51273: sqlite3BtreeLeave(p);
51274:
51275: /* If there are still other outstanding references to the shared-btree
51276: ** structure, return now. The remainder of this procedure cleans
51277: ** up the shared-btree.
51278: */
51279: assert( p->wantToLock==0 && p->locked==0 );
51280: if( !p->sharable || removeFromSharingList(pBt) ){
51281: /* The pBt is no longer on the sharing list, so we can access
51282: ** it without having to hold the mutex.
51283: **
51284: ** Clean out and delete the BtShared object.
51285: */
51286: assert( !pBt->pCursor );
51287: sqlite3PagerClose(pBt->pPager);
51288: if( pBt->xFreeSchema && pBt->pSchema ){
51289: pBt->xFreeSchema(pBt->pSchema);
51290: }
51291: sqlite3DbFree(0, pBt->pSchema);
51292: freeTempSpace(pBt);
51293: sqlite3_free(pBt);
51294: }
51295:
51296: #ifndef SQLITE_OMIT_SHARED_CACHE
51297: assert( p->wantToLock==0 );
51298: assert( p->locked==0 );
51299: if( p->pPrev ) p->pPrev->pNext = p->pNext;
51300: if( p->pNext ) p->pNext->pPrev = p->pPrev;
51301: #endif
51302:
51303: sqlite3_free(p);
51304: return SQLITE_OK;
51305: }
51306:
51307: /*
51308: ** Change the limit on the number of pages allowed in the cache.
51309: **
51310: ** The maximum number of cache pages is set to the absolute
51311: ** value of mxPage. If mxPage is negative, the pager will
51312: ** operate asynchronously - it will not stop to do fsync()s
51313: ** to insure data is written to the disk surface before
51314: ** continuing. Transactions still work if synchronous is off,
51315: ** and the database cannot be corrupted if this program
51316: ** crashes. But if the operating system crashes or there is
51317: ** an abrupt power failure when synchronous is off, the database
51318: ** could be left in an inconsistent and unrecoverable state.
51319: ** Synchronous is on by default so database corruption is not
51320: ** normally a worry.
51321: */
51322: SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){
51323: BtShared *pBt = p->pBt;
51324: assert( sqlite3_mutex_held(p->db->mutex) );
51325: sqlite3BtreeEnter(p);
51326: sqlite3PagerSetCachesize(pBt->pPager, mxPage);
51327: sqlite3BtreeLeave(p);
51328: return SQLITE_OK;
51329: }
51330:
51331: /*
51332: ** Change the way data is synced to disk in order to increase or decrease
51333: ** how well the database resists damage due to OS crashes and power
51334: ** failures. Level 1 is the same as asynchronous (no syncs() occur and
51335: ** there is a high probability of damage) Level 2 is the default. There
51336: ** is a very low but non-zero probability of damage. Level 3 reduces the
51337: ** probability of damage to near zero but with a write performance reduction.
51338: */
51339: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
51340: SQLITE_PRIVATE int sqlite3BtreeSetSafetyLevel(
51341: Btree *p, /* The btree to set the safety level on */
51342: int level, /* PRAGMA synchronous. 1=OFF, 2=NORMAL, 3=FULL */
51343: int fullSync, /* PRAGMA fullfsync. */
51344: int ckptFullSync /* PRAGMA checkpoint_fullfync */
51345: ){
51346: BtShared *pBt = p->pBt;
51347: assert( sqlite3_mutex_held(p->db->mutex) );
51348: assert( level>=1 && level<=3 );
51349: sqlite3BtreeEnter(p);
51350: sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync, ckptFullSync);
51351: sqlite3BtreeLeave(p);
51352: return SQLITE_OK;
51353: }
51354: #endif
51355:
51356: /*
51357: ** Return TRUE if the given btree is set to safety level 1. In other
51358: ** words, return TRUE if no sync() occurs on the disk files.
51359: */
51360: SQLITE_PRIVATE int sqlite3BtreeSyncDisabled(Btree *p){
51361: BtShared *pBt = p->pBt;
51362: int rc;
51363: assert( sqlite3_mutex_held(p->db->mutex) );
51364: sqlite3BtreeEnter(p);
51365: assert( pBt && pBt->pPager );
51366: rc = sqlite3PagerNosync(pBt->pPager);
51367: sqlite3BtreeLeave(p);
51368: return rc;
51369: }
51370:
51371: /*
51372: ** Change the default pages size and the number of reserved bytes per page.
51373: ** Or, if the page size has already been fixed, return SQLITE_READONLY
51374: ** without changing anything.
51375: **
51376: ** The page size must be a power of 2 between 512 and 65536. If the page
51377: ** size supplied does not meet this constraint then the page size is not
51378: ** changed.
51379: **
51380: ** Page sizes are constrained to be a power of two so that the region
51381: ** of the database file used for locking (beginning at PENDING_BYTE,
51382: ** the first byte past the 1GB boundary, 0x40000000) needs to occur
51383: ** at the beginning of a page.
51384: **
51385: ** If parameter nReserve is less than zero, then the number of reserved
51386: ** bytes per page is left unchanged.
51387: **
51388: ** If the iFix!=0 then the BTS_PAGESIZE_FIXED flag is set so that the page size
51389: ** and autovacuum mode can no longer be changed.
51390: */
51391: SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){
51392: int rc = SQLITE_OK;
51393: BtShared *pBt = p->pBt;
51394: assert( nReserve>=-1 && nReserve<=255 );
51395: sqlite3BtreeEnter(p);
51396: if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){
51397: sqlite3BtreeLeave(p);
51398: return SQLITE_READONLY;
51399: }
51400: if( nReserve<0 ){
51401: nReserve = pBt->pageSize - pBt->usableSize;
51402: }
51403: assert( nReserve>=0 && nReserve<=255 );
51404: if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE &&
51405: ((pageSize-1)&pageSize)==0 ){
51406: assert( (pageSize & 7)==0 );
51407: assert( !pBt->pPage1 && !pBt->pCursor );
51408: pBt->pageSize = (u32)pageSize;
51409: freeTempSpace(pBt);
51410: }
51411: rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
51412: pBt->usableSize = pBt->pageSize - (u16)nReserve;
51413: if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED;
51414: sqlite3BtreeLeave(p);
51415: return rc;
51416: }
51417:
51418: /*
51419: ** Return the currently defined page size
51420: */
51421: SQLITE_PRIVATE int sqlite3BtreeGetPageSize(Btree *p){
51422: return p->pBt->pageSize;
51423: }
51424:
51425: #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM)
51426: /*
51427: ** Return the number of bytes of space at the end of every page that
51428: ** are intentually left unused. This is the "reserved" space that is
51429: ** sometimes used by extensions.
51430: */
51431: SQLITE_PRIVATE int sqlite3BtreeGetReserve(Btree *p){
51432: int n;
51433: sqlite3BtreeEnter(p);
51434: n = p->pBt->pageSize - p->pBt->usableSize;
51435: sqlite3BtreeLeave(p);
51436: return n;
51437: }
51438:
51439: /*
51440: ** Set the maximum page count for a database if mxPage is positive.
51441: ** No changes are made if mxPage is 0 or negative.
51442: ** Regardless of the value of mxPage, return the maximum page count.
51443: */
51444: SQLITE_PRIVATE int sqlite3BtreeMaxPageCount(Btree *p, int mxPage){
51445: int n;
51446: sqlite3BtreeEnter(p);
51447: n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
51448: sqlite3BtreeLeave(p);
51449: return n;
51450: }
51451:
51452: /*
51453: ** Set the BTS_SECURE_DELETE flag if newFlag is 0 or 1. If newFlag is -1,
51454: ** then make no changes. Always return the value of the BTS_SECURE_DELETE
51455: ** setting after the change.
51456: */
51457: SQLITE_PRIVATE int sqlite3BtreeSecureDelete(Btree *p, int newFlag){
51458: int b;
51459: if( p==0 ) return 0;
51460: sqlite3BtreeEnter(p);
51461: if( newFlag>=0 ){
51462: p->pBt->btsFlags &= ~BTS_SECURE_DELETE;
51463: if( newFlag ) p->pBt->btsFlags |= BTS_SECURE_DELETE;
51464: }
51465: b = (p->pBt->btsFlags & BTS_SECURE_DELETE)!=0;
51466: sqlite3BtreeLeave(p);
51467: return b;
51468: }
51469: #endif /* !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) */
51470:
51471: /*
51472: ** Change the 'auto-vacuum' property of the database. If the 'autoVacuum'
51473: ** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
51474: ** is disabled. The default value for the auto-vacuum property is
51475: ** determined by the SQLITE_DEFAULT_AUTOVACUUM macro.
51476: */
51477: SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){
51478: #ifdef SQLITE_OMIT_AUTOVACUUM
51479: return SQLITE_READONLY;
51480: #else
51481: BtShared *pBt = p->pBt;
51482: int rc = SQLITE_OK;
51483: u8 av = (u8)autoVacuum;
51484:
51485: sqlite3BtreeEnter(p);
51486: if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){
51487: rc = SQLITE_READONLY;
51488: }else{
51489: pBt->autoVacuum = av ?1:0;
51490: pBt->incrVacuum = av==2 ?1:0;
51491: }
51492: sqlite3BtreeLeave(p);
51493: return rc;
51494: #endif
51495: }
51496:
51497: /*
51498: ** Return the value of the 'auto-vacuum' property. If auto-vacuum is
51499: ** enabled 1 is returned. Otherwise 0.
51500: */
51501: SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *p){
51502: #ifdef SQLITE_OMIT_AUTOVACUUM
51503: return BTREE_AUTOVACUUM_NONE;
51504: #else
51505: int rc;
51506: sqlite3BtreeEnter(p);
51507: rc = (
51508: (!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
51509: (!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
51510: BTREE_AUTOVACUUM_INCR
51511: );
51512: sqlite3BtreeLeave(p);
51513: return rc;
51514: #endif
51515: }
51516:
51517:
51518: /*
51519: ** Get a reference to pPage1 of the database file. This will
51520: ** also acquire a readlock on that file.
51521: **
51522: ** SQLITE_OK is returned on success. If the file is not a
51523: ** well-formed database file, then SQLITE_CORRUPT is returned.
51524: ** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM
51525: ** is returned if we run out of memory.
51526: */
51527: static int lockBtree(BtShared *pBt){
51528: int rc; /* Result code from subfunctions */
51529: MemPage *pPage1; /* Page 1 of the database file */
51530: int nPage; /* Number of pages in the database */
51531: int nPageFile = 0; /* Number of pages in the database file */
51532: int nPageHeader; /* Number of pages in the database according to hdr */
51533:
51534: assert( sqlite3_mutex_held(pBt->mutex) );
51535: assert( pBt->pPage1==0 );
51536: rc = sqlite3PagerSharedLock(pBt->pPager);
51537: if( rc!=SQLITE_OK ) return rc;
51538: rc = btreeGetPage(pBt, 1, &pPage1, 0);
51539: if( rc!=SQLITE_OK ) return rc;
51540:
51541: /* Do some checking to help insure the file we opened really is
51542: ** a valid database file.
51543: */
51544: nPage = nPageHeader = get4byte(28+(u8*)pPage1->aData);
51545: sqlite3PagerPagecount(pBt->pPager, &nPageFile);
51546: if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
51547: nPage = nPageFile;
51548: }
51549: if( nPage>0 ){
51550: u32 pageSize;
51551: u32 usableSize;
51552: u8 *page1 = pPage1->aData;
51553: rc = SQLITE_NOTADB;
51554: if( memcmp(page1, zMagicHeader, 16)!=0 ){
51555: goto page1_init_failed;
51556: }
51557:
51558: #ifdef SQLITE_OMIT_WAL
51559: if( page1[18]>1 ){
51560: pBt->btsFlags |= BTS_READ_ONLY;
51561: }
51562: if( page1[19]>1 ){
51563: goto page1_init_failed;
51564: }
51565: #else
51566: if( page1[18]>2 ){
51567: pBt->btsFlags |= BTS_READ_ONLY;
51568: }
51569: if( page1[19]>2 ){
51570: goto page1_init_failed;
51571: }
51572:
51573: /* If the write version is set to 2, this database should be accessed
51574: ** in WAL mode. If the log is not already open, open it now. Then
51575: ** return SQLITE_OK and return without populating BtShared.pPage1.
51576: ** The caller detects this and calls this function again. This is
51577: ** required as the version of page 1 currently in the page1 buffer
51578: ** may not be the latest version - there may be a newer one in the log
51579: ** file.
51580: */
51581: if( page1[19]==2 && (pBt->btsFlags & BTS_NO_WAL)==0 ){
51582: int isOpen = 0;
51583: rc = sqlite3PagerOpenWal(pBt->pPager, &isOpen);
51584: if( rc!=SQLITE_OK ){
51585: goto page1_init_failed;
51586: }else if( isOpen==0 ){
51587: releasePage(pPage1);
51588: return SQLITE_OK;
51589: }
51590: rc = SQLITE_NOTADB;
51591: }
51592: #endif
51593:
51594: /* The maximum embedded fraction must be exactly 25%. And the minimum
51595: ** embedded fraction must be 12.5% for both leaf-data and non-leaf-data.
51596: ** The original design allowed these amounts to vary, but as of
51597: ** version 3.6.0, we require them to be fixed.
51598: */
51599: if( memcmp(&page1[21], "\100\040\040",3)!=0 ){
51600: goto page1_init_failed;
51601: }
51602: pageSize = (page1[16]<<8) | (page1[17]<<16);
51603: if( ((pageSize-1)&pageSize)!=0
51604: || pageSize>SQLITE_MAX_PAGE_SIZE
51605: || pageSize<=256
51606: ){
51607: goto page1_init_failed;
51608: }
51609: assert( (pageSize & 7)==0 );
51610: usableSize = pageSize - page1[20];
51611: if( (u32)pageSize!=pBt->pageSize ){
51612: /* After reading the first page of the database assuming a page size
51613: ** of BtShared.pageSize, we have discovered that the page-size is
51614: ** actually pageSize. Unlock the database, leave pBt->pPage1 at
51615: ** zero and return SQLITE_OK. The caller will call this function
51616: ** again with the correct page-size.
51617: */
51618: releasePage(pPage1);
51619: pBt->usableSize = usableSize;
51620: pBt->pageSize = pageSize;
51621: freeTempSpace(pBt);
51622: rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize,
51623: pageSize-usableSize);
51624: return rc;
51625: }
51626: if( (pBt->db->flags & SQLITE_RecoveryMode)==0 && nPage>nPageFile ){
51627: rc = SQLITE_CORRUPT_BKPT;
51628: goto page1_init_failed;
51629: }
51630: if( usableSize<480 ){
51631: goto page1_init_failed;
51632: }
51633: pBt->pageSize = pageSize;
51634: pBt->usableSize = usableSize;
51635: #ifndef SQLITE_OMIT_AUTOVACUUM
51636: pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
51637: pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
51638: #endif
51639: }
51640:
51641: /* maxLocal is the maximum amount of payload to store locally for
51642: ** a cell. Make sure it is small enough so that at least minFanout
51643: ** cells can will fit on one page. We assume a 10-byte page header.
51644: ** Besides the payload, the cell must store:
51645: ** 2-byte pointer to the cell
51646: ** 4-byte child pointer
51647: ** 9-byte nKey value
51648: ** 4-byte nData value
51649: ** 4-byte overflow page pointer
51650: ** So a cell consists of a 2-byte pointer, a header which is as much as
51651: ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
51652: ** page pointer.
51653: */
51654: pBt->maxLocal = (u16)((pBt->usableSize-12)*64/255 - 23);
51655: pBt->minLocal = (u16)((pBt->usableSize-12)*32/255 - 23);
51656: pBt->maxLeaf = (u16)(pBt->usableSize - 35);
51657: pBt->minLeaf = (u16)((pBt->usableSize-12)*32/255 - 23);
51658: if( pBt->maxLocal>127 ){
51659: pBt->max1bytePayload = 127;
51660: }else{
51661: pBt->max1bytePayload = (u8)pBt->maxLocal;
51662: }
51663: assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
51664: pBt->pPage1 = pPage1;
51665: pBt->nPage = nPage;
51666: return SQLITE_OK;
51667:
51668: page1_init_failed:
51669: releasePage(pPage1);
51670: pBt->pPage1 = 0;
51671: return rc;
51672: }
51673:
51674: /*
51675: ** If there are no outstanding cursors and we are not in the middle
51676: ** of a transaction but there is a read lock on the database, then
51677: ** this routine unrefs the first page of the database file which
51678: ** has the effect of releasing the read lock.
51679: **
51680: ** If there is a transaction in progress, this routine is a no-op.
51681: */
51682: static void unlockBtreeIfUnused(BtShared *pBt){
51683: assert( sqlite3_mutex_held(pBt->mutex) );
51684: assert( pBt->pCursor==0 || pBt->inTransaction>TRANS_NONE );
51685: if( pBt->inTransaction==TRANS_NONE && pBt->pPage1!=0 ){
51686: assert( pBt->pPage1->aData );
51687: assert( sqlite3PagerRefcount(pBt->pPager)==1 );
51688: assert( pBt->pPage1->aData );
51689: releasePage(pBt->pPage1);
51690: pBt->pPage1 = 0;
51691: }
51692: }
51693:
51694: /*
51695: ** If pBt points to an empty file then convert that empty file
51696: ** into a new empty database by initializing the first page of
51697: ** the database.
51698: */
51699: static int newDatabase(BtShared *pBt){
51700: MemPage *pP1;
51701: unsigned char *data;
51702: int rc;
51703:
51704: assert( sqlite3_mutex_held(pBt->mutex) );
51705: if( pBt->nPage>0 ){
51706: return SQLITE_OK;
51707: }
51708: pP1 = pBt->pPage1;
51709: assert( pP1!=0 );
51710: data = pP1->aData;
51711: rc = sqlite3PagerWrite(pP1->pDbPage);
51712: if( rc ) return rc;
51713: memcpy(data, zMagicHeader, sizeof(zMagicHeader));
51714: assert( sizeof(zMagicHeader)==16 );
51715: data[16] = (u8)((pBt->pageSize>>8)&0xff);
51716: data[17] = (u8)((pBt->pageSize>>16)&0xff);
51717: data[18] = 1;
51718: data[19] = 1;
51719: assert( pBt->usableSize<=pBt->pageSize && pBt->usableSize+255>=pBt->pageSize);
51720: data[20] = (u8)(pBt->pageSize - pBt->usableSize);
51721: data[21] = 64;
51722: data[22] = 32;
51723: data[23] = 32;
51724: memset(&data[24], 0, 100-24);
51725: zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA );
51726: pBt->btsFlags |= BTS_PAGESIZE_FIXED;
51727: #ifndef SQLITE_OMIT_AUTOVACUUM
51728: assert( pBt->autoVacuum==1 || pBt->autoVacuum==0 );
51729: assert( pBt->incrVacuum==1 || pBt->incrVacuum==0 );
51730: put4byte(&data[36 + 4*4], pBt->autoVacuum);
51731: put4byte(&data[36 + 7*4], pBt->incrVacuum);
51732: #endif
51733: pBt->nPage = 1;
51734: data[31] = 1;
51735: return SQLITE_OK;
51736: }
51737:
51738: /*
51739: ** Attempt to start a new transaction. A write-transaction
51740: ** is started if the second argument is nonzero, otherwise a read-
51741: ** transaction. If the second argument is 2 or more and exclusive
51742: ** transaction is started, meaning that no other process is allowed
51743: ** to access the database. A preexisting transaction may not be
51744: ** upgraded to exclusive by calling this routine a second time - the
51745: ** exclusivity flag only works for a new transaction.
51746: **
51747: ** A write-transaction must be started before attempting any
51748: ** changes to the database. None of the following routines
51749: ** will work unless a transaction is started first:
51750: **
51751: ** sqlite3BtreeCreateTable()
51752: ** sqlite3BtreeCreateIndex()
51753: ** sqlite3BtreeClearTable()
51754: ** sqlite3BtreeDropTable()
51755: ** sqlite3BtreeInsert()
51756: ** sqlite3BtreeDelete()
51757: ** sqlite3BtreeUpdateMeta()
51758: **
51759: ** If an initial attempt to acquire the lock fails because of lock contention
51760: ** and the database was previously unlocked, then invoke the busy handler
51761: ** if there is one. But if there was previously a read-lock, do not
51762: ** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is
51763: ** returned when there is already a read-lock in order to avoid a deadlock.
51764: **
51765: ** Suppose there are two processes A and B. A has a read lock and B has
51766: ** a reserved lock. B tries to promote to exclusive but is blocked because
51767: ** of A's read lock. A tries to promote to reserved but is blocked by B.
51768: ** One or the other of the two processes must give way or there can be
51769: ** no progress. By returning SQLITE_BUSY and not invoking the busy callback
51770: ** when A already has a read lock, we encourage A to give up and let B
51771: ** proceed.
51772: */
51773: SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag){
51774: sqlite3 *pBlock = 0;
51775: BtShared *pBt = p->pBt;
51776: int rc = SQLITE_OK;
51777:
51778: sqlite3BtreeEnter(p);
51779: btreeIntegrity(p);
51780:
51781: /* If the btree is already in a write-transaction, or it
51782: ** is already in a read-transaction and a read-transaction
51783: ** is requested, this is a no-op.
51784: */
51785: if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){
51786: goto trans_begun;
51787: }
51788:
51789: /* Write transactions are not possible on a read-only database */
51790: if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){
51791: rc = SQLITE_READONLY;
51792: goto trans_begun;
51793: }
51794:
51795: #ifndef SQLITE_OMIT_SHARED_CACHE
51796: /* If another database handle has already opened a write transaction
51797: ** on this shared-btree structure and a second write transaction is
51798: ** requested, return SQLITE_LOCKED.
51799: */
51800: if( (wrflag && pBt->inTransaction==TRANS_WRITE)
51801: || (pBt->btsFlags & BTS_PENDING)!=0
51802: ){
51803: pBlock = pBt->pWriter->db;
51804: }else if( wrflag>1 ){
51805: BtLock *pIter;
51806: for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
51807: if( pIter->pBtree!=p ){
51808: pBlock = pIter->pBtree->db;
51809: break;
51810: }
51811: }
51812: }
51813: if( pBlock ){
51814: sqlite3ConnectionBlocked(p->db, pBlock);
51815: rc = SQLITE_LOCKED_SHAREDCACHE;
51816: goto trans_begun;
51817: }
51818: #endif
51819:
51820: /* Any read-only or read-write transaction implies a read-lock on
51821: ** page 1. So if some other shared-cache client already has a write-lock
51822: ** on page 1, the transaction cannot be opened. */
51823: rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
51824: if( SQLITE_OK!=rc ) goto trans_begun;
51825:
51826: pBt->btsFlags &= ~BTS_INITIALLY_EMPTY;
51827: if( pBt->nPage==0 ) pBt->btsFlags |= BTS_INITIALLY_EMPTY;
51828: do {
51829: /* Call lockBtree() until either pBt->pPage1 is populated or
51830: ** lockBtree() returns something other than SQLITE_OK. lockBtree()
51831: ** may return SQLITE_OK but leave pBt->pPage1 set to 0 if after
51832: ** reading page 1 it discovers that the page-size of the database
51833: ** file is not pBt->pageSize. In this case lockBtree() will update
51834: ** pBt->pageSize to the page-size of the file on disk.
51835: */
51836: while( pBt->pPage1==0 && SQLITE_OK==(rc = lockBtree(pBt)) );
51837:
51838: if( rc==SQLITE_OK && wrflag ){
51839: if( (pBt->btsFlags & BTS_READ_ONLY)!=0 ){
51840: rc = SQLITE_READONLY;
51841: }else{
51842: rc = sqlite3PagerBegin(pBt->pPager,wrflag>1,sqlite3TempInMemory(p->db));
51843: if( rc==SQLITE_OK ){
51844: rc = newDatabase(pBt);
51845: }
51846: }
51847: }
51848:
51849: if( rc!=SQLITE_OK ){
51850: unlockBtreeIfUnused(pBt);
51851: }
51852: }while( (rc&0xFF)==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
51853: btreeInvokeBusyHandler(pBt) );
51854:
51855: if( rc==SQLITE_OK ){
51856: if( p->inTrans==TRANS_NONE ){
51857: pBt->nTransaction++;
51858: #ifndef SQLITE_OMIT_SHARED_CACHE
51859: if( p->sharable ){
51860: assert( p->lock.pBtree==p && p->lock.iTable==1 );
51861: p->lock.eLock = READ_LOCK;
51862: p->lock.pNext = pBt->pLock;
51863: pBt->pLock = &p->lock;
51864: }
51865: #endif
51866: }
51867: p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
51868: if( p->inTrans>pBt->inTransaction ){
51869: pBt->inTransaction = p->inTrans;
51870: }
51871: if( wrflag ){
51872: MemPage *pPage1 = pBt->pPage1;
51873: #ifndef SQLITE_OMIT_SHARED_CACHE
51874: assert( !pBt->pWriter );
51875: pBt->pWriter = p;
51876: pBt->btsFlags &= ~BTS_EXCLUSIVE;
51877: if( wrflag>1 ) pBt->btsFlags |= BTS_EXCLUSIVE;
51878: #endif
51879:
51880: /* If the db-size header field is incorrect (as it may be if an old
51881: ** client has been writing the database file), update it now. Doing
51882: ** this sooner rather than later means the database size can safely
51883: ** re-read the database size from page 1 if a savepoint or transaction
51884: ** rollback occurs within the transaction.
51885: */
51886: if( pBt->nPage!=get4byte(&pPage1->aData[28]) ){
51887: rc = sqlite3PagerWrite(pPage1->pDbPage);
51888: if( rc==SQLITE_OK ){
51889: put4byte(&pPage1->aData[28], pBt->nPage);
51890: }
51891: }
51892: }
51893: }
51894:
51895:
51896: trans_begun:
51897: if( rc==SQLITE_OK && wrflag ){
51898: /* This call makes sure that the pager has the correct number of
51899: ** open savepoints. If the second parameter is greater than 0 and
51900: ** the sub-journal is not already open, then it will be opened here.
51901: */
51902: rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
51903: }
51904:
51905: btreeIntegrity(p);
51906: sqlite3BtreeLeave(p);
51907: return rc;
51908: }
51909:
51910: #ifndef SQLITE_OMIT_AUTOVACUUM
51911:
51912: /*
51913: ** Set the pointer-map entries for all children of page pPage. Also, if
51914: ** pPage contains cells that point to overflow pages, set the pointer
51915: ** map entries for the overflow pages as well.
51916: */
51917: static int setChildPtrmaps(MemPage *pPage){
51918: int i; /* Counter variable */
51919: int nCell; /* Number of cells in page pPage */
51920: int rc; /* Return code */
51921: BtShared *pBt = pPage->pBt;
51922: u8 isInitOrig = pPage->isInit;
51923: Pgno pgno = pPage->pgno;
51924:
51925: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
51926: rc = btreeInitPage(pPage);
51927: if( rc!=SQLITE_OK ){
51928: goto set_child_ptrmaps_out;
51929: }
51930: nCell = pPage->nCell;
51931:
51932: for(i=0; i<nCell; i++){
51933: u8 *pCell = findCell(pPage, i);
51934:
51935: ptrmapPutOvflPtr(pPage, pCell, &rc);
51936:
51937: if( !pPage->leaf ){
51938: Pgno childPgno = get4byte(pCell);
51939: ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
51940: }
51941: }
51942:
51943: if( !pPage->leaf ){
51944: Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
51945: ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno, &rc);
51946: }
51947:
51948: set_child_ptrmaps_out:
51949: pPage->isInit = isInitOrig;
51950: return rc;
51951: }
51952:
51953: /*
51954: ** Somewhere on pPage is a pointer to page iFrom. Modify this pointer so
51955: ** that it points to iTo. Parameter eType describes the type of pointer to
51956: ** be modified, as follows:
51957: **
51958: ** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child
51959: ** page of pPage.
51960: **
51961: ** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
51962: ** page pointed to by one of the cells on pPage.
51963: **
51964: ** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
51965: ** overflow page in the list.
51966: */
51967: static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
51968: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
51969: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
51970: if( eType==PTRMAP_OVERFLOW2 ){
51971: /* The pointer is always the first 4 bytes of the page in this case. */
51972: if( get4byte(pPage->aData)!=iFrom ){
51973: return SQLITE_CORRUPT_BKPT;
51974: }
51975: put4byte(pPage->aData, iTo);
51976: }else{
51977: u8 isInitOrig = pPage->isInit;
51978: int i;
51979: int nCell;
51980:
51981: btreeInitPage(pPage);
51982: nCell = pPage->nCell;
51983:
51984: for(i=0; i<nCell; i++){
51985: u8 *pCell = findCell(pPage, i);
51986: if( eType==PTRMAP_OVERFLOW1 ){
51987: CellInfo info;
51988: btreeParseCellPtr(pPage, pCell, &info);
51989: if( info.iOverflow
51990: && pCell+info.iOverflow+3<=pPage->aData+pPage->maskPage
51991: && iFrom==get4byte(&pCell[info.iOverflow])
51992: ){
51993: put4byte(&pCell[info.iOverflow], iTo);
51994: break;
51995: }
51996: }else{
51997: if( get4byte(pCell)==iFrom ){
51998: put4byte(pCell, iTo);
51999: break;
52000: }
52001: }
52002: }
52003:
52004: if( i==nCell ){
52005: if( eType!=PTRMAP_BTREE ||
52006: get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
52007: return SQLITE_CORRUPT_BKPT;
52008: }
52009: put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
52010: }
52011:
52012: pPage->isInit = isInitOrig;
52013: }
52014: return SQLITE_OK;
52015: }
52016:
52017:
52018: /*
52019: ** Move the open database page pDbPage to location iFreePage in the
52020: ** database. The pDbPage reference remains valid.
52021: **
52022: ** The isCommit flag indicates that there is no need to remember that
52023: ** the journal needs to be sync()ed before database page pDbPage->pgno
52024: ** can be written to. The caller has already promised not to write to that
52025: ** page.
52026: */
52027: static int relocatePage(
52028: BtShared *pBt, /* Btree */
52029: MemPage *pDbPage, /* Open page to move */
52030: u8 eType, /* Pointer map 'type' entry for pDbPage */
52031: Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
52032: Pgno iFreePage, /* The location to move pDbPage to */
52033: int isCommit /* isCommit flag passed to sqlite3PagerMovepage */
52034: ){
52035: MemPage *pPtrPage; /* The page that contains a pointer to pDbPage */
52036: Pgno iDbPage = pDbPage->pgno;
52037: Pager *pPager = pBt->pPager;
52038: int rc;
52039:
52040: assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 ||
52041: eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE );
52042: assert( sqlite3_mutex_held(pBt->mutex) );
52043: assert( pDbPage->pBt==pBt );
52044:
52045: /* Move page iDbPage from its current location to page number iFreePage */
52046: TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n",
52047: iDbPage, iFreePage, iPtrPage, eType));
52048: rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
52049: if( rc!=SQLITE_OK ){
52050: return rc;
52051: }
52052: pDbPage->pgno = iFreePage;
52053:
52054: /* If pDbPage was a btree-page, then it may have child pages and/or cells
52055: ** that point to overflow pages. The pointer map entries for all these
52056: ** pages need to be changed.
52057: **
52058: ** If pDbPage is an overflow page, then the first 4 bytes may store a
52059: ** pointer to a subsequent overflow page. If this is the case, then
52060: ** the pointer map needs to be updated for the subsequent overflow page.
52061: */
52062: if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){
52063: rc = setChildPtrmaps(pDbPage);
52064: if( rc!=SQLITE_OK ){
52065: return rc;
52066: }
52067: }else{
52068: Pgno nextOvfl = get4byte(pDbPage->aData);
52069: if( nextOvfl!=0 ){
52070: ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage, &rc);
52071: if( rc!=SQLITE_OK ){
52072: return rc;
52073: }
52074: }
52075: }
52076:
52077: /* Fix the database pointer on page iPtrPage that pointed at iDbPage so
52078: ** that it points at iFreePage. Also fix the pointer map entry for
52079: ** iPtrPage.
52080: */
52081: if( eType!=PTRMAP_ROOTPAGE ){
52082: rc = btreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
52083: if( rc!=SQLITE_OK ){
52084: return rc;
52085: }
52086: rc = sqlite3PagerWrite(pPtrPage->pDbPage);
52087: if( rc!=SQLITE_OK ){
52088: releasePage(pPtrPage);
52089: return rc;
52090: }
52091: rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType);
52092: releasePage(pPtrPage);
52093: if( rc==SQLITE_OK ){
52094: ptrmapPut(pBt, iFreePage, eType, iPtrPage, &rc);
52095: }
52096: }
52097: return rc;
52098: }
52099:
52100: /* Forward declaration required by incrVacuumStep(). */
52101: static int allocateBtreePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
52102:
52103: /*
52104: ** Perform a single step of an incremental-vacuum. If successful,
52105: ** return SQLITE_OK. If there is no work to do (and therefore no
52106: ** point in calling this function again), return SQLITE_DONE.
52107: **
52108: ** More specificly, this function attempts to re-organize the
52109: ** database so that the last page of the file currently in use
52110: ** is no longer in use.
52111: **
52112: ** If the nFin parameter is non-zero, this function assumes
52113: ** that the caller will keep calling incrVacuumStep() until
52114: ** it returns SQLITE_DONE or an error, and that nFin is the
52115: ** number of pages the database file will contain after this
52116: ** process is complete. If nFin is zero, it is assumed that
52117: ** incrVacuumStep() will be called a finite amount of times
52118: ** which may or may not empty the freelist. A full autovacuum
52119: ** has nFin>0. A "PRAGMA incremental_vacuum" has nFin==0.
52120: */
52121: static int incrVacuumStep(BtShared *pBt, Pgno nFin, Pgno iLastPg){
52122: Pgno nFreeList; /* Number of pages still on the free-list */
52123: int rc;
52124:
52125: assert( sqlite3_mutex_held(pBt->mutex) );
52126: assert( iLastPg>nFin );
52127:
52128: if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
52129: u8 eType;
52130: Pgno iPtrPage;
52131:
52132: nFreeList = get4byte(&pBt->pPage1->aData[36]);
52133: if( nFreeList==0 ){
52134: return SQLITE_DONE;
52135: }
52136:
52137: rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage);
52138: if( rc!=SQLITE_OK ){
52139: return rc;
52140: }
52141: if( eType==PTRMAP_ROOTPAGE ){
52142: return SQLITE_CORRUPT_BKPT;
52143: }
52144:
52145: if( eType==PTRMAP_FREEPAGE ){
52146: if( nFin==0 ){
52147: /* Remove the page from the files free-list. This is not required
52148: ** if nFin is non-zero. In that case, the free-list will be
52149: ** truncated to zero after this function returns, so it doesn't
52150: ** matter if it still contains some garbage entries.
52151: */
52152: Pgno iFreePg;
52153: MemPage *pFreePg;
52154: rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, 1);
52155: if( rc!=SQLITE_OK ){
52156: return rc;
52157: }
52158: assert( iFreePg==iLastPg );
52159: releasePage(pFreePg);
52160: }
52161: } else {
52162: Pgno iFreePg; /* Index of free page to move pLastPg to */
52163: MemPage *pLastPg;
52164:
52165: rc = btreeGetPage(pBt, iLastPg, &pLastPg, 0);
52166: if( rc!=SQLITE_OK ){
52167: return rc;
52168: }
52169:
52170: /* If nFin is zero, this loop runs exactly once and page pLastPg
52171: ** is swapped with the first free page pulled off the free list.
52172: **
52173: ** On the other hand, if nFin is greater than zero, then keep
52174: ** looping until a free-page located within the first nFin pages
52175: ** of the file is found.
52176: */
52177: do {
52178: MemPage *pFreePg;
52179: rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, 0, 0);
52180: if( rc!=SQLITE_OK ){
52181: releasePage(pLastPg);
52182: return rc;
52183: }
52184: releasePage(pFreePg);
52185: }while( nFin!=0 && iFreePg>nFin );
52186: assert( iFreePg<iLastPg );
52187:
52188: rc = sqlite3PagerWrite(pLastPg->pDbPage);
52189: if( rc==SQLITE_OK ){
52190: rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, nFin!=0);
52191: }
52192: releasePage(pLastPg);
52193: if( rc!=SQLITE_OK ){
52194: return rc;
52195: }
52196: }
52197: }
52198:
52199: if( nFin==0 ){
52200: iLastPg--;
52201: while( iLastPg==PENDING_BYTE_PAGE(pBt)||PTRMAP_ISPAGE(pBt, iLastPg) ){
52202: if( PTRMAP_ISPAGE(pBt, iLastPg) ){
52203: MemPage *pPg;
52204: rc = btreeGetPage(pBt, iLastPg, &pPg, 0);
52205: if( rc!=SQLITE_OK ){
52206: return rc;
52207: }
52208: rc = sqlite3PagerWrite(pPg->pDbPage);
52209: releasePage(pPg);
52210: if( rc!=SQLITE_OK ){
52211: return rc;
52212: }
52213: }
52214: iLastPg--;
52215: }
52216: sqlite3PagerTruncateImage(pBt->pPager, iLastPg);
52217: pBt->nPage = iLastPg;
52218: }
52219: return SQLITE_OK;
52220: }
52221:
52222: /*
52223: ** A write-transaction must be opened before calling this function.
52224: ** It performs a single unit of work towards an incremental vacuum.
52225: **
52226: ** If the incremental vacuum is finished after this function has run,
52227: ** SQLITE_DONE is returned. If it is not finished, but no error occurred,
52228: ** SQLITE_OK is returned. Otherwise an SQLite error code.
52229: */
52230: SQLITE_PRIVATE int sqlite3BtreeIncrVacuum(Btree *p){
52231: int rc;
52232: BtShared *pBt = p->pBt;
52233:
52234: sqlite3BtreeEnter(p);
52235: assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
52236: if( !pBt->autoVacuum ){
52237: rc = SQLITE_DONE;
52238: }else{
52239: invalidateAllOverflowCache(pBt);
52240: rc = incrVacuumStep(pBt, 0, btreePagecount(pBt));
52241: if( rc==SQLITE_OK ){
52242: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
52243: put4byte(&pBt->pPage1->aData[28], pBt->nPage);
52244: }
52245: }
52246: sqlite3BtreeLeave(p);
52247: return rc;
52248: }
52249:
52250: /*
52251: ** This routine is called prior to sqlite3PagerCommit when a transaction
52252: ** is commited for an auto-vacuum database.
52253: **
52254: ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
52255: ** the database file should be truncated to during the commit process.
52256: ** i.e. the database has been reorganized so that only the first *pnTrunc
52257: ** pages are in use.
52258: */
52259: static int autoVacuumCommit(BtShared *pBt){
52260: int rc = SQLITE_OK;
52261: Pager *pPager = pBt->pPager;
52262: VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager) );
52263:
52264: assert( sqlite3_mutex_held(pBt->mutex) );
52265: invalidateAllOverflowCache(pBt);
52266: assert(pBt->autoVacuum);
52267: if( !pBt->incrVacuum ){
52268: Pgno nFin; /* Number of pages in database after autovacuuming */
52269: Pgno nFree; /* Number of pages on the freelist initially */
52270: Pgno nPtrmap; /* Number of PtrMap pages to be freed */
52271: Pgno iFree; /* The next page to be freed */
52272: int nEntry; /* Number of entries on one ptrmap page */
52273: Pgno nOrig; /* Database size before freeing */
52274:
52275: nOrig = btreePagecount(pBt);
52276: if( PTRMAP_ISPAGE(pBt, nOrig) || nOrig==PENDING_BYTE_PAGE(pBt) ){
52277: /* It is not possible to create a database for which the final page
52278: ** is either a pointer-map page or the pending-byte page. If one
52279: ** is encountered, this indicates corruption.
52280: */
52281: return SQLITE_CORRUPT_BKPT;
52282: }
52283:
52284: nFree = get4byte(&pBt->pPage1->aData[36]);
52285: nEntry = pBt->usableSize/5;
52286: nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+nEntry)/nEntry;
52287: nFin = nOrig - nFree - nPtrmap;
52288: if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<PENDING_BYTE_PAGE(pBt) ){
52289: nFin--;
52290: }
52291: while( PTRMAP_ISPAGE(pBt, nFin) || nFin==PENDING_BYTE_PAGE(pBt) ){
52292: nFin--;
52293: }
52294: if( nFin>nOrig ) return SQLITE_CORRUPT_BKPT;
52295:
52296: for(iFree=nOrig; iFree>nFin && rc==SQLITE_OK; iFree--){
52297: rc = incrVacuumStep(pBt, nFin, iFree);
52298: }
52299: if( (rc==SQLITE_DONE || rc==SQLITE_OK) && nFree>0 ){
52300: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
52301: put4byte(&pBt->pPage1->aData[32], 0);
52302: put4byte(&pBt->pPage1->aData[36], 0);
52303: put4byte(&pBt->pPage1->aData[28], nFin);
52304: sqlite3PagerTruncateImage(pBt->pPager, nFin);
52305: pBt->nPage = nFin;
52306: }
52307: if( rc!=SQLITE_OK ){
52308: sqlite3PagerRollback(pPager);
52309: }
52310: }
52311:
52312: assert( nRef==sqlite3PagerRefcount(pPager) );
52313: return rc;
52314: }
52315:
52316: #else /* ifndef SQLITE_OMIT_AUTOVACUUM */
52317: # define setChildPtrmaps(x) SQLITE_OK
52318: #endif
52319:
52320: /*
52321: ** This routine does the first phase of a two-phase commit. This routine
52322: ** causes a rollback journal to be created (if it does not already exist)
52323: ** and populated with enough information so that if a power loss occurs
52324: ** the database can be restored to its original state by playing back
52325: ** the journal. Then the contents of the journal are flushed out to
52326: ** the disk. After the journal is safely on oxide, the changes to the
52327: ** database are written into the database file and flushed to oxide.
52328: ** At the end of this call, the rollback journal still exists on the
52329: ** disk and we are still holding all locks, so the transaction has not
52330: ** committed. See sqlite3BtreeCommitPhaseTwo() for the second phase of the
52331: ** commit process.
52332: **
52333: ** This call is a no-op if no write-transaction is currently active on pBt.
52334: **
52335: ** Otherwise, sync the database file for the btree pBt. zMaster points to
52336: ** the name of a master journal file that should be written into the
52337: ** individual journal file, or is NULL, indicating no master journal file
52338: ** (single database transaction).
52339: **
52340: ** When this is called, the master journal should already have been
52341: ** created, populated with this journal pointer and synced to disk.
52342: **
52343: ** Once this is routine has returned, the only thing required to commit
52344: ** the write-transaction for this database file is to delete the journal.
52345: */
52346: SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zMaster){
52347: int rc = SQLITE_OK;
52348: if( p->inTrans==TRANS_WRITE ){
52349: BtShared *pBt = p->pBt;
52350: sqlite3BtreeEnter(p);
52351: #ifndef SQLITE_OMIT_AUTOVACUUM
52352: if( pBt->autoVacuum ){
52353: rc = autoVacuumCommit(pBt);
52354: if( rc!=SQLITE_OK ){
52355: sqlite3BtreeLeave(p);
52356: return rc;
52357: }
52358: }
52359: #endif
52360: rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
52361: sqlite3BtreeLeave(p);
52362: }
52363: return rc;
52364: }
52365:
52366: /*
52367: ** This function is called from both BtreeCommitPhaseTwo() and BtreeRollback()
52368: ** at the conclusion of a transaction.
52369: */
52370: static void btreeEndTransaction(Btree *p){
52371: BtShared *pBt = p->pBt;
52372: assert( sqlite3BtreeHoldsMutex(p) );
52373:
52374: btreeClearHasContent(pBt);
52375: if( p->inTrans>TRANS_NONE && p->db->activeVdbeCnt>1 ){
52376: /* If there are other active statements that belong to this database
52377: ** handle, downgrade to a read-only transaction. The other statements
52378: ** may still be reading from the database. */
52379: downgradeAllSharedCacheTableLocks(p);
52380: p->inTrans = TRANS_READ;
52381: }else{
52382: /* If the handle had any kind of transaction open, decrement the
52383: ** transaction count of the shared btree. If the transaction count
52384: ** reaches 0, set the shared state to TRANS_NONE. The unlockBtreeIfUnused()
52385: ** call below will unlock the pager. */
52386: if( p->inTrans!=TRANS_NONE ){
52387: clearAllSharedCacheTableLocks(p);
52388: pBt->nTransaction--;
52389: if( 0==pBt->nTransaction ){
52390: pBt->inTransaction = TRANS_NONE;
52391: }
52392: }
52393:
52394: /* Set the current transaction state to TRANS_NONE and unlock the
52395: ** pager if this call closed the only read or write transaction. */
52396: p->inTrans = TRANS_NONE;
52397: unlockBtreeIfUnused(pBt);
52398: }
52399:
52400: btreeIntegrity(p);
52401: }
52402:
52403: /*
52404: ** Commit the transaction currently in progress.
52405: **
52406: ** This routine implements the second phase of a 2-phase commit. The
52407: ** sqlite3BtreeCommitPhaseOne() routine does the first phase and should
52408: ** be invoked prior to calling this routine. The sqlite3BtreeCommitPhaseOne()
52409: ** routine did all the work of writing information out to disk and flushing the
52410: ** contents so that they are written onto the disk platter. All this
52411: ** routine has to do is delete or truncate or zero the header in the
52412: ** the rollback journal (which causes the transaction to commit) and
52413: ** drop locks.
52414: **
52415: ** Normally, if an error occurs while the pager layer is attempting to
52416: ** finalize the underlying journal file, this function returns an error and
52417: ** the upper layer will attempt a rollback. However, if the second argument
52418: ** is non-zero then this b-tree transaction is part of a multi-file
52419: ** transaction. In this case, the transaction has already been committed
52420: ** (by deleting a master journal file) and the caller will ignore this
52421: ** functions return code. So, even if an error occurs in the pager layer,
52422: ** reset the b-tree objects internal state to indicate that the write
52423: ** transaction has been closed. This is quite safe, as the pager will have
52424: ** transitioned to the error state.
52425: **
52426: ** This will release the write lock on the database file. If there
52427: ** are no active cursors, it also releases the read lock.
52428: */
52429: SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){
52430:
52431: if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
52432: sqlite3BtreeEnter(p);
52433: btreeIntegrity(p);
52434:
52435: /* If the handle has a write-transaction open, commit the shared-btrees
52436: ** transaction and set the shared state to TRANS_READ.
52437: */
52438: if( p->inTrans==TRANS_WRITE ){
52439: int rc;
52440: BtShared *pBt = p->pBt;
52441: assert( pBt->inTransaction==TRANS_WRITE );
52442: assert( pBt->nTransaction>0 );
52443: rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
52444: if( rc!=SQLITE_OK && bCleanup==0 ){
52445: sqlite3BtreeLeave(p);
52446: return rc;
52447: }
52448: pBt->inTransaction = TRANS_READ;
52449: }
52450:
52451: btreeEndTransaction(p);
52452: sqlite3BtreeLeave(p);
52453: return SQLITE_OK;
52454: }
52455:
52456: /*
52457: ** Do both phases of a commit.
52458: */
52459: SQLITE_PRIVATE int sqlite3BtreeCommit(Btree *p){
52460: int rc;
52461: sqlite3BtreeEnter(p);
52462: rc = sqlite3BtreeCommitPhaseOne(p, 0);
52463: if( rc==SQLITE_OK ){
52464: rc = sqlite3BtreeCommitPhaseTwo(p, 0);
52465: }
52466: sqlite3BtreeLeave(p);
52467: return rc;
52468: }
52469:
52470: #ifndef NDEBUG
52471: /*
52472: ** Return the number of write-cursors open on this handle. This is for use
52473: ** in assert() expressions, so it is only compiled if NDEBUG is not
52474: ** defined.
52475: **
52476: ** For the purposes of this routine, a write-cursor is any cursor that
52477: ** is capable of writing to the databse. That means the cursor was
52478: ** originally opened for writing and the cursor has not be disabled
52479: ** by having its state changed to CURSOR_FAULT.
52480: */
52481: static int countWriteCursors(BtShared *pBt){
52482: BtCursor *pCur;
52483: int r = 0;
52484: for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
52485: if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++;
52486: }
52487: return r;
52488: }
52489: #endif
52490:
52491: /*
52492: ** This routine sets the state to CURSOR_FAULT and the error
52493: ** code to errCode for every cursor on BtShared that pBtree
52494: ** references.
52495: **
52496: ** Every cursor is tripped, including cursors that belong
52497: ** to other database connections that happen to be sharing
52498: ** the cache with pBtree.
52499: **
52500: ** This routine gets called when a rollback occurs.
52501: ** All cursors using the same cache must be tripped
52502: ** to prevent them from trying to use the btree after
52503: ** the rollback. The rollback may have deleted tables
52504: ** or moved root pages, so it is not sufficient to
52505: ** save the state of the cursor. The cursor must be
52506: ** invalidated.
52507: */
52508: SQLITE_PRIVATE void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){
52509: BtCursor *p;
52510: sqlite3BtreeEnter(pBtree);
52511: for(p=pBtree->pBt->pCursor; p; p=p->pNext){
52512: int i;
52513: sqlite3BtreeClearCursor(p);
52514: p->eState = CURSOR_FAULT;
52515: p->skipNext = errCode;
52516: for(i=0; i<=p->iPage; i++){
52517: releasePage(p->apPage[i]);
52518: p->apPage[i] = 0;
52519: }
52520: }
52521: sqlite3BtreeLeave(pBtree);
52522: }
52523:
52524: /*
52525: ** Rollback the transaction in progress. All cursors will be
52526: ** invalided by this operation. Any attempt to use a cursor
52527: ** that was open at the beginning of this operation will result
52528: ** in an error.
52529: **
52530: ** This will release the write lock on the database file. If there
52531: ** are no active cursors, it also releases the read lock.
52532: */
52533: SQLITE_PRIVATE int sqlite3BtreeRollback(Btree *p){
52534: int rc;
52535: BtShared *pBt = p->pBt;
52536: MemPage *pPage1;
52537:
52538: sqlite3BtreeEnter(p);
52539: rc = saveAllCursors(pBt, 0, 0);
52540: #ifndef SQLITE_OMIT_SHARED_CACHE
52541: if( rc!=SQLITE_OK ){
52542: /* This is a horrible situation. An IO or malloc() error occurred whilst
52543: ** trying to save cursor positions. If this is an automatic rollback (as
52544: ** the result of a constraint, malloc() failure or IO error) then
52545: ** the cache may be internally inconsistent (not contain valid trees) so
52546: ** we cannot simply return the error to the caller. Instead, abort
52547: ** all queries that may be using any of the cursors that failed to save.
52548: */
52549: sqlite3BtreeTripAllCursors(p, rc);
52550: }
52551: #endif
52552: btreeIntegrity(p);
52553:
52554: if( p->inTrans==TRANS_WRITE ){
52555: int rc2;
52556:
52557: assert( TRANS_WRITE==pBt->inTransaction );
52558: rc2 = sqlite3PagerRollback(pBt->pPager);
52559: if( rc2!=SQLITE_OK ){
52560: rc = rc2;
52561: }
52562:
52563: /* The rollback may have destroyed the pPage1->aData value. So
52564: ** call btreeGetPage() on page 1 again to make
52565: ** sure pPage1->aData is set correctly. */
52566: if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
52567: int nPage = get4byte(28+(u8*)pPage1->aData);
52568: testcase( nPage==0 );
52569: if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
52570: testcase( pBt->nPage!=nPage );
52571: pBt->nPage = nPage;
52572: releasePage(pPage1);
52573: }
52574: assert( countWriteCursors(pBt)==0 );
52575: pBt->inTransaction = TRANS_READ;
52576: }
52577:
52578: btreeEndTransaction(p);
52579: sqlite3BtreeLeave(p);
52580: return rc;
52581: }
52582:
52583: /*
52584: ** Start a statement subtransaction. The subtransaction can can be rolled
52585: ** back independently of the main transaction. You must start a transaction
52586: ** before starting a subtransaction. The subtransaction is ended automatically
52587: ** if the main transaction commits or rolls back.
52588: **
52589: ** Statement subtransactions are used around individual SQL statements
52590: ** that are contained within a BEGIN...COMMIT block. If a constraint
52591: ** error occurs within the statement, the effect of that one statement
52592: ** can be rolled back without having to rollback the entire transaction.
52593: **
52594: ** A statement sub-transaction is implemented as an anonymous savepoint. The
52595: ** value passed as the second parameter is the total number of savepoints,
52596: ** including the new anonymous savepoint, open on the B-Tree. i.e. if there
52597: ** are no active savepoints and no other statement-transactions open,
52598: ** iStatement is 1. This anonymous savepoint can be released or rolled back
52599: ** using the sqlite3BtreeSavepoint() function.
52600: */
52601: SQLITE_PRIVATE int sqlite3BtreeBeginStmt(Btree *p, int iStatement){
52602: int rc;
52603: BtShared *pBt = p->pBt;
52604: sqlite3BtreeEnter(p);
52605: assert( p->inTrans==TRANS_WRITE );
52606: assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
52607: assert( iStatement>0 );
52608: assert( iStatement>p->db->nSavepoint );
52609: assert( pBt->inTransaction==TRANS_WRITE );
52610: /* At the pager level, a statement transaction is a savepoint with
52611: ** an index greater than all savepoints created explicitly using
52612: ** SQL statements. It is illegal to open, release or rollback any
52613: ** such savepoints while the statement transaction savepoint is active.
52614: */
52615: rc = sqlite3PagerOpenSavepoint(pBt->pPager, iStatement);
52616: sqlite3BtreeLeave(p);
52617: return rc;
52618: }
52619:
52620: /*
52621: ** The second argument to this function, op, is always SAVEPOINT_ROLLBACK
52622: ** or SAVEPOINT_RELEASE. This function either releases or rolls back the
52623: ** savepoint identified by parameter iSavepoint, depending on the value
52624: ** of op.
52625: **
52626: ** Normally, iSavepoint is greater than or equal to zero. However, if op is
52627: ** SAVEPOINT_ROLLBACK, then iSavepoint may also be -1. In this case the
52628: ** contents of the entire transaction are rolled back. This is different
52629: ** from a normal transaction rollback, as no locks are released and the
52630: ** transaction remains open.
52631: */
52632: SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
52633: int rc = SQLITE_OK;
52634: if( p && p->inTrans==TRANS_WRITE ){
52635: BtShared *pBt = p->pBt;
52636: assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
52637: assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
52638: sqlite3BtreeEnter(p);
52639: rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
52640: if( rc==SQLITE_OK ){
52641: if( iSavepoint<0 && (pBt->btsFlags & BTS_INITIALLY_EMPTY)!=0 ){
52642: pBt->nPage = 0;
52643: }
52644: rc = newDatabase(pBt);
52645: pBt->nPage = get4byte(28 + pBt->pPage1->aData);
52646:
52647: /* The database size was written into the offset 28 of the header
52648: ** when the transaction started, so we know that the value at offset
52649: ** 28 is nonzero. */
52650: assert( pBt->nPage>0 );
52651: }
52652: sqlite3BtreeLeave(p);
52653: }
52654: return rc;
52655: }
52656:
52657: /*
52658: ** Create a new cursor for the BTree whose root is on the page
52659: ** iTable. If a read-only cursor is requested, it is assumed that
52660: ** the caller already has at least a read-only transaction open
52661: ** on the database already. If a write-cursor is requested, then
52662: ** the caller is assumed to have an open write transaction.
52663: **
52664: ** If wrFlag==0, then the cursor can only be used for reading.
52665: ** If wrFlag==1, then the cursor can be used for reading or for
52666: ** writing if other conditions for writing are also met. These
52667: ** are the conditions that must be met in order for writing to
52668: ** be allowed:
52669: **
52670: ** 1: The cursor must have been opened with wrFlag==1
52671: **
52672: ** 2: Other database connections that share the same pager cache
52673: ** but which are not in the READ_UNCOMMITTED state may not have
52674: ** cursors open with wrFlag==0 on the same table. Otherwise
52675: ** the changes made by this write cursor would be visible to
52676: ** the read cursors in the other database connection.
52677: **
52678: ** 3: The database must be writable (not on read-only media)
52679: **
52680: ** 4: There must be an active transaction.
52681: **
52682: ** No checking is done to make sure that page iTable really is the
52683: ** root page of a b-tree. If it is not, then the cursor acquired
52684: ** will not work correctly.
52685: **
52686: ** It is assumed that the sqlite3BtreeCursorZero() has been called
52687: ** on pCur to initialize the memory space prior to invoking this routine.
52688: */
52689: static int btreeCursor(
52690: Btree *p, /* The btree */
52691: int iTable, /* Root page of table to open */
52692: int wrFlag, /* 1 to write. 0 read-only */
52693: struct KeyInfo *pKeyInfo, /* First arg to comparison function */
52694: BtCursor *pCur /* Space for new cursor */
52695: ){
52696: BtShared *pBt = p->pBt; /* Shared b-tree handle */
52697:
52698: assert( sqlite3BtreeHoldsMutex(p) );
52699: assert( wrFlag==0 || wrFlag==1 );
52700:
52701: /* The following assert statements verify that if this is a sharable
52702: ** b-tree database, the connection is holding the required table locks,
52703: ** and that no other connection has any open cursor that conflicts with
52704: ** this lock. */
52705: assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, wrFlag+1) );
52706: assert( wrFlag==0 || !hasReadConflicts(p, iTable) );
52707:
52708: /* Assert that the caller has opened the required transaction. */
52709: assert( p->inTrans>TRANS_NONE );
52710: assert( wrFlag==0 || p->inTrans==TRANS_WRITE );
52711: assert( pBt->pPage1 && pBt->pPage1->aData );
52712:
52713: if( NEVER(wrFlag && (pBt->btsFlags & BTS_READ_ONLY)!=0) ){
52714: return SQLITE_READONLY;
52715: }
52716: if( iTable==1 && btreePagecount(pBt)==0 ){
52717: assert( wrFlag==0 );
52718: iTable = 0;
52719: }
52720:
52721: /* Now that no other errors can occur, finish filling in the BtCursor
52722: ** variables and link the cursor into the BtShared list. */
52723: pCur->pgnoRoot = (Pgno)iTable;
52724: pCur->iPage = -1;
52725: pCur->pKeyInfo = pKeyInfo;
52726: pCur->pBtree = p;
52727: pCur->pBt = pBt;
52728: pCur->wrFlag = (u8)wrFlag;
52729: pCur->pNext = pBt->pCursor;
52730: if( pCur->pNext ){
52731: pCur->pNext->pPrev = pCur;
52732: }
52733: pBt->pCursor = pCur;
52734: pCur->eState = CURSOR_INVALID;
52735: pCur->cachedRowid = 0;
52736: return SQLITE_OK;
52737: }
52738: SQLITE_PRIVATE int sqlite3BtreeCursor(
52739: Btree *p, /* The btree */
52740: int iTable, /* Root page of table to open */
52741: int wrFlag, /* 1 to write. 0 read-only */
52742: struct KeyInfo *pKeyInfo, /* First arg to xCompare() */
52743: BtCursor *pCur /* Write new cursor here */
52744: ){
52745: int rc;
52746: sqlite3BtreeEnter(p);
52747: rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
52748: sqlite3BtreeLeave(p);
52749: return rc;
52750: }
52751:
52752: /*
52753: ** Return the size of a BtCursor object in bytes.
52754: **
52755: ** This interfaces is needed so that users of cursors can preallocate
52756: ** sufficient storage to hold a cursor. The BtCursor object is opaque
52757: ** to users so they cannot do the sizeof() themselves - they must call
52758: ** this routine.
52759: */
52760: SQLITE_PRIVATE int sqlite3BtreeCursorSize(void){
52761: return ROUND8(sizeof(BtCursor));
52762: }
52763:
52764: /*
52765: ** Initialize memory that will be converted into a BtCursor object.
52766: **
52767: ** The simple approach here would be to memset() the entire object
52768: ** to zero. But it turns out that the apPage[] and aiIdx[] arrays
52769: ** do not need to be zeroed and they are large, so we can save a lot
52770: ** of run-time by skipping the initialization of those elements.
52771: */
52772: SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor *p){
52773: memset(p, 0, offsetof(BtCursor, iPage));
52774: }
52775:
52776: /*
52777: ** Set the cached rowid value of every cursor in the same database file
52778: ** as pCur and having the same root page number as pCur. The value is
52779: ** set to iRowid.
52780: **
52781: ** Only positive rowid values are considered valid for this cache.
52782: ** The cache is initialized to zero, indicating an invalid cache.
52783: ** A btree will work fine with zero or negative rowids. We just cannot
52784: ** cache zero or negative rowids, which means tables that use zero or
52785: ** negative rowids might run a little slower. But in practice, zero
52786: ** or negative rowids are very uncommon so this should not be a problem.
52787: */
52788: SQLITE_PRIVATE void sqlite3BtreeSetCachedRowid(BtCursor *pCur, sqlite3_int64 iRowid){
52789: BtCursor *p;
52790: for(p=pCur->pBt->pCursor; p; p=p->pNext){
52791: if( p->pgnoRoot==pCur->pgnoRoot ) p->cachedRowid = iRowid;
52792: }
52793: assert( pCur->cachedRowid==iRowid );
52794: }
52795:
52796: /*
52797: ** Return the cached rowid for the given cursor. A negative or zero
52798: ** return value indicates that the rowid cache is invalid and should be
52799: ** ignored. If the rowid cache has never before been set, then a
52800: ** zero is returned.
52801: */
52802: SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeGetCachedRowid(BtCursor *pCur){
52803: return pCur->cachedRowid;
52804: }
52805:
52806: /*
52807: ** Close a cursor. The read lock on the database file is released
52808: ** when the last cursor is closed.
52809: */
52810: SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
52811: Btree *pBtree = pCur->pBtree;
52812: if( pBtree ){
52813: int i;
52814: BtShared *pBt = pCur->pBt;
52815: sqlite3BtreeEnter(pBtree);
52816: sqlite3BtreeClearCursor(pCur);
52817: if( pCur->pPrev ){
52818: pCur->pPrev->pNext = pCur->pNext;
52819: }else{
52820: pBt->pCursor = pCur->pNext;
52821: }
52822: if( pCur->pNext ){
52823: pCur->pNext->pPrev = pCur->pPrev;
52824: }
52825: for(i=0; i<=pCur->iPage; i++){
52826: releasePage(pCur->apPage[i]);
52827: }
52828: unlockBtreeIfUnused(pBt);
52829: invalidateOverflowCache(pCur);
52830: /* sqlite3_free(pCur); */
52831: sqlite3BtreeLeave(pBtree);
52832: }
52833: return SQLITE_OK;
52834: }
52835:
52836: /*
52837: ** Make sure the BtCursor* given in the argument has a valid
52838: ** BtCursor.info structure. If it is not already valid, call
52839: ** btreeParseCell() to fill it in.
52840: **
52841: ** BtCursor.info is a cache of the information in the current cell.
52842: ** Using this cache reduces the number of calls to btreeParseCell().
52843: **
52844: ** 2007-06-25: There is a bug in some versions of MSVC that cause the
52845: ** compiler to crash when getCellInfo() is implemented as a macro.
52846: ** But there is a measureable speed advantage to using the macro on gcc
52847: ** (when less compiler optimizations like -Os or -O0 are used and the
52848: ** compiler is not doing agressive inlining.) So we use a real function
52849: ** for MSVC and a macro for everything else. Ticket #2457.
52850: */
52851: #ifndef NDEBUG
52852: static void assertCellInfo(BtCursor *pCur){
52853: CellInfo info;
52854: int iPage = pCur->iPage;
52855: memset(&info, 0, sizeof(info));
52856: btreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
52857: assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
52858: }
52859: #else
52860: #define assertCellInfo(x)
52861: #endif
52862: #ifdef _MSC_VER
52863: /* Use a real function in MSVC to work around bugs in that compiler. */
52864: static void getCellInfo(BtCursor *pCur){
52865: if( pCur->info.nSize==0 ){
52866: int iPage = pCur->iPage;
52867: btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
52868: pCur->validNKey = 1;
52869: }else{
52870: assertCellInfo(pCur);
52871: }
52872: }
52873: #else /* if not _MSC_VER */
52874: /* Use a macro in all other compilers so that the function is inlined */
52875: #define getCellInfo(pCur) \
52876: if( pCur->info.nSize==0 ){ \
52877: int iPage = pCur->iPage; \
52878: btreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
52879: pCur->validNKey = 1; \
52880: }else{ \
52881: assertCellInfo(pCur); \
52882: }
52883: #endif /* _MSC_VER */
52884:
52885: #ifndef NDEBUG /* The next routine used only within assert() statements */
52886: /*
52887: ** Return true if the given BtCursor is valid. A valid cursor is one
52888: ** that is currently pointing to a row in a (non-empty) table.
52889: ** This is a verification routine is used only within assert() statements.
52890: */
52891: SQLITE_PRIVATE int sqlite3BtreeCursorIsValid(BtCursor *pCur){
52892: return pCur && pCur->eState==CURSOR_VALID;
52893: }
52894: #endif /* NDEBUG */
52895:
52896: /*
52897: ** Set *pSize to the size of the buffer needed to hold the value of
52898: ** the key for the current entry. If the cursor is not pointing
52899: ** to a valid entry, *pSize is set to 0.
52900: **
52901: ** For a table with the INTKEY flag set, this routine returns the key
52902: ** itself, not the number of bytes in the key.
52903: **
52904: ** The caller must position the cursor prior to invoking this routine.
52905: **
52906: ** This routine cannot fail. It always returns SQLITE_OK.
52907: */
52908: SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
52909: assert( cursorHoldsMutex(pCur) );
52910: assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
52911: if( pCur->eState!=CURSOR_VALID ){
52912: *pSize = 0;
52913: }else{
52914: getCellInfo(pCur);
52915: *pSize = pCur->info.nKey;
52916: }
52917: return SQLITE_OK;
52918: }
52919:
52920: /*
52921: ** Set *pSize to the number of bytes of data in the entry the
52922: ** cursor currently points to.
52923: **
52924: ** The caller must guarantee that the cursor is pointing to a non-NULL
52925: ** valid entry. In other words, the calling procedure must guarantee
52926: ** that the cursor has Cursor.eState==CURSOR_VALID.
52927: **
52928: ** Failure is not possible. This function always returns SQLITE_OK.
52929: ** It might just as well be a procedure (returning void) but we continue
52930: ** to return an integer result code for historical reasons.
52931: */
52932: SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
52933: assert( cursorHoldsMutex(pCur) );
52934: assert( pCur->eState==CURSOR_VALID );
52935: getCellInfo(pCur);
52936: *pSize = pCur->info.nData;
52937: return SQLITE_OK;
52938: }
52939:
52940: /*
52941: ** Given the page number of an overflow page in the database (parameter
52942: ** ovfl), this function finds the page number of the next page in the
52943: ** linked list of overflow pages. If possible, it uses the auto-vacuum
52944: ** pointer-map data instead of reading the content of page ovfl to do so.
52945: **
52946: ** If an error occurs an SQLite error code is returned. Otherwise:
52947: **
52948: ** The page number of the next overflow page in the linked list is
52949: ** written to *pPgnoNext. If page ovfl is the last page in its linked
52950: ** list, *pPgnoNext is set to zero.
52951: **
52952: ** If ppPage is not NULL, and a reference to the MemPage object corresponding
52953: ** to page number pOvfl was obtained, then *ppPage is set to point to that
52954: ** reference. It is the responsibility of the caller to call releasePage()
52955: ** on *ppPage to free the reference. In no reference was obtained (because
52956: ** the pointer-map was used to obtain the value for *pPgnoNext), then
52957: ** *ppPage is set to zero.
52958: */
52959: static int getOverflowPage(
52960: BtShared *pBt, /* The database file */
52961: Pgno ovfl, /* Current overflow page number */
52962: MemPage **ppPage, /* OUT: MemPage handle (may be NULL) */
52963: Pgno *pPgnoNext /* OUT: Next overflow page number */
52964: ){
52965: Pgno next = 0;
52966: MemPage *pPage = 0;
52967: int rc = SQLITE_OK;
52968:
52969: assert( sqlite3_mutex_held(pBt->mutex) );
52970: assert(pPgnoNext);
52971:
52972: #ifndef SQLITE_OMIT_AUTOVACUUM
52973: /* Try to find the next page in the overflow list using the
52974: ** autovacuum pointer-map pages. Guess that the next page in
52975: ** the overflow list is page number (ovfl+1). If that guess turns
52976: ** out to be wrong, fall back to loading the data of page
52977: ** number ovfl to determine the next page number.
52978: */
52979: if( pBt->autoVacuum ){
52980: Pgno pgno;
52981: Pgno iGuess = ovfl+1;
52982: u8 eType;
52983:
52984: while( PTRMAP_ISPAGE(pBt, iGuess) || iGuess==PENDING_BYTE_PAGE(pBt) ){
52985: iGuess++;
52986: }
52987:
52988: if( iGuess<=btreePagecount(pBt) ){
52989: rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
52990: if( rc==SQLITE_OK && eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
52991: next = iGuess;
52992: rc = SQLITE_DONE;
52993: }
52994: }
52995: }
52996: #endif
52997:
52998: assert( next==0 || rc==SQLITE_DONE );
52999: if( rc==SQLITE_OK ){
53000: rc = btreeGetPage(pBt, ovfl, &pPage, 0);
53001: assert( rc==SQLITE_OK || pPage==0 );
53002: if( rc==SQLITE_OK ){
53003: next = get4byte(pPage->aData);
53004: }
53005: }
53006:
53007: *pPgnoNext = next;
53008: if( ppPage ){
53009: *ppPage = pPage;
53010: }else{
53011: releasePage(pPage);
53012: }
53013: return (rc==SQLITE_DONE ? SQLITE_OK : rc);
53014: }
53015:
53016: /*
53017: ** Copy data from a buffer to a page, or from a page to a buffer.
53018: **
53019: ** pPayload is a pointer to data stored on database page pDbPage.
53020: ** If argument eOp is false, then nByte bytes of data are copied
53021: ** from pPayload to the buffer pointed at by pBuf. If eOp is true,
53022: ** then sqlite3PagerWrite() is called on pDbPage and nByte bytes
53023: ** of data are copied from the buffer pBuf to pPayload.
53024: **
53025: ** SQLITE_OK is returned on success, otherwise an error code.
53026: */
53027: static int copyPayload(
53028: void *pPayload, /* Pointer to page data */
53029: void *pBuf, /* Pointer to buffer */
53030: int nByte, /* Number of bytes to copy */
53031: int eOp, /* 0 -> copy from page, 1 -> copy to page */
53032: DbPage *pDbPage /* Page containing pPayload */
53033: ){
53034: if( eOp ){
53035: /* Copy data from buffer to page (a write operation) */
53036: int rc = sqlite3PagerWrite(pDbPage);
53037: if( rc!=SQLITE_OK ){
53038: return rc;
53039: }
53040: memcpy(pPayload, pBuf, nByte);
53041: }else{
53042: /* Copy data from page to buffer (a read operation) */
53043: memcpy(pBuf, pPayload, nByte);
53044: }
53045: return SQLITE_OK;
53046: }
53047:
53048: /*
53049: ** This function is used to read or overwrite payload information
53050: ** for the entry that the pCur cursor is pointing to. If the eOp
53051: ** parameter is 0, this is a read operation (data copied into
53052: ** buffer pBuf). If it is non-zero, a write (data copied from
53053: ** buffer pBuf).
53054: **
53055: ** A total of "amt" bytes are read or written beginning at "offset".
53056: ** Data is read to or from the buffer pBuf.
53057: **
53058: ** The content being read or written might appear on the main page
53059: ** or be scattered out on multiple overflow pages.
53060: **
53061: ** If the BtCursor.isIncrblobHandle flag is set, and the current
53062: ** cursor entry uses one or more overflow pages, this function
53063: ** allocates space for and lazily popluates the overflow page-list
53064: ** cache array (BtCursor.aOverflow). Subsequent calls use this
53065: ** cache to make seeking to the supplied offset more efficient.
53066: **
53067: ** Once an overflow page-list cache has been allocated, it may be
53068: ** invalidated if some other cursor writes to the same table, or if
53069: ** the cursor is moved to a different row. Additionally, in auto-vacuum
53070: ** mode, the following events may invalidate an overflow page-list cache.
53071: **
53072: ** * An incremental vacuum,
53073: ** * A commit in auto_vacuum="full" mode,
53074: ** * Creating a table (may require moving an overflow page).
53075: */
53076: static int accessPayload(
53077: BtCursor *pCur, /* Cursor pointing to entry to read from */
53078: u32 offset, /* Begin reading this far into payload */
53079: u32 amt, /* Read this many bytes */
53080: unsigned char *pBuf, /* Write the bytes into this buffer */
53081: int eOp /* zero to read. non-zero to write. */
53082: ){
53083: unsigned char *aPayload;
53084: int rc = SQLITE_OK;
53085: u32 nKey;
53086: int iIdx = 0;
53087: MemPage *pPage = pCur->apPage[pCur->iPage]; /* Btree page of current entry */
53088: BtShared *pBt = pCur->pBt; /* Btree this cursor belongs to */
53089:
53090: assert( pPage );
53091: assert( pCur->eState==CURSOR_VALID );
53092: assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
53093: assert( cursorHoldsMutex(pCur) );
53094:
53095: getCellInfo(pCur);
53096: aPayload = pCur->info.pCell + pCur->info.nHeader;
53097: nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
53098:
53099: if( NEVER(offset+amt > nKey+pCur->info.nData)
53100: || &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
53101: ){
53102: /* Trying to read or write past the end of the data is an error */
53103: return SQLITE_CORRUPT_BKPT;
53104: }
53105:
53106: /* Check if data must be read/written to/from the btree page itself. */
53107: if( offset<pCur->info.nLocal ){
53108: int a = amt;
53109: if( a+offset>pCur->info.nLocal ){
53110: a = pCur->info.nLocal - offset;
53111: }
53112: rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage);
53113: offset = 0;
53114: pBuf += a;
53115: amt -= a;
53116: }else{
53117: offset -= pCur->info.nLocal;
53118: }
53119:
53120: if( rc==SQLITE_OK && amt>0 ){
53121: const u32 ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
53122: Pgno nextPage;
53123:
53124: nextPage = get4byte(&aPayload[pCur->info.nLocal]);
53125:
53126: #ifndef SQLITE_OMIT_INCRBLOB
53127: /* If the isIncrblobHandle flag is set and the BtCursor.aOverflow[]
53128: ** has not been allocated, allocate it now. The array is sized at
53129: ** one entry for each overflow page in the overflow chain. The
53130: ** page number of the first overflow page is stored in aOverflow[0],
53131: ** etc. A value of 0 in the aOverflow[] array means "not yet known"
53132: ** (the cache is lazily populated).
53133: */
53134: if( pCur->isIncrblobHandle && !pCur->aOverflow ){
53135: int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
53136: pCur->aOverflow = (Pgno *)sqlite3MallocZero(sizeof(Pgno)*nOvfl);
53137: /* nOvfl is always positive. If it were zero, fetchPayload would have
53138: ** been used instead of this routine. */
53139: if( ALWAYS(nOvfl) && !pCur->aOverflow ){
53140: rc = SQLITE_NOMEM;
53141: }
53142: }
53143:
53144: /* If the overflow page-list cache has been allocated and the
53145: ** entry for the first required overflow page is valid, skip
53146: ** directly to it.
53147: */
53148: if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
53149: iIdx = (offset/ovflSize);
53150: nextPage = pCur->aOverflow[iIdx];
53151: offset = (offset%ovflSize);
53152: }
53153: #endif
53154:
53155: for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){
53156:
53157: #ifndef SQLITE_OMIT_INCRBLOB
53158: /* If required, populate the overflow page-list cache. */
53159: if( pCur->aOverflow ){
53160: assert(!pCur->aOverflow[iIdx] || pCur->aOverflow[iIdx]==nextPage);
53161: pCur->aOverflow[iIdx] = nextPage;
53162: }
53163: #endif
53164:
53165: if( offset>=ovflSize ){
53166: /* The only reason to read this page is to obtain the page
53167: ** number for the next page in the overflow chain. The page
53168: ** data is not required. So first try to lookup the overflow
53169: ** page-list cache, if any, then fall back to the getOverflowPage()
53170: ** function.
53171: */
53172: #ifndef SQLITE_OMIT_INCRBLOB
53173: if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
53174: nextPage = pCur->aOverflow[iIdx+1];
53175: } else
53176: #endif
53177: rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
53178: offset -= ovflSize;
53179: }else{
53180: /* Need to read this page properly. It contains some of the
53181: ** range of data that is being read (eOp==0) or written (eOp!=0).
53182: */
53183: #ifdef SQLITE_DIRECT_OVERFLOW_READ
53184: sqlite3_file *fd;
53185: #endif
53186: int a = amt;
53187: if( a + offset > ovflSize ){
53188: a = ovflSize - offset;
53189: }
53190:
53191: #ifdef SQLITE_DIRECT_OVERFLOW_READ
53192: /* If all the following are true:
53193: **
53194: ** 1) this is a read operation, and
53195: ** 2) data is required from the start of this overflow page, and
53196: ** 3) the database is file-backed, and
53197: ** 4) there is no open write-transaction, and
53198: ** 5) the database is not a WAL database,
53199: **
53200: ** then data can be read directly from the database file into the
53201: ** output buffer, bypassing the page-cache altogether. This speeds
53202: ** up loading large records that span many overflow pages.
53203: */
53204: if( eOp==0 /* (1) */
53205: && offset==0 /* (2) */
53206: && pBt->inTransaction==TRANS_READ /* (4) */
53207: && (fd = sqlite3PagerFile(pBt->pPager))->pMethods /* (3) */
53208: && pBt->pPage1->aData[19]==0x01 /* (5) */
53209: ){
53210: u8 aSave[4];
53211: u8 *aWrite = &pBuf[-4];
53212: memcpy(aSave, aWrite, 4);
53213: rc = sqlite3OsRead(fd, aWrite, a+4, (i64)pBt->pageSize*(nextPage-1));
53214: nextPage = get4byte(aWrite);
53215: memcpy(aWrite, aSave, 4);
53216: }else
53217: #endif
53218:
53219: {
53220: DbPage *pDbPage;
53221: rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage);
53222: if( rc==SQLITE_OK ){
53223: aPayload = sqlite3PagerGetData(pDbPage);
53224: nextPage = get4byte(aPayload);
53225: rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage);
53226: sqlite3PagerUnref(pDbPage);
53227: offset = 0;
53228: }
53229: }
53230: amt -= a;
53231: pBuf += a;
53232: }
53233: }
53234: }
53235:
53236: if( rc==SQLITE_OK && amt>0 ){
53237: return SQLITE_CORRUPT_BKPT;
53238: }
53239: return rc;
53240: }
53241:
53242: /*
53243: ** Read part of the key associated with cursor pCur. Exactly
53244: ** "amt" bytes will be transfered into pBuf[]. The transfer
53245: ** begins at "offset".
53246: **
53247: ** The caller must ensure that pCur is pointing to a valid row
53248: ** in the table.
53249: **
53250: ** Return SQLITE_OK on success or an error code if anything goes
53251: ** wrong. An error is returned if "offset+amt" is larger than
53252: ** the available payload.
53253: */
53254: SQLITE_PRIVATE int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
53255: assert( cursorHoldsMutex(pCur) );
53256: assert( pCur->eState==CURSOR_VALID );
53257: assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
53258: assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
53259: return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
53260: }
53261:
53262: /*
53263: ** Read part of the data associated with cursor pCur. Exactly
53264: ** "amt" bytes will be transfered into pBuf[]. The transfer
53265: ** begins at "offset".
53266: **
53267: ** Return SQLITE_OK on success or an error code if anything goes
53268: ** wrong. An error is returned if "offset+amt" is larger than
53269: ** the available payload.
53270: */
53271: SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
53272: int rc;
53273:
53274: #ifndef SQLITE_OMIT_INCRBLOB
53275: if ( pCur->eState==CURSOR_INVALID ){
53276: return SQLITE_ABORT;
53277: }
53278: #endif
53279:
53280: assert( cursorHoldsMutex(pCur) );
53281: rc = restoreCursorPosition(pCur);
53282: if( rc==SQLITE_OK ){
53283: assert( pCur->eState==CURSOR_VALID );
53284: assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
53285: assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
53286: rc = accessPayload(pCur, offset, amt, pBuf, 0);
53287: }
53288: return rc;
53289: }
53290:
53291: /*
53292: ** Return a pointer to payload information from the entry that the
53293: ** pCur cursor is pointing to. The pointer is to the beginning of
53294: ** the key if skipKey==0 and it points to the beginning of data if
53295: ** skipKey==1. The number of bytes of available key/data is written
53296: ** into *pAmt. If *pAmt==0, then the value returned will not be
53297: ** a valid pointer.
53298: **
53299: ** This routine is an optimization. It is common for the entire key
53300: ** and data to fit on the local page and for there to be no overflow
53301: ** pages. When that is so, this routine can be used to access the
53302: ** key and data without making a copy. If the key and/or data spills
53303: ** onto overflow pages, then accessPayload() must be used to reassemble
53304: ** the key/data and copy it into a preallocated buffer.
53305: **
53306: ** The pointer returned by this routine looks directly into the cached
53307: ** page of the database. The data might change or move the next time
53308: ** any btree routine is called.
53309: */
53310: static const unsigned char *fetchPayload(
53311: BtCursor *pCur, /* Cursor pointing to entry to read from */
53312: int *pAmt, /* Write the number of available bytes here */
53313: int skipKey /* read beginning at data if this is true */
53314: ){
53315: unsigned char *aPayload;
53316: MemPage *pPage;
53317: u32 nKey;
53318: u32 nLocal;
53319:
53320: assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
53321: assert( pCur->eState==CURSOR_VALID );
53322: assert( cursorHoldsMutex(pCur) );
53323: pPage = pCur->apPage[pCur->iPage];
53324: assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
53325: if( NEVER(pCur->info.nSize==0) ){
53326: btreeParseCell(pCur->apPage[pCur->iPage], pCur->aiIdx[pCur->iPage],
53327: &pCur->info);
53328: }
53329: aPayload = pCur->info.pCell;
53330: aPayload += pCur->info.nHeader;
53331: if( pPage->intKey ){
53332: nKey = 0;
53333: }else{
53334: nKey = (int)pCur->info.nKey;
53335: }
53336: if( skipKey ){
53337: aPayload += nKey;
53338: nLocal = pCur->info.nLocal - nKey;
53339: }else{
53340: nLocal = pCur->info.nLocal;
53341: assert( nLocal<=nKey );
53342: }
53343: *pAmt = nLocal;
53344: return aPayload;
53345: }
53346:
53347:
53348: /*
53349: ** For the entry that cursor pCur is point to, return as
53350: ** many bytes of the key or data as are available on the local
53351: ** b-tree page. Write the number of available bytes into *pAmt.
53352: **
53353: ** The pointer returned is ephemeral. The key/data may move
53354: ** or be destroyed on the next call to any Btree routine,
53355: ** including calls from other threads against the same cache.
53356: ** Hence, a mutex on the BtShared should be held prior to calling
53357: ** this routine.
53358: **
53359: ** These routines is used to get quick access to key and data
53360: ** in the common case where no overflow pages are used.
53361: */
53362: SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
53363: const void *p = 0;
53364: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53365: assert( cursorHoldsMutex(pCur) );
53366: if( ALWAYS(pCur->eState==CURSOR_VALID) ){
53367: p = (const void*)fetchPayload(pCur, pAmt, 0);
53368: }
53369: return p;
53370: }
53371: SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
53372: const void *p = 0;
53373: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53374: assert( cursorHoldsMutex(pCur) );
53375: if( ALWAYS(pCur->eState==CURSOR_VALID) ){
53376: p = (const void*)fetchPayload(pCur, pAmt, 1);
53377: }
53378: return p;
53379: }
53380:
53381:
53382: /*
53383: ** Move the cursor down to a new child page. The newPgno argument is the
53384: ** page number of the child page to move to.
53385: **
53386: ** This function returns SQLITE_CORRUPT if the page-header flags field of
53387: ** the new child page does not match the flags field of the parent (i.e.
53388: ** if an intkey page appears to be the parent of a non-intkey page, or
53389: ** vice-versa).
53390: */
53391: static int moveToChild(BtCursor *pCur, u32 newPgno){
53392: int rc;
53393: int i = pCur->iPage;
53394: MemPage *pNewPage;
53395: BtShared *pBt = pCur->pBt;
53396:
53397: assert( cursorHoldsMutex(pCur) );
53398: assert( pCur->eState==CURSOR_VALID );
53399: assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
53400: if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
53401: return SQLITE_CORRUPT_BKPT;
53402: }
53403: rc = getAndInitPage(pBt, newPgno, &pNewPage);
53404: if( rc ) return rc;
53405: pCur->apPage[i+1] = pNewPage;
53406: pCur->aiIdx[i+1] = 0;
53407: pCur->iPage++;
53408:
53409: pCur->info.nSize = 0;
53410: pCur->validNKey = 0;
53411: if( pNewPage->nCell<1 || pNewPage->intKey!=pCur->apPage[i]->intKey ){
53412: return SQLITE_CORRUPT_BKPT;
53413: }
53414: return SQLITE_OK;
53415: }
53416:
53417: #if 0
53418: /*
53419: ** Page pParent is an internal (non-leaf) tree page. This function
53420: ** asserts that page number iChild is the left-child if the iIdx'th
53421: ** cell in page pParent. Or, if iIdx is equal to the total number of
53422: ** cells in pParent, that page number iChild is the right-child of
53423: ** the page.
53424: */
53425: static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
53426: assert( iIdx<=pParent->nCell );
53427: if( iIdx==pParent->nCell ){
53428: assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
53429: }else{
53430: assert( get4byte(findCell(pParent, iIdx))==iChild );
53431: }
53432: }
53433: #else
53434: # define assertParentIndex(x,y,z)
53435: #endif
53436:
53437: /*
53438: ** Move the cursor up to the parent page.
53439: **
53440: ** pCur->idx is set to the cell index that contains the pointer
53441: ** to the page we are coming from. If we are coming from the
53442: ** right-most child page then pCur->idx is set to one more than
53443: ** the largest cell index.
53444: */
53445: static void moveToParent(BtCursor *pCur){
53446: assert( cursorHoldsMutex(pCur) );
53447: assert( pCur->eState==CURSOR_VALID );
53448: assert( pCur->iPage>0 );
53449: assert( pCur->apPage[pCur->iPage] );
53450:
53451: /* UPDATE: It is actually possible for the condition tested by the assert
53452: ** below to be untrue if the database file is corrupt. This can occur if
53453: ** one cursor has modified page pParent while a reference to it is held
53454: ** by a second cursor. Which can only happen if a single page is linked
53455: ** into more than one b-tree structure in a corrupt database. */
53456: #if 0
53457: assertParentIndex(
53458: pCur->apPage[pCur->iPage-1],
53459: pCur->aiIdx[pCur->iPage-1],
53460: pCur->apPage[pCur->iPage]->pgno
53461: );
53462: #endif
53463: testcase( pCur->aiIdx[pCur->iPage-1] > pCur->apPage[pCur->iPage-1]->nCell );
53464:
53465: releasePage(pCur->apPage[pCur->iPage]);
53466: pCur->iPage--;
53467: pCur->info.nSize = 0;
53468: pCur->validNKey = 0;
53469: }
53470:
53471: /*
53472: ** Move the cursor to point to the root page of its b-tree structure.
53473: **
53474: ** If the table has a virtual root page, then the cursor is moved to point
53475: ** to the virtual root page instead of the actual root page. A table has a
53476: ** virtual root page when the actual root page contains no cells and a
53477: ** single child page. This can only happen with the table rooted at page 1.
53478: **
53479: ** If the b-tree structure is empty, the cursor state is set to
53480: ** CURSOR_INVALID. Otherwise, the cursor is set to point to the first
53481: ** cell located on the root (or virtual root) page and the cursor state
53482: ** is set to CURSOR_VALID.
53483: **
53484: ** If this function returns successfully, it may be assumed that the
53485: ** page-header flags indicate that the [virtual] root-page is the expected
53486: ** kind of b-tree page (i.e. if when opening the cursor the caller did not
53487: ** specify a KeyInfo structure the flags byte is set to 0x05 or 0x0D,
53488: ** indicating a table b-tree, or if the caller did specify a KeyInfo
53489: ** structure the flags byte is set to 0x02 or 0x0A, indicating an index
53490: ** b-tree).
53491: */
53492: static int moveToRoot(BtCursor *pCur){
53493: MemPage *pRoot;
53494: int rc = SQLITE_OK;
53495: Btree *p = pCur->pBtree;
53496: BtShared *pBt = p->pBt;
53497:
53498: assert( cursorHoldsMutex(pCur) );
53499: assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
53500: assert( CURSOR_VALID < CURSOR_REQUIRESEEK );
53501: assert( CURSOR_FAULT > CURSOR_REQUIRESEEK );
53502: if( pCur->eState>=CURSOR_REQUIRESEEK ){
53503: if( pCur->eState==CURSOR_FAULT ){
53504: assert( pCur->skipNext!=SQLITE_OK );
53505: return pCur->skipNext;
53506: }
53507: sqlite3BtreeClearCursor(pCur);
53508: }
53509:
53510: if( pCur->iPage>=0 ){
53511: int i;
53512: for(i=1; i<=pCur->iPage; i++){
53513: releasePage(pCur->apPage[i]);
53514: }
53515: pCur->iPage = 0;
53516: }else if( pCur->pgnoRoot==0 ){
53517: pCur->eState = CURSOR_INVALID;
53518: return SQLITE_OK;
53519: }else{
53520: rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
53521: if( rc!=SQLITE_OK ){
53522: pCur->eState = CURSOR_INVALID;
53523: return rc;
53524: }
53525: pCur->iPage = 0;
53526:
53527: /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
53528: ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
53529: ** NULL, the caller expects a table b-tree. If this is not the case,
53530: ** return an SQLITE_CORRUPT error. */
53531: assert( pCur->apPage[0]->intKey==1 || pCur->apPage[0]->intKey==0 );
53532: if( (pCur->pKeyInfo==0)!=pCur->apPage[0]->intKey ){
53533: return SQLITE_CORRUPT_BKPT;
53534: }
53535: }
53536:
53537: /* Assert that the root page is of the correct type. This must be the
53538: ** case as the call to this function that loaded the root-page (either
53539: ** this call or a previous invocation) would have detected corruption
53540: ** if the assumption were not true, and it is not possible for the flags
53541: ** byte to have been modified while this cursor is holding a reference
53542: ** to the page. */
53543: pRoot = pCur->apPage[0];
53544: assert( pRoot->pgno==pCur->pgnoRoot );
53545: assert( pRoot->isInit && (pCur->pKeyInfo==0)==pRoot->intKey );
53546:
53547: pCur->aiIdx[0] = 0;
53548: pCur->info.nSize = 0;
53549: pCur->atLast = 0;
53550: pCur->validNKey = 0;
53551:
53552: if( pRoot->nCell==0 && !pRoot->leaf ){
53553: Pgno subpage;
53554: if( pRoot->pgno!=1 ) return SQLITE_CORRUPT_BKPT;
53555: subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
53556: pCur->eState = CURSOR_VALID;
53557: rc = moveToChild(pCur, subpage);
53558: }else{
53559: pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
53560: }
53561: return rc;
53562: }
53563:
53564: /*
53565: ** Move the cursor down to the left-most leaf entry beneath the
53566: ** entry to which it is currently pointing.
53567: **
53568: ** The left-most leaf is the one with the smallest key - the first
53569: ** in ascending order.
53570: */
53571: static int moveToLeftmost(BtCursor *pCur){
53572: Pgno pgno;
53573: int rc = SQLITE_OK;
53574: MemPage *pPage;
53575:
53576: assert( cursorHoldsMutex(pCur) );
53577: assert( pCur->eState==CURSOR_VALID );
53578: while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53579: assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
53580: pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
53581: rc = moveToChild(pCur, pgno);
53582: }
53583: return rc;
53584: }
53585:
53586: /*
53587: ** Move the cursor down to the right-most leaf entry beneath the
53588: ** page to which it is currently pointing. Notice the difference
53589: ** between moveToLeftmost() and moveToRightmost(). moveToLeftmost()
53590: ** finds the left-most entry beneath the *entry* whereas moveToRightmost()
53591: ** finds the right-most entry beneath the *page*.
53592: **
53593: ** The right-most entry is the one with the largest key - the last
53594: ** key in ascending order.
53595: */
53596: static int moveToRightmost(BtCursor *pCur){
53597: Pgno pgno;
53598: int rc = SQLITE_OK;
53599: MemPage *pPage = 0;
53600:
53601: assert( cursorHoldsMutex(pCur) );
53602: assert( pCur->eState==CURSOR_VALID );
53603: while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
53604: pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
53605: pCur->aiIdx[pCur->iPage] = pPage->nCell;
53606: rc = moveToChild(pCur, pgno);
53607: }
53608: if( rc==SQLITE_OK ){
53609: pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
53610: pCur->info.nSize = 0;
53611: pCur->validNKey = 0;
53612: }
53613: return rc;
53614: }
53615:
53616: /* Move the cursor to the first entry in the table. Return SQLITE_OK
53617: ** on success. Set *pRes to 0 if the cursor actually points to something
53618: ** or set *pRes to 1 if the table is empty.
53619: */
53620: SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
53621: int rc;
53622:
53623: assert( cursorHoldsMutex(pCur) );
53624: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53625: rc = moveToRoot(pCur);
53626: if( rc==SQLITE_OK ){
53627: if( pCur->eState==CURSOR_INVALID ){
53628: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
53629: *pRes = 1;
53630: }else{
53631: assert( pCur->apPage[pCur->iPage]->nCell>0 );
53632: *pRes = 0;
53633: rc = moveToLeftmost(pCur);
53634: }
53635: }
53636: return rc;
53637: }
53638:
53639: /* Move the cursor to the last entry in the table. Return SQLITE_OK
53640: ** on success. Set *pRes to 0 if the cursor actually points to something
53641: ** or set *pRes to 1 if the table is empty.
53642: */
53643: SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
53644: int rc;
53645:
53646: assert( cursorHoldsMutex(pCur) );
53647: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53648:
53649: /* If the cursor already points to the last entry, this is a no-op. */
53650: if( CURSOR_VALID==pCur->eState && pCur->atLast ){
53651: #ifdef SQLITE_DEBUG
53652: /* This block serves to assert() that the cursor really does point
53653: ** to the last entry in the b-tree. */
53654: int ii;
53655: for(ii=0; ii<pCur->iPage; ii++){
53656: assert( pCur->aiIdx[ii]==pCur->apPage[ii]->nCell );
53657: }
53658: assert( pCur->aiIdx[pCur->iPage]==pCur->apPage[pCur->iPage]->nCell-1 );
53659: assert( pCur->apPage[pCur->iPage]->leaf );
53660: #endif
53661: return SQLITE_OK;
53662: }
53663:
53664: rc = moveToRoot(pCur);
53665: if( rc==SQLITE_OK ){
53666: if( CURSOR_INVALID==pCur->eState ){
53667: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
53668: *pRes = 1;
53669: }else{
53670: assert( pCur->eState==CURSOR_VALID );
53671: *pRes = 0;
53672: rc = moveToRightmost(pCur);
53673: pCur->atLast = rc==SQLITE_OK ?1:0;
53674: }
53675: }
53676: return rc;
53677: }
53678:
53679: /* Move the cursor so that it points to an entry near the key
53680: ** specified by pIdxKey or intKey. Return a success code.
53681: **
53682: ** For INTKEY tables, the intKey parameter is used. pIdxKey
53683: ** must be NULL. For index tables, pIdxKey is used and intKey
53684: ** is ignored.
53685: **
53686: ** If an exact match is not found, then the cursor is always
53687: ** left pointing at a leaf page which would hold the entry if it
53688: ** were present. The cursor might point to an entry that comes
53689: ** before or after the key.
53690: **
53691: ** An integer is written into *pRes which is the result of
53692: ** comparing the key with the entry to which the cursor is
53693: ** pointing. The meaning of the integer written into
53694: ** *pRes is as follows:
53695: **
53696: ** *pRes<0 The cursor is left pointing at an entry that
53697: ** is smaller than intKey/pIdxKey or if the table is empty
53698: ** and the cursor is therefore left point to nothing.
53699: **
53700: ** *pRes==0 The cursor is left pointing at an entry that
53701: ** exactly matches intKey/pIdxKey.
53702: **
53703: ** *pRes>0 The cursor is left pointing at an entry that
53704: ** is larger than intKey/pIdxKey.
53705: **
53706: */
53707: SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
53708: BtCursor *pCur, /* The cursor to be moved */
53709: UnpackedRecord *pIdxKey, /* Unpacked index key */
53710: i64 intKey, /* The table key */
53711: int biasRight, /* If true, bias the search to the high end */
53712: int *pRes /* Write search results here */
53713: ){
53714: int rc;
53715:
53716: assert( cursorHoldsMutex(pCur) );
53717: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
53718: assert( pRes );
53719: assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
53720:
53721: /* If the cursor is already positioned at the point we are trying
53722: ** to move to, then just return without doing any work */
53723: if( pCur->eState==CURSOR_VALID && pCur->validNKey
53724: && pCur->apPage[0]->intKey
53725: ){
53726: if( pCur->info.nKey==intKey ){
53727: *pRes = 0;
53728: return SQLITE_OK;
53729: }
53730: if( pCur->atLast && pCur->info.nKey<intKey ){
53731: *pRes = -1;
53732: return SQLITE_OK;
53733: }
53734: }
53735:
53736: rc = moveToRoot(pCur);
53737: if( rc ){
53738: return rc;
53739: }
53740: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage] );
53741: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->isInit );
53742: assert( pCur->eState==CURSOR_INVALID || pCur->apPage[pCur->iPage]->nCell>0 );
53743: if( pCur->eState==CURSOR_INVALID ){
53744: *pRes = -1;
53745: assert( pCur->pgnoRoot==0 || pCur->apPage[pCur->iPage]->nCell==0 );
53746: return SQLITE_OK;
53747: }
53748: assert( pCur->apPage[0]->intKey || pIdxKey );
53749: for(;;){
53750: int lwr, upr, idx;
53751: Pgno chldPg;
53752: MemPage *pPage = pCur->apPage[pCur->iPage];
53753: int c;
53754:
53755: /* pPage->nCell must be greater than zero. If this is the root-page
53756: ** the cursor would have been INVALID above and this for(;;) loop
53757: ** not run. If this is not the root-page, then the moveToChild() routine
53758: ** would have already detected db corruption. Similarly, pPage must
53759: ** be the right kind (index or table) of b-tree page. Otherwise
53760: ** a moveToChild() or moveToRoot() call would have detected corruption. */
53761: assert( pPage->nCell>0 );
53762: assert( pPage->intKey==(pIdxKey==0) );
53763: lwr = 0;
53764: upr = pPage->nCell-1;
53765: if( biasRight ){
53766: pCur->aiIdx[pCur->iPage] = (u16)(idx = upr);
53767: }else{
53768: pCur->aiIdx[pCur->iPage] = (u16)(idx = (upr+lwr)/2);
53769: }
53770: for(;;){
53771: u8 *pCell; /* Pointer to current cell in pPage */
53772:
53773: assert( idx==pCur->aiIdx[pCur->iPage] );
53774: pCur->info.nSize = 0;
53775: pCell = findCell(pPage, idx) + pPage->childPtrSize;
53776: if( pPage->intKey ){
53777: i64 nCellKey;
53778: if( pPage->hasData ){
53779: u32 dummy;
53780: pCell += getVarint32(pCell, dummy);
53781: }
53782: getVarint(pCell, (u64*)&nCellKey);
53783: if( nCellKey==intKey ){
53784: c = 0;
53785: }else if( nCellKey<intKey ){
53786: c = -1;
53787: }else{
53788: assert( nCellKey>intKey );
53789: c = +1;
53790: }
53791: pCur->validNKey = 1;
53792: pCur->info.nKey = nCellKey;
53793: }else{
53794: /* The maximum supported page-size is 65536 bytes. This means that
53795: ** the maximum number of record bytes stored on an index B-Tree
53796: ** page is less than 16384 bytes and may be stored as a 2-byte
53797: ** varint. This information is used to attempt to avoid parsing
53798: ** the entire cell by checking for the cases where the record is
53799: ** stored entirely within the b-tree page by inspecting the first
53800: ** 2 bytes of the cell.
53801: */
53802: int nCell = pCell[0];
53803: if( nCell<=pPage->max1bytePayload
53804: /* && (pCell+nCell)<pPage->aDataEnd */
53805: ){
53806: /* This branch runs if the record-size field of the cell is a
53807: ** single byte varint and the record fits entirely on the main
53808: ** b-tree page. */
53809: testcase( pCell+nCell+1==pPage->aDataEnd );
53810: c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[1], pIdxKey);
53811: }else if( !(pCell[1] & 0x80)
53812: && (nCell = ((nCell&0x7f)<<7) + pCell[1])<=pPage->maxLocal
53813: /* && (pCell+nCell+2)<=pPage->aDataEnd */
53814: ){
53815: /* The record-size field is a 2 byte varint and the record
53816: ** fits entirely on the main b-tree page. */
53817: testcase( pCell+nCell+2==pPage->aDataEnd );
53818: c = sqlite3VdbeRecordCompare(nCell, (void*)&pCell[2], pIdxKey);
53819: }else{
53820: /* The record flows over onto one or more overflow pages. In
53821: ** this case the whole cell needs to be parsed, a buffer allocated
53822: ** and accessPayload() used to retrieve the record into the
53823: ** buffer before VdbeRecordCompare() can be called. */
53824: void *pCellKey;
53825: u8 * const pCellBody = pCell - pPage->childPtrSize;
53826: btreeParseCellPtr(pPage, pCellBody, &pCur->info);
53827: nCell = (int)pCur->info.nKey;
53828: pCellKey = sqlite3Malloc( nCell );
53829: if( pCellKey==0 ){
53830: rc = SQLITE_NOMEM;
53831: goto moveto_finish;
53832: }
53833: rc = accessPayload(pCur, 0, nCell, (unsigned char*)pCellKey, 0);
53834: if( rc ){
53835: sqlite3_free(pCellKey);
53836: goto moveto_finish;
53837: }
53838: c = sqlite3VdbeRecordCompare(nCell, pCellKey, pIdxKey);
53839: sqlite3_free(pCellKey);
53840: }
53841: }
53842: if( c==0 ){
53843: if( pPage->intKey && !pPage->leaf ){
53844: lwr = idx;
53845: break;
53846: }else{
53847: *pRes = 0;
53848: rc = SQLITE_OK;
53849: goto moveto_finish;
53850: }
53851: }
53852: if( c<0 ){
53853: lwr = idx+1;
53854: }else{
53855: upr = idx-1;
53856: }
53857: if( lwr>upr ){
53858: break;
53859: }
53860: pCur->aiIdx[pCur->iPage] = (u16)(idx = (lwr+upr)/2);
53861: }
53862: assert( lwr==upr+1 || (pPage->intKey && !pPage->leaf) );
53863: assert( pPage->isInit );
53864: if( pPage->leaf ){
53865: chldPg = 0;
53866: }else if( lwr>=pPage->nCell ){
53867: chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
53868: }else{
53869: chldPg = get4byte(findCell(pPage, lwr));
53870: }
53871: if( chldPg==0 ){
53872: assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
53873: *pRes = c;
53874: rc = SQLITE_OK;
53875: goto moveto_finish;
53876: }
53877: pCur->aiIdx[pCur->iPage] = (u16)lwr;
53878: pCur->info.nSize = 0;
53879: pCur->validNKey = 0;
53880: rc = moveToChild(pCur, chldPg);
53881: if( rc ) goto moveto_finish;
53882: }
53883: moveto_finish:
53884: return rc;
53885: }
53886:
53887:
53888: /*
53889: ** Return TRUE if the cursor is not pointing at an entry of the table.
53890: **
53891: ** TRUE will be returned after a call to sqlite3BtreeNext() moves
53892: ** past the last entry in the table or sqlite3BtreePrev() moves past
53893: ** the first entry. TRUE is also returned if the table is empty.
53894: */
53895: SQLITE_PRIVATE int sqlite3BtreeEof(BtCursor *pCur){
53896: /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
53897: ** have been deleted? This API will need to change to return an error code
53898: ** as well as the boolean result value.
53899: */
53900: return (CURSOR_VALID!=pCur->eState);
53901: }
53902:
53903: /*
53904: ** Advance the cursor to the next entry in the database. If
53905: ** successful then set *pRes=0. If the cursor
53906: ** was already pointing to the last entry in the database before
53907: ** this routine was called, then set *pRes=1.
53908: */
53909: SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
53910: int rc;
53911: int idx;
53912: MemPage *pPage;
53913:
53914: assert( cursorHoldsMutex(pCur) );
53915: rc = restoreCursorPosition(pCur);
53916: if( rc!=SQLITE_OK ){
53917: return rc;
53918: }
53919: assert( pRes!=0 );
53920: if( CURSOR_INVALID==pCur->eState ){
53921: *pRes = 1;
53922: return SQLITE_OK;
53923: }
53924: if( pCur->skipNext>0 ){
53925: pCur->skipNext = 0;
53926: *pRes = 0;
53927: return SQLITE_OK;
53928: }
53929: pCur->skipNext = 0;
53930:
53931: pPage = pCur->apPage[pCur->iPage];
53932: idx = ++pCur->aiIdx[pCur->iPage];
53933: assert( pPage->isInit );
53934:
53935: /* If the database file is corrupt, it is possible for the value of idx
53936: ** to be invalid here. This can only occur if a second cursor modifies
53937: ** the page while cursor pCur is holding a reference to it. Which can
53938: ** only happen if the database is corrupt in such a way as to link the
53939: ** page into more than one b-tree structure. */
53940: testcase( idx>pPage->nCell );
53941:
53942: pCur->info.nSize = 0;
53943: pCur->validNKey = 0;
53944: if( idx>=pPage->nCell ){
53945: if( !pPage->leaf ){
53946: rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
53947: if( rc ) return rc;
53948: rc = moveToLeftmost(pCur);
53949: *pRes = 0;
53950: return rc;
53951: }
53952: do{
53953: if( pCur->iPage==0 ){
53954: *pRes = 1;
53955: pCur->eState = CURSOR_INVALID;
53956: return SQLITE_OK;
53957: }
53958: moveToParent(pCur);
53959: pPage = pCur->apPage[pCur->iPage];
53960: }while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
53961: *pRes = 0;
53962: if( pPage->intKey ){
53963: rc = sqlite3BtreeNext(pCur, pRes);
53964: }else{
53965: rc = SQLITE_OK;
53966: }
53967: return rc;
53968: }
53969: *pRes = 0;
53970: if( pPage->leaf ){
53971: return SQLITE_OK;
53972: }
53973: rc = moveToLeftmost(pCur);
53974: return rc;
53975: }
53976:
53977:
53978: /*
53979: ** Step the cursor to the back to the previous entry in the database. If
53980: ** successful then set *pRes=0. If the cursor
53981: ** was already pointing to the first entry in the database before
53982: ** this routine was called, then set *pRes=1.
53983: */
53984: SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
53985: int rc;
53986: MemPage *pPage;
53987:
53988: assert( cursorHoldsMutex(pCur) );
53989: rc = restoreCursorPosition(pCur);
53990: if( rc!=SQLITE_OK ){
53991: return rc;
53992: }
53993: pCur->atLast = 0;
53994: if( CURSOR_INVALID==pCur->eState ){
53995: *pRes = 1;
53996: return SQLITE_OK;
53997: }
53998: if( pCur->skipNext<0 ){
53999: pCur->skipNext = 0;
54000: *pRes = 0;
54001: return SQLITE_OK;
54002: }
54003: pCur->skipNext = 0;
54004:
54005: pPage = pCur->apPage[pCur->iPage];
54006: assert( pPage->isInit );
54007: if( !pPage->leaf ){
54008: int idx = pCur->aiIdx[pCur->iPage];
54009: rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
54010: if( rc ){
54011: return rc;
54012: }
54013: rc = moveToRightmost(pCur);
54014: }else{
54015: while( pCur->aiIdx[pCur->iPage]==0 ){
54016: if( pCur->iPage==0 ){
54017: pCur->eState = CURSOR_INVALID;
54018: *pRes = 1;
54019: return SQLITE_OK;
54020: }
54021: moveToParent(pCur);
54022: }
54023: pCur->info.nSize = 0;
54024: pCur->validNKey = 0;
54025:
54026: pCur->aiIdx[pCur->iPage]--;
54027: pPage = pCur->apPage[pCur->iPage];
54028: if( pPage->intKey && !pPage->leaf ){
54029: rc = sqlite3BtreePrevious(pCur, pRes);
54030: }else{
54031: rc = SQLITE_OK;
54032: }
54033: }
54034: *pRes = 0;
54035: return rc;
54036: }
54037:
54038: /*
54039: ** Allocate a new page from the database file.
54040: **
54041: ** The new page is marked as dirty. (In other words, sqlite3PagerWrite()
54042: ** has already been called on the new page.) The new page has also
54043: ** been referenced and the calling routine is responsible for calling
54044: ** sqlite3PagerUnref() on the new page when it is done.
54045: **
54046: ** SQLITE_OK is returned on success. Any other return value indicates
54047: ** an error. *ppPage and *pPgno are undefined in the event of an error.
54048: ** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned.
54049: **
54050: ** If the "nearby" parameter is not 0, then a (feeble) effort is made to
54051: ** locate a page close to the page number "nearby". This can be used in an
54052: ** attempt to keep related pages close to each other in the database file,
54053: ** which in turn can make database access faster.
54054: **
54055: ** If the "exact" parameter is not 0, and the page-number nearby exists
54056: ** anywhere on the free-list, then it is guarenteed to be returned. This
54057: ** is only used by auto-vacuum databases when allocating a new table.
54058: */
54059: static int allocateBtreePage(
54060: BtShared *pBt,
54061: MemPage **ppPage,
54062: Pgno *pPgno,
54063: Pgno nearby,
54064: u8 exact
54065: ){
54066: MemPage *pPage1;
54067: int rc;
54068: u32 n; /* Number of pages on the freelist */
54069: u32 k; /* Number of leaves on the trunk of the freelist */
54070: MemPage *pTrunk = 0;
54071: MemPage *pPrevTrunk = 0;
54072: Pgno mxPage; /* Total size of the database file */
54073:
54074: assert( sqlite3_mutex_held(pBt->mutex) );
54075: pPage1 = pBt->pPage1;
54076: mxPage = btreePagecount(pBt);
54077: n = get4byte(&pPage1->aData[36]);
54078: testcase( n==mxPage-1 );
54079: if( n>=mxPage ){
54080: return SQLITE_CORRUPT_BKPT;
54081: }
54082: if( n>0 ){
54083: /* There are pages on the freelist. Reuse one of those pages. */
54084: Pgno iTrunk;
54085: u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
54086:
54087: /* If the 'exact' parameter was true and a query of the pointer-map
54088: ** shows that the page 'nearby' is somewhere on the free-list, then
54089: ** the entire-list will be searched for that page.
54090: */
54091: #ifndef SQLITE_OMIT_AUTOVACUUM
54092: if( exact && nearby<=mxPage ){
54093: u8 eType;
54094: assert( nearby>0 );
54095: assert( pBt->autoVacuum );
54096: rc = ptrmapGet(pBt, nearby, &eType, 0);
54097: if( rc ) return rc;
54098: if( eType==PTRMAP_FREEPAGE ){
54099: searchList = 1;
54100: }
54101: *pPgno = nearby;
54102: }
54103: #endif
54104:
54105: /* Decrement the free-list count by 1. Set iTrunk to the index of the
54106: ** first free-list trunk page. iPrevTrunk is initially 1.
54107: */
54108: rc = sqlite3PagerWrite(pPage1->pDbPage);
54109: if( rc ) return rc;
54110: put4byte(&pPage1->aData[36], n-1);
54111:
54112: /* The code within this loop is run only once if the 'searchList' variable
54113: ** is not true. Otherwise, it runs once for each trunk-page on the
54114: ** free-list until the page 'nearby' is located.
54115: */
54116: do {
54117: pPrevTrunk = pTrunk;
54118: if( pPrevTrunk ){
54119: iTrunk = get4byte(&pPrevTrunk->aData[0]);
54120: }else{
54121: iTrunk = get4byte(&pPage1->aData[32]);
54122: }
54123: testcase( iTrunk==mxPage );
54124: if( iTrunk>mxPage ){
54125: rc = SQLITE_CORRUPT_BKPT;
54126: }else{
54127: rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
54128: }
54129: if( rc ){
54130: pTrunk = 0;
54131: goto end_allocate_page;
54132: }
54133: assert( pTrunk!=0 );
54134: assert( pTrunk->aData!=0 );
54135:
54136: k = get4byte(&pTrunk->aData[4]); /* # of leaves on this trunk page */
54137: if( k==0 && !searchList ){
54138: /* The trunk has no leaves and the list is not being searched.
54139: ** So extract the trunk page itself and use it as the newly
54140: ** allocated page */
54141: assert( pPrevTrunk==0 );
54142: rc = sqlite3PagerWrite(pTrunk->pDbPage);
54143: if( rc ){
54144: goto end_allocate_page;
54145: }
54146: *pPgno = iTrunk;
54147: memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
54148: *ppPage = pTrunk;
54149: pTrunk = 0;
54150: TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
54151: }else if( k>(u32)(pBt->usableSize/4 - 2) ){
54152: /* Value of k is out of range. Database corruption */
54153: rc = SQLITE_CORRUPT_BKPT;
54154: goto end_allocate_page;
54155: #ifndef SQLITE_OMIT_AUTOVACUUM
54156: }else if( searchList && nearby==iTrunk ){
54157: /* The list is being searched and this trunk page is the page
54158: ** to allocate, regardless of whether it has leaves.
54159: */
54160: assert( *pPgno==iTrunk );
54161: *ppPage = pTrunk;
54162: searchList = 0;
54163: rc = sqlite3PagerWrite(pTrunk->pDbPage);
54164: if( rc ){
54165: goto end_allocate_page;
54166: }
54167: if( k==0 ){
54168: if( !pPrevTrunk ){
54169: memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
54170: }else{
54171: rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
54172: if( rc!=SQLITE_OK ){
54173: goto end_allocate_page;
54174: }
54175: memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
54176: }
54177: }else{
54178: /* The trunk page is required by the caller but it contains
54179: ** pointers to free-list leaves. The first leaf becomes a trunk
54180: ** page in this case.
54181: */
54182: MemPage *pNewTrunk;
54183: Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
54184: if( iNewTrunk>mxPage ){
54185: rc = SQLITE_CORRUPT_BKPT;
54186: goto end_allocate_page;
54187: }
54188: testcase( iNewTrunk==mxPage );
54189: rc = btreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0);
54190: if( rc!=SQLITE_OK ){
54191: goto end_allocate_page;
54192: }
54193: rc = sqlite3PagerWrite(pNewTrunk->pDbPage);
54194: if( rc!=SQLITE_OK ){
54195: releasePage(pNewTrunk);
54196: goto end_allocate_page;
54197: }
54198: memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
54199: put4byte(&pNewTrunk->aData[4], k-1);
54200: memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
54201: releasePage(pNewTrunk);
54202: if( !pPrevTrunk ){
54203: assert( sqlite3PagerIswriteable(pPage1->pDbPage) );
54204: put4byte(&pPage1->aData[32], iNewTrunk);
54205: }else{
54206: rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
54207: if( rc ){
54208: goto end_allocate_page;
54209: }
54210: put4byte(&pPrevTrunk->aData[0], iNewTrunk);
54211: }
54212: }
54213: pTrunk = 0;
54214: TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
54215: #endif
54216: }else if( k>0 ){
54217: /* Extract a leaf from the trunk */
54218: u32 closest;
54219: Pgno iPage;
54220: unsigned char *aData = pTrunk->aData;
54221: if( nearby>0 ){
54222: u32 i;
54223: int dist;
54224: closest = 0;
54225: dist = sqlite3AbsInt32(get4byte(&aData[8]) - nearby);
54226: for(i=1; i<k; i++){
54227: int d2 = sqlite3AbsInt32(get4byte(&aData[8+i*4]) - nearby);
54228: if( d2<dist ){
54229: closest = i;
54230: dist = d2;
54231: }
54232: }
54233: }else{
54234: closest = 0;
54235: }
54236:
54237: iPage = get4byte(&aData[8+closest*4]);
54238: testcase( iPage==mxPage );
54239: if( iPage>mxPage ){
54240: rc = SQLITE_CORRUPT_BKPT;
54241: goto end_allocate_page;
54242: }
54243: testcase( iPage==mxPage );
54244: if( !searchList || iPage==nearby ){
54245: int noContent;
54246: *pPgno = iPage;
54247: TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
54248: ": %d more free pages\n",
54249: *pPgno, closest+1, k, pTrunk->pgno, n-1));
54250: rc = sqlite3PagerWrite(pTrunk->pDbPage);
54251: if( rc ) goto end_allocate_page;
54252: if( closest<k-1 ){
54253: memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
54254: }
54255: put4byte(&aData[4], k-1);
54256: noContent = !btreeGetHasContent(pBt, *pPgno);
54257: rc = btreeGetPage(pBt, *pPgno, ppPage, noContent);
54258: if( rc==SQLITE_OK ){
54259: rc = sqlite3PagerWrite((*ppPage)->pDbPage);
54260: if( rc!=SQLITE_OK ){
54261: releasePage(*ppPage);
54262: }
54263: }
54264: searchList = 0;
54265: }
54266: }
54267: releasePage(pPrevTrunk);
54268: pPrevTrunk = 0;
54269: }while( searchList );
54270: }else{
54271: /* There are no pages on the freelist, so create a new page at the
54272: ** end of the file */
54273: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
54274: if( rc ) return rc;
54275: pBt->nPage++;
54276: if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ) pBt->nPage++;
54277:
54278: #ifndef SQLITE_OMIT_AUTOVACUUM
54279: if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, pBt->nPage) ){
54280: /* If *pPgno refers to a pointer-map page, allocate two new pages
54281: ** at the end of the file instead of one. The first allocated page
54282: ** becomes a new pointer-map page, the second is used by the caller.
54283: */
54284: MemPage *pPg = 0;
54285: TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", pBt->nPage));
54286: assert( pBt->nPage!=PENDING_BYTE_PAGE(pBt) );
54287: rc = btreeGetPage(pBt, pBt->nPage, &pPg, 1);
54288: if( rc==SQLITE_OK ){
54289: rc = sqlite3PagerWrite(pPg->pDbPage);
54290: releasePage(pPg);
54291: }
54292: if( rc ) return rc;
54293: pBt->nPage++;
54294: if( pBt->nPage==PENDING_BYTE_PAGE(pBt) ){ pBt->nPage++; }
54295: }
54296: #endif
54297: put4byte(28 + (u8*)pBt->pPage1->aData, pBt->nPage);
54298: *pPgno = pBt->nPage;
54299:
54300: assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
54301: rc = btreeGetPage(pBt, *pPgno, ppPage, 1);
54302: if( rc ) return rc;
54303: rc = sqlite3PagerWrite((*ppPage)->pDbPage);
54304: if( rc!=SQLITE_OK ){
54305: releasePage(*ppPage);
54306: }
54307: TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
54308: }
54309:
54310: assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
54311:
54312: end_allocate_page:
54313: releasePage(pTrunk);
54314: releasePage(pPrevTrunk);
54315: if( rc==SQLITE_OK ){
54316: if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){
54317: releasePage(*ppPage);
54318: return SQLITE_CORRUPT_BKPT;
54319: }
54320: (*ppPage)->isInit = 0;
54321: }else{
54322: *ppPage = 0;
54323: }
54324: assert( rc!=SQLITE_OK || sqlite3PagerIswriteable((*ppPage)->pDbPage) );
54325: return rc;
54326: }
54327:
54328: /*
54329: ** This function is used to add page iPage to the database file free-list.
54330: ** It is assumed that the page is not already a part of the free-list.
54331: **
54332: ** The value passed as the second argument to this function is optional.
54333: ** If the caller happens to have a pointer to the MemPage object
54334: ** corresponding to page iPage handy, it may pass it as the second value.
54335: ** Otherwise, it may pass NULL.
54336: **
54337: ** If a pointer to a MemPage object is passed as the second argument,
54338: ** its reference count is not altered by this function.
54339: */
54340: static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
54341: MemPage *pTrunk = 0; /* Free-list trunk page */
54342: Pgno iTrunk = 0; /* Page number of free-list trunk page */
54343: MemPage *pPage1 = pBt->pPage1; /* Local reference to page 1 */
54344: MemPage *pPage; /* Page being freed. May be NULL. */
54345: int rc; /* Return Code */
54346: int nFree; /* Initial number of pages on free-list */
54347:
54348: assert( sqlite3_mutex_held(pBt->mutex) );
54349: assert( iPage>1 );
54350: assert( !pMemPage || pMemPage->pgno==iPage );
54351:
54352: if( pMemPage ){
54353: pPage = pMemPage;
54354: sqlite3PagerRef(pPage->pDbPage);
54355: }else{
54356: pPage = btreePageLookup(pBt, iPage);
54357: }
54358:
54359: /* Increment the free page count on pPage1 */
54360: rc = sqlite3PagerWrite(pPage1->pDbPage);
54361: if( rc ) goto freepage_out;
54362: nFree = get4byte(&pPage1->aData[36]);
54363: put4byte(&pPage1->aData[36], nFree+1);
54364:
54365: if( pBt->btsFlags & BTS_SECURE_DELETE ){
54366: /* If the secure_delete option is enabled, then
54367: ** always fully overwrite deleted information with zeros.
54368: */
54369: if( (!pPage && ((rc = btreeGetPage(pBt, iPage, &pPage, 0))!=0) )
54370: || ((rc = sqlite3PagerWrite(pPage->pDbPage))!=0)
54371: ){
54372: goto freepage_out;
54373: }
54374: memset(pPage->aData, 0, pPage->pBt->pageSize);
54375: }
54376:
54377: /* If the database supports auto-vacuum, write an entry in the pointer-map
54378: ** to indicate that the page is free.
54379: */
54380: if( ISAUTOVACUUM ){
54381: ptrmapPut(pBt, iPage, PTRMAP_FREEPAGE, 0, &rc);
54382: if( rc ) goto freepage_out;
54383: }
54384:
54385: /* Now manipulate the actual database free-list structure. There are two
54386: ** possibilities. If the free-list is currently empty, or if the first
54387: ** trunk page in the free-list is full, then this page will become a
54388: ** new free-list trunk page. Otherwise, it will become a leaf of the
54389: ** first trunk page in the current free-list. This block tests if it
54390: ** is possible to add the page as a new free-list leaf.
54391: */
54392: if( nFree!=0 ){
54393: u32 nLeaf; /* Initial number of leaf cells on trunk page */
54394:
54395: iTrunk = get4byte(&pPage1->aData[32]);
54396: rc = btreeGetPage(pBt, iTrunk, &pTrunk, 0);
54397: if( rc!=SQLITE_OK ){
54398: goto freepage_out;
54399: }
54400:
54401: nLeaf = get4byte(&pTrunk->aData[4]);
54402: assert( pBt->usableSize>32 );
54403: if( nLeaf > (u32)pBt->usableSize/4 - 2 ){
54404: rc = SQLITE_CORRUPT_BKPT;
54405: goto freepage_out;
54406: }
54407: if( nLeaf < (u32)pBt->usableSize/4 - 8 ){
54408: /* In this case there is room on the trunk page to insert the page
54409: ** being freed as a new leaf.
54410: **
54411: ** Note that the trunk page is not really full until it contains
54412: ** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
54413: ** coded. But due to a coding error in versions of SQLite prior to
54414: ** 3.6.0, databases with freelist trunk pages holding more than
54415: ** usableSize/4 - 8 entries will be reported as corrupt. In order
54416: ** to maintain backwards compatibility with older versions of SQLite,
54417: ** we will continue to restrict the number of entries to usableSize/4 - 8
54418: ** for now. At some point in the future (once everyone has upgraded
54419: ** to 3.6.0 or later) we should consider fixing the conditional above
54420: ** to read "usableSize/4-2" instead of "usableSize/4-8".
54421: */
54422: rc = sqlite3PagerWrite(pTrunk->pDbPage);
54423: if( rc==SQLITE_OK ){
54424: put4byte(&pTrunk->aData[4], nLeaf+1);
54425: put4byte(&pTrunk->aData[8+nLeaf*4], iPage);
54426: if( pPage && (pBt->btsFlags & BTS_SECURE_DELETE)==0 ){
54427: sqlite3PagerDontWrite(pPage->pDbPage);
54428: }
54429: rc = btreeSetHasContent(pBt, iPage);
54430: }
54431: TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
54432: goto freepage_out;
54433: }
54434: }
54435:
54436: /* If control flows to this point, then it was not possible to add the
54437: ** the page being freed as a leaf page of the first trunk in the free-list.
54438: ** Possibly because the free-list is empty, or possibly because the
54439: ** first trunk in the free-list is full. Either way, the page being freed
54440: ** will become the new first trunk page in the free-list.
54441: */
54442: if( pPage==0 && SQLITE_OK!=(rc = btreeGetPage(pBt, iPage, &pPage, 0)) ){
54443: goto freepage_out;
54444: }
54445: rc = sqlite3PagerWrite(pPage->pDbPage);
54446: if( rc!=SQLITE_OK ){
54447: goto freepage_out;
54448: }
54449: put4byte(pPage->aData, iTrunk);
54450: put4byte(&pPage->aData[4], 0);
54451: put4byte(&pPage1->aData[32], iPage);
54452: TRACE(("FREE-PAGE: %d new trunk page replacing %d\n", pPage->pgno, iTrunk));
54453:
54454: freepage_out:
54455: if( pPage ){
54456: pPage->isInit = 0;
54457: }
54458: releasePage(pPage);
54459: releasePage(pTrunk);
54460: return rc;
54461: }
54462: static void freePage(MemPage *pPage, int *pRC){
54463: if( (*pRC)==SQLITE_OK ){
54464: *pRC = freePage2(pPage->pBt, pPage, pPage->pgno);
54465: }
54466: }
54467:
54468: /*
54469: ** Free any overflow pages associated with the given Cell.
54470: */
54471: static int clearCell(MemPage *pPage, unsigned char *pCell){
54472: BtShared *pBt = pPage->pBt;
54473: CellInfo info;
54474: Pgno ovflPgno;
54475: int rc;
54476: int nOvfl;
54477: u32 ovflPageSize;
54478:
54479: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54480: btreeParseCellPtr(pPage, pCell, &info);
54481: if( info.iOverflow==0 ){
54482: return SQLITE_OK; /* No overflow pages. Return without doing anything */
54483: }
54484: if( pCell+info.iOverflow+3 > pPage->aData+pPage->maskPage ){
54485: return SQLITE_CORRUPT; /* Cell extends past end of page */
54486: }
54487: ovflPgno = get4byte(&pCell[info.iOverflow]);
54488: assert( pBt->usableSize > 4 );
54489: ovflPageSize = pBt->usableSize - 4;
54490: nOvfl = (info.nPayload - info.nLocal + ovflPageSize - 1)/ovflPageSize;
54491: assert( ovflPgno==0 || nOvfl>0 );
54492: while( nOvfl-- ){
54493: Pgno iNext = 0;
54494: MemPage *pOvfl = 0;
54495: if( ovflPgno<2 || ovflPgno>btreePagecount(pBt) ){
54496: /* 0 is not a legal page number and page 1 cannot be an
54497: ** overflow page. Therefore if ovflPgno<2 or past the end of the
54498: ** file the database must be corrupt. */
54499: return SQLITE_CORRUPT_BKPT;
54500: }
54501: if( nOvfl ){
54502: rc = getOverflowPage(pBt, ovflPgno, &pOvfl, &iNext);
54503: if( rc ) return rc;
54504: }
54505:
54506: if( ( pOvfl || ((pOvfl = btreePageLookup(pBt, ovflPgno))!=0) )
54507: && sqlite3PagerPageRefcount(pOvfl->pDbPage)!=1
54508: ){
54509: /* There is no reason any cursor should have an outstanding reference
54510: ** to an overflow page belonging to a cell that is being deleted/updated.
54511: ** So if there exists more than one reference to this page, then it
54512: ** must not really be an overflow page and the database must be corrupt.
54513: ** It is helpful to detect this before calling freePage2(), as
54514: ** freePage2() may zero the page contents if secure-delete mode is
54515: ** enabled. If this 'overflow' page happens to be a page that the
54516: ** caller is iterating through or using in some other way, this
54517: ** can be problematic.
54518: */
54519: rc = SQLITE_CORRUPT_BKPT;
54520: }else{
54521: rc = freePage2(pBt, pOvfl, ovflPgno);
54522: }
54523:
54524: if( pOvfl ){
54525: sqlite3PagerUnref(pOvfl->pDbPage);
54526: }
54527: if( rc ) return rc;
54528: ovflPgno = iNext;
54529: }
54530: return SQLITE_OK;
54531: }
54532:
54533: /*
54534: ** Create the byte sequence used to represent a cell on page pPage
54535: ** and write that byte sequence into pCell[]. Overflow pages are
54536: ** allocated and filled in as necessary. The calling procedure
54537: ** is responsible for making sure sufficient space has been allocated
54538: ** for pCell[].
54539: **
54540: ** Note that pCell does not necessary need to point to the pPage->aData
54541: ** area. pCell might point to some temporary storage. The cell will
54542: ** be constructed in this temporary area then copied into pPage->aData
54543: ** later.
54544: */
54545: static int fillInCell(
54546: MemPage *pPage, /* The page that contains the cell */
54547: unsigned char *pCell, /* Complete text of the cell */
54548: const void *pKey, i64 nKey, /* The key */
54549: const void *pData,int nData, /* The data */
54550: int nZero, /* Extra zero bytes to append to pData */
54551: int *pnSize /* Write cell size here */
54552: ){
54553: int nPayload;
54554: const u8 *pSrc;
54555: int nSrc, n, rc;
54556: int spaceLeft;
54557: MemPage *pOvfl = 0;
54558: MemPage *pToRelease = 0;
54559: unsigned char *pPrior;
54560: unsigned char *pPayload;
54561: BtShared *pBt = pPage->pBt;
54562: Pgno pgnoOvfl = 0;
54563: int nHeader;
54564: CellInfo info;
54565:
54566: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54567:
54568: /* pPage is not necessarily writeable since pCell might be auxiliary
54569: ** buffer space that is separate from the pPage buffer area */
54570: assert( pCell<pPage->aData || pCell>=&pPage->aData[pBt->pageSize]
54571: || sqlite3PagerIswriteable(pPage->pDbPage) );
54572:
54573: /* Fill in the header. */
54574: nHeader = 0;
54575: if( !pPage->leaf ){
54576: nHeader += 4;
54577: }
54578: if( pPage->hasData ){
54579: nHeader += putVarint(&pCell[nHeader], nData+nZero);
54580: }else{
54581: nData = nZero = 0;
54582: }
54583: nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
54584: btreeParseCellPtr(pPage, pCell, &info);
54585: assert( info.nHeader==nHeader );
54586: assert( info.nKey==nKey );
54587: assert( info.nData==(u32)(nData+nZero) );
54588:
54589: /* Fill in the payload */
54590: nPayload = nData + nZero;
54591: if( pPage->intKey ){
54592: pSrc = pData;
54593: nSrc = nData;
54594: nData = 0;
54595: }else{
54596: if( NEVER(nKey>0x7fffffff || pKey==0) ){
54597: return SQLITE_CORRUPT_BKPT;
54598: }
54599: nPayload += (int)nKey;
54600: pSrc = pKey;
54601: nSrc = (int)nKey;
54602: }
54603: *pnSize = info.nSize;
54604: spaceLeft = info.nLocal;
54605: pPayload = &pCell[nHeader];
54606: pPrior = &pCell[info.iOverflow];
54607:
54608: while( nPayload>0 ){
54609: if( spaceLeft==0 ){
54610: #ifndef SQLITE_OMIT_AUTOVACUUM
54611: Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
54612: if( pBt->autoVacuum ){
54613: do{
54614: pgnoOvfl++;
54615: } while(
54616: PTRMAP_ISPAGE(pBt, pgnoOvfl) || pgnoOvfl==PENDING_BYTE_PAGE(pBt)
54617: );
54618: }
54619: #endif
54620: rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0);
54621: #ifndef SQLITE_OMIT_AUTOVACUUM
54622: /* If the database supports auto-vacuum, and the second or subsequent
54623: ** overflow page is being allocated, add an entry to the pointer-map
54624: ** for that page now.
54625: **
54626: ** If this is the first overflow page, then write a partial entry
54627: ** to the pointer-map. If we write nothing to this pointer-map slot,
54628: ** then the optimistic overflow chain processing in clearCell()
54629: ** may misinterpret the uninitialised values and delete the
54630: ** wrong pages from the database.
54631: */
54632: if( pBt->autoVacuum && rc==SQLITE_OK ){
54633: u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1);
54634: ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap, &rc);
54635: if( rc ){
54636: releasePage(pOvfl);
54637: }
54638: }
54639: #endif
54640: if( rc ){
54641: releasePage(pToRelease);
54642: return rc;
54643: }
54644:
54645: /* If pToRelease is not zero than pPrior points into the data area
54646: ** of pToRelease. Make sure pToRelease is still writeable. */
54647: assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
54648:
54649: /* If pPrior is part of the data area of pPage, then make sure pPage
54650: ** is still writeable */
54651: assert( pPrior<pPage->aData || pPrior>=&pPage->aData[pBt->pageSize]
54652: || sqlite3PagerIswriteable(pPage->pDbPage) );
54653:
54654: put4byte(pPrior, pgnoOvfl);
54655: releasePage(pToRelease);
54656: pToRelease = pOvfl;
54657: pPrior = pOvfl->aData;
54658: put4byte(pPrior, 0);
54659: pPayload = &pOvfl->aData[4];
54660: spaceLeft = pBt->usableSize - 4;
54661: }
54662: n = nPayload;
54663: if( n>spaceLeft ) n = spaceLeft;
54664:
54665: /* If pToRelease is not zero than pPayload points into the data area
54666: ** of pToRelease. Make sure pToRelease is still writeable. */
54667: assert( pToRelease==0 || sqlite3PagerIswriteable(pToRelease->pDbPage) );
54668:
54669: /* If pPayload is part of the data area of pPage, then make sure pPage
54670: ** is still writeable */
54671: assert( pPayload<pPage->aData || pPayload>=&pPage->aData[pBt->pageSize]
54672: || sqlite3PagerIswriteable(pPage->pDbPage) );
54673:
54674: if( nSrc>0 ){
54675: if( n>nSrc ) n = nSrc;
54676: assert( pSrc );
54677: memcpy(pPayload, pSrc, n);
54678: }else{
54679: memset(pPayload, 0, n);
54680: }
54681: nPayload -= n;
54682: pPayload += n;
54683: pSrc += n;
54684: nSrc -= n;
54685: spaceLeft -= n;
54686: if( nSrc==0 ){
54687: nSrc = nData;
54688: pSrc = pData;
54689: }
54690: }
54691: releasePage(pToRelease);
54692: return SQLITE_OK;
54693: }
54694:
54695: /*
54696: ** Remove the i-th cell from pPage. This routine effects pPage only.
54697: ** The cell content is not freed or deallocated. It is assumed that
54698: ** the cell content has been copied someplace else. This routine just
54699: ** removes the reference to the cell from pPage.
54700: **
54701: ** "sz" must be the number of bytes in the cell.
54702: */
54703: static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
54704: u32 pc; /* Offset to cell content of cell being deleted */
54705: u8 *data; /* pPage->aData */
54706: u8 *ptr; /* Used to move bytes around within data[] */
54707: u8 *endPtr; /* End of loop */
54708: int rc; /* The return code */
54709: int hdr; /* Beginning of the header. 0 most pages. 100 page 1 */
54710:
54711: if( *pRC ) return;
54712:
54713: assert( idx>=0 && idx<pPage->nCell );
54714: assert( sz==cellSize(pPage, idx) );
54715: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
54716: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54717: data = pPage->aData;
54718: ptr = &pPage->aCellIdx[2*idx];
54719: pc = get2byte(ptr);
54720: hdr = pPage->hdrOffset;
54721: testcase( pc==get2byte(&data[hdr+5]) );
54722: testcase( pc+sz==pPage->pBt->usableSize );
54723: if( pc < (u32)get2byte(&data[hdr+5]) || pc+sz > pPage->pBt->usableSize ){
54724: *pRC = SQLITE_CORRUPT_BKPT;
54725: return;
54726: }
54727: rc = freeSpace(pPage, pc, sz);
54728: if( rc ){
54729: *pRC = rc;
54730: return;
54731: }
54732: endPtr = &pPage->aCellIdx[2*pPage->nCell - 2];
54733: assert( (SQLITE_PTR_TO_INT(ptr)&1)==0 ); /* ptr is always 2-byte aligned */
54734: while( ptr<endPtr ){
54735: *(u16*)ptr = *(u16*)&ptr[2];
54736: ptr += 2;
54737: }
54738: pPage->nCell--;
54739: put2byte(&data[hdr+3], pPage->nCell);
54740: pPage->nFree += 2;
54741: }
54742:
54743: /*
54744: ** Insert a new cell on pPage at cell index "i". pCell points to the
54745: ** content of the cell.
54746: **
54747: ** If the cell content will fit on the page, then put it there. If it
54748: ** will not fit, then make a copy of the cell content into pTemp if
54749: ** pTemp is not null. Regardless of pTemp, allocate a new entry
54750: ** in pPage->aOvfl[] and make it point to the cell content (either
54751: ** in pTemp or the original pCell) and also record its index.
54752: ** Allocating a new entry in pPage->aCell[] implies that
54753: ** pPage->nOverflow is incremented.
54754: **
54755: ** If nSkip is non-zero, then do not copy the first nSkip bytes of the
54756: ** cell. The caller will overwrite them after this function returns. If
54757: ** nSkip is non-zero, then pCell may not point to an invalid memory location
54758: ** (but pCell+nSkip is always valid).
54759: */
54760: static void insertCell(
54761: MemPage *pPage, /* Page into which we are copying */
54762: int i, /* New cell becomes the i-th cell of the page */
54763: u8 *pCell, /* Content of the new cell */
54764: int sz, /* Bytes of content in pCell */
54765: u8 *pTemp, /* Temp storage space for pCell, if needed */
54766: Pgno iChild, /* If non-zero, replace first 4 bytes with this value */
54767: int *pRC /* Read and write return code from here */
54768: ){
54769: int idx = 0; /* Where to write new cell content in data[] */
54770: int j; /* Loop counter */
54771: int end; /* First byte past the last cell pointer in data[] */
54772: int ins; /* Index in data[] where new cell pointer is inserted */
54773: int cellOffset; /* Address of first cell pointer in data[] */
54774: u8 *data; /* The content of the whole page */
54775: u8 *ptr; /* Used for moving information around in data[] */
54776: u8 *endPtr; /* End of the loop */
54777:
54778: int nSkip = (iChild ? 4 : 0);
54779:
54780: if( *pRC ) return;
54781:
54782: assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
54783: assert( pPage->nCell<=MX_CELL(pPage->pBt) && MX_CELL(pPage->pBt)<=10921 );
54784: assert( pPage->nOverflow<=ArraySize(pPage->aOvfl) );
54785: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54786: /* The cell should normally be sized correctly. However, when moving a
54787: ** malformed cell from a leaf page to an interior page, if the cell size
54788: ** wanted to be less than 4 but got rounded up to 4 on the leaf, then size
54789: ** might be less than 8 (leaf-size + pointer) on the interior node. Hence
54790: ** the term after the || in the following assert(). */
54791: assert( sz==cellSizePtr(pPage, pCell) || (sz==8 && iChild>0) );
54792: if( pPage->nOverflow || sz+2>pPage->nFree ){
54793: if( pTemp ){
54794: memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
54795: pCell = pTemp;
54796: }
54797: if( iChild ){
54798: put4byte(pCell, iChild);
54799: }
54800: j = pPage->nOverflow++;
54801: assert( j<(int)(sizeof(pPage->aOvfl)/sizeof(pPage->aOvfl[0])) );
54802: pPage->aOvfl[j].pCell = pCell;
54803: pPage->aOvfl[j].idx = (u16)i;
54804: }else{
54805: int rc = sqlite3PagerWrite(pPage->pDbPage);
54806: if( rc!=SQLITE_OK ){
54807: *pRC = rc;
54808: return;
54809: }
54810: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
54811: data = pPage->aData;
54812: cellOffset = pPage->cellOffset;
54813: end = cellOffset + 2*pPage->nCell;
54814: ins = cellOffset + 2*i;
54815: rc = allocateSpace(pPage, sz, &idx);
54816: if( rc ){ *pRC = rc; return; }
54817: /* The allocateSpace() routine guarantees the following two properties
54818: ** if it returns success */
54819: assert( idx >= end+2 );
54820: assert( idx+sz <= (int)pPage->pBt->usableSize );
54821: pPage->nCell++;
54822: pPage->nFree -= (u16)(2 + sz);
54823: memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
54824: if( iChild ){
54825: put4byte(&data[idx], iChild);
54826: }
54827: ptr = &data[end];
54828: endPtr = &data[ins];
54829: assert( (SQLITE_PTR_TO_INT(ptr)&1)==0 ); /* ptr is always 2-byte aligned */
54830: while( ptr>endPtr ){
54831: *(u16*)ptr = *(u16*)&ptr[-2];
54832: ptr -= 2;
54833: }
54834: put2byte(&data[ins], idx);
54835: put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
54836: #ifndef SQLITE_OMIT_AUTOVACUUM
54837: if( pPage->pBt->autoVacuum ){
54838: /* The cell may contain a pointer to an overflow page. If so, write
54839: ** the entry for the overflow page into the pointer map.
54840: */
54841: ptrmapPutOvflPtr(pPage, pCell, pRC);
54842: }
54843: #endif
54844: }
54845: }
54846:
54847: /*
54848: ** Add a list of cells to a page. The page should be initially empty.
54849: ** The cells are guaranteed to fit on the page.
54850: */
54851: static void assemblePage(
54852: MemPage *pPage, /* The page to be assemblied */
54853: int nCell, /* The number of cells to add to this page */
54854: u8 **apCell, /* Pointers to cell bodies */
54855: u16 *aSize /* Sizes of the cells */
54856: ){
54857: int i; /* Loop counter */
54858: u8 *pCellptr; /* Address of next cell pointer */
54859: int cellbody; /* Address of next cell body */
54860: u8 * const data = pPage->aData; /* Pointer to data for pPage */
54861: const int hdr = pPage->hdrOffset; /* Offset of header on pPage */
54862: const int nUsable = pPage->pBt->usableSize; /* Usable size of page */
54863:
54864: assert( pPage->nOverflow==0 );
54865: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54866: assert( nCell>=0 && nCell<=(int)MX_CELL(pPage->pBt)
54867: && (int)MX_CELL(pPage->pBt)<=10921);
54868: assert( sqlite3PagerIswriteable(pPage->pDbPage) );
54869:
54870: /* Check that the page has just been zeroed by zeroPage() */
54871: assert( pPage->nCell==0 );
54872: assert( get2byteNotZero(&data[hdr+5])==nUsable );
54873:
54874: pCellptr = &pPage->aCellIdx[nCell*2];
54875: cellbody = nUsable;
54876: for(i=nCell-1; i>=0; i--){
54877: u16 sz = aSize[i];
54878: pCellptr -= 2;
54879: cellbody -= sz;
54880: put2byte(pCellptr, cellbody);
54881: memcpy(&data[cellbody], apCell[i], sz);
54882: }
54883: put2byte(&data[hdr+3], nCell);
54884: put2byte(&data[hdr+5], cellbody);
54885: pPage->nFree -= (nCell*2 + nUsable - cellbody);
54886: pPage->nCell = (u16)nCell;
54887: }
54888:
54889: /*
54890: ** The following parameters determine how many adjacent pages get involved
54891: ** in a balancing operation. NN is the number of neighbors on either side
54892: ** of the page that participate in the balancing operation. NB is the
54893: ** total number of pages that participate, including the target page and
54894: ** NN neighbors on either side.
54895: **
54896: ** The minimum value of NN is 1 (of course). Increasing NN above 1
54897: ** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance
54898: ** in exchange for a larger degradation in INSERT and UPDATE performance.
54899: ** The value of NN appears to give the best results overall.
54900: */
54901: #define NN 1 /* Number of neighbors on either side of pPage */
54902: #define NB (NN*2+1) /* Total pages involved in the balance */
54903:
54904:
54905: #ifndef SQLITE_OMIT_QUICKBALANCE
54906: /*
54907: ** This version of balance() handles the common special case where
54908: ** a new entry is being inserted on the extreme right-end of the
54909: ** tree, in other words, when the new entry will become the largest
54910: ** entry in the tree.
54911: **
54912: ** Instead of trying to balance the 3 right-most leaf pages, just add
54913: ** a new page to the right-hand side and put the one new entry in
54914: ** that page. This leaves the right side of the tree somewhat
54915: ** unbalanced. But odds are that we will be inserting new entries
54916: ** at the end soon afterwards so the nearly empty page will quickly
54917: ** fill up. On average.
54918: **
54919: ** pPage is the leaf page which is the right-most page in the tree.
54920: ** pParent is its parent. pPage must have a single overflow entry
54921: ** which is also the right-most entry on the page.
54922: **
54923: ** The pSpace buffer is used to store a temporary copy of the divider
54924: ** cell that will be inserted into pParent. Such a cell consists of a 4
54925: ** byte page number followed by a variable length integer. In other
54926: ** words, at most 13 bytes. Hence the pSpace buffer must be at
54927: ** least 13 bytes in size.
54928: */
54929: static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
54930: BtShared *const pBt = pPage->pBt; /* B-Tree Database */
54931: MemPage *pNew; /* Newly allocated page */
54932: int rc; /* Return Code */
54933: Pgno pgnoNew; /* Page number of pNew */
54934:
54935: assert( sqlite3_mutex_held(pPage->pBt->mutex) );
54936: assert( sqlite3PagerIswriteable(pParent->pDbPage) );
54937: assert( pPage->nOverflow==1 );
54938:
54939: /* This error condition is now caught prior to reaching this function */
54940: if( pPage->nCell<=0 ) return SQLITE_CORRUPT_BKPT;
54941:
54942: /* Allocate a new page. This page will become the right-sibling of
54943: ** pPage. Make the parent page writable, so that the new divider cell
54944: ** may be inserted. If both these operations are successful, proceed.
54945: */
54946: rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
54947:
54948: if( rc==SQLITE_OK ){
54949:
54950: u8 *pOut = &pSpace[4];
54951: u8 *pCell = pPage->aOvfl[0].pCell;
54952: u16 szCell = cellSizePtr(pPage, pCell);
54953: u8 *pStop;
54954:
54955: assert( sqlite3PagerIswriteable(pNew->pDbPage) );
54956: assert( pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
54957: zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF);
54958: assemblePage(pNew, 1, &pCell, &szCell);
54959:
54960: /* If this is an auto-vacuum database, update the pointer map
54961: ** with entries for the new page, and any pointer from the
54962: ** cell on the page to an overflow page. If either of these
54963: ** operations fails, the return code is set, but the contents
54964: ** of the parent page are still manipulated by thh code below.
54965: ** That is Ok, at this point the parent page is guaranteed to
54966: ** be marked as dirty. Returning an error code will cause a
54967: ** rollback, undoing any changes made to the parent page.
54968: */
54969: if( ISAUTOVACUUM ){
54970: ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
54971: if( szCell>pNew->minLocal ){
54972: ptrmapPutOvflPtr(pNew, pCell, &rc);
54973: }
54974: }
54975:
54976: /* Create a divider cell to insert into pParent. The divider cell
54977: ** consists of a 4-byte page number (the page number of pPage) and
54978: ** a variable length key value (which must be the same value as the
54979: ** largest key on pPage).
54980: **
54981: ** To find the largest key value on pPage, first find the right-most
54982: ** cell on pPage. The first two fields of this cell are the
54983: ** record-length (a variable length integer at most 32-bits in size)
54984: ** and the key value (a variable length integer, may have any value).
54985: ** The first of the while(...) loops below skips over the record-length
54986: ** field. The second while(...) loop copies the key value from the
54987: ** cell on pPage into the pSpace buffer.
54988: */
54989: pCell = findCell(pPage, pPage->nCell-1);
54990: pStop = &pCell[9];
54991: while( (*(pCell++)&0x80) && pCell<pStop );
54992: pStop = &pCell[9];
54993: while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
54994:
54995: /* Insert the new divider cell into pParent. */
54996: insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
54997: 0, pPage->pgno, &rc);
54998:
54999: /* Set the right-child pointer of pParent to point to the new page. */
55000: put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
55001:
55002: /* Release the reference to the new page. */
55003: releasePage(pNew);
55004: }
55005:
55006: return rc;
55007: }
55008: #endif /* SQLITE_OMIT_QUICKBALANCE */
55009:
55010: #if 0
55011: /*
55012: ** This function does not contribute anything to the operation of SQLite.
55013: ** it is sometimes activated temporarily while debugging code responsible
55014: ** for setting pointer-map entries.
55015: */
55016: static int ptrmapCheckPages(MemPage **apPage, int nPage){
55017: int i, j;
55018: for(i=0; i<nPage; i++){
55019: Pgno n;
55020: u8 e;
55021: MemPage *pPage = apPage[i];
55022: BtShared *pBt = pPage->pBt;
55023: assert( pPage->isInit );
55024:
55025: for(j=0; j<pPage->nCell; j++){
55026: CellInfo info;
55027: u8 *z;
55028:
55029: z = findCell(pPage, j);
55030: btreeParseCellPtr(pPage, z, &info);
55031: if( info.iOverflow ){
55032: Pgno ovfl = get4byte(&z[info.iOverflow]);
55033: ptrmapGet(pBt, ovfl, &e, &n);
55034: assert( n==pPage->pgno && e==PTRMAP_OVERFLOW1 );
55035: }
55036: if( !pPage->leaf ){
55037: Pgno child = get4byte(z);
55038: ptrmapGet(pBt, child, &e, &n);
55039: assert( n==pPage->pgno && e==PTRMAP_BTREE );
55040: }
55041: }
55042: if( !pPage->leaf ){
55043: Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
55044: ptrmapGet(pBt, child, &e, &n);
55045: assert( n==pPage->pgno && e==PTRMAP_BTREE );
55046: }
55047: }
55048: return 1;
55049: }
55050: #endif
55051:
55052: /*
55053: ** This function is used to copy the contents of the b-tree node stored
55054: ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
55055: ** the pointer-map entries for each child page are updated so that the
55056: ** parent page stored in the pointer map is page pTo. If pFrom contained
55057: ** any cells with overflow page pointers, then the corresponding pointer
55058: ** map entries are also updated so that the parent page is page pTo.
55059: **
55060: ** If pFrom is currently carrying any overflow cells (entries in the
55061: ** MemPage.aOvfl[] array), they are not copied to pTo.
55062: **
55063: ** Before returning, page pTo is reinitialized using btreeInitPage().
55064: **
55065: ** The performance of this function is not critical. It is only used by
55066: ** the balance_shallower() and balance_deeper() procedures, neither of
55067: ** which are called often under normal circumstances.
55068: */
55069: static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
55070: if( (*pRC)==SQLITE_OK ){
55071: BtShared * const pBt = pFrom->pBt;
55072: u8 * const aFrom = pFrom->aData;
55073: u8 * const aTo = pTo->aData;
55074: int const iFromHdr = pFrom->hdrOffset;
55075: int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
55076: int rc;
55077: int iData;
55078:
55079:
55080: assert( pFrom->isInit );
55081: assert( pFrom->nFree>=iToHdr );
55082: assert( get2byte(&aFrom[iFromHdr+5]) <= (int)pBt->usableSize );
55083:
55084: /* Copy the b-tree node content from page pFrom to page pTo. */
55085: iData = get2byte(&aFrom[iFromHdr+5]);
55086: memcpy(&aTo[iData], &aFrom[iData], pBt->usableSize-iData);
55087: memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
55088:
55089: /* Reinitialize page pTo so that the contents of the MemPage structure
55090: ** match the new data. The initialization of pTo can actually fail under
55091: ** fairly obscure circumstances, even though it is a copy of initialized
55092: ** page pFrom.
55093: */
55094: pTo->isInit = 0;
55095: rc = btreeInitPage(pTo);
55096: if( rc!=SQLITE_OK ){
55097: *pRC = rc;
55098: return;
55099: }
55100:
55101: /* If this is an auto-vacuum database, update the pointer-map entries
55102: ** for any b-tree or overflow pages that pTo now contains the pointers to.
55103: */
55104: if( ISAUTOVACUUM ){
55105: *pRC = setChildPtrmaps(pTo);
55106: }
55107: }
55108: }
55109:
55110: /*
55111: ** This routine redistributes cells on the iParentIdx'th child of pParent
55112: ** (hereafter "the page") and up to 2 siblings so that all pages have about the
55113: ** same amount of free space. Usually a single sibling on either side of the
55114: ** page are used in the balancing, though both siblings might come from one
55115: ** side if the page is the first or last child of its parent. If the page
55116: ** has fewer than 2 siblings (something which can only happen if the page
55117: ** is a root page or a child of a root page) then all available siblings
55118: ** participate in the balancing.
55119: **
55120: ** The number of siblings of the page might be increased or decreased by
55121: ** one or two in an effort to keep pages nearly full but not over full.
55122: **
55123: ** Note that when this routine is called, some of the cells on the page
55124: ** might not actually be stored in MemPage.aData[]. This can happen
55125: ** if the page is overfull. This routine ensures that all cells allocated
55126: ** to the page and its siblings fit into MemPage.aData[] before returning.
55127: **
55128: ** In the course of balancing the page and its siblings, cells may be
55129: ** inserted into or removed from the parent page (pParent). Doing so
55130: ** may cause the parent page to become overfull or underfull. If this
55131: ** happens, it is the responsibility of the caller to invoke the correct
55132: ** balancing routine to fix this problem (see the balance() routine).
55133: **
55134: ** If this routine fails for any reason, it might leave the database
55135: ** in a corrupted state. So if this routine fails, the database should
55136: ** be rolled back.
55137: **
55138: ** The third argument to this function, aOvflSpace, is a pointer to a
55139: ** buffer big enough to hold one page. If while inserting cells into the parent
55140: ** page (pParent) the parent page becomes overfull, this buffer is
55141: ** used to store the parent's overflow cells. Because this function inserts
55142: ** a maximum of four divider cells into the parent page, and the maximum
55143: ** size of a cell stored within an internal node is always less than 1/4
55144: ** of the page-size, the aOvflSpace[] buffer is guaranteed to be large
55145: ** enough for all overflow cells.
55146: **
55147: ** If aOvflSpace is set to a null pointer, this function returns
55148: ** SQLITE_NOMEM.
55149: */
55150: static int balance_nonroot(
55151: MemPage *pParent, /* Parent page of siblings being balanced */
55152: int iParentIdx, /* Index of "the page" in pParent */
55153: u8 *aOvflSpace, /* page-size bytes of space for parent ovfl */
55154: int isRoot /* True if pParent is a root-page */
55155: ){
55156: BtShared *pBt; /* The whole database */
55157: int nCell = 0; /* Number of cells in apCell[] */
55158: int nMaxCells = 0; /* Allocated size of apCell, szCell, aFrom. */
55159: int nNew = 0; /* Number of pages in apNew[] */
55160: int nOld; /* Number of pages in apOld[] */
55161: int i, j, k; /* Loop counters */
55162: int nxDiv; /* Next divider slot in pParent->aCell[] */
55163: int rc = SQLITE_OK; /* The return code */
55164: u16 leafCorrection; /* 4 if pPage is a leaf. 0 if not */
55165: int leafData; /* True if pPage is a leaf of a LEAFDATA tree */
55166: int usableSpace; /* Bytes in pPage beyond the header */
55167: int pageFlags; /* Value of pPage->aData[0] */
55168: int subtotal; /* Subtotal of bytes in cells on one page */
55169: int iSpace1 = 0; /* First unused byte of aSpace1[] */
55170: int iOvflSpace = 0; /* First unused byte of aOvflSpace[] */
55171: int szScratch; /* Size of scratch memory requested */
55172: MemPage *apOld[NB]; /* pPage and up to two siblings */
55173: MemPage *apCopy[NB]; /* Private copies of apOld[] pages */
55174: MemPage *apNew[NB+2]; /* pPage and up to NB siblings after balancing */
55175: u8 *pRight; /* Location in parent of right-sibling pointer */
55176: u8 *apDiv[NB-1]; /* Divider cells in pParent */
55177: int cntNew[NB+2]; /* Index in aCell[] of cell after i-th page */
55178: int szNew[NB+2]; /* Combined size of cells place on i-th page */
55179: u8 **apCell = 0; /* All cells begin balanced */
55180: u16 *szCell; /* Local size of all cells in apCell[] */
55181: u8 *aSpace1; /* Space for copies of dividers cells */
55182: Pgno pgno; /* Temp var to store a page number in */
55183:
55184: pBt = pParent->pBt;
55185: assert( sqlite3_mutex_held(pBt->mutex) );
55186: assert( sqlite3PagerIswriteable(pParent->pDbPage) );
55187:
55188: #if 0
55189: TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
55190: #endif
55191:
55192: /* At this point pParent may have at most one overflow cell. And if
55193: ** this overflow cell is present, it must be the cell with
55194: ** index iParentIdx. This scenario comes about when this function
55195: ** is called (indirectly) from sqlite3BtreeDelete().
55196: */
55197: assert( pParent->nOverflow==0 || pParent->nOverflow==1 );
55198: assert( pParent->nOverflow==0 || pParent->aOvfl[0].idx==iParentIdx );
55199:
55200: if( !aOvflSpace ){
55201: return SQLITE_NOMEM;
55202: }
55203:
55204: /* Find the sibling pages to balance. Also locate the cells in pParent
55205: ** that divide the siblings. An attempt is made to find NN siblings on
55206: ** either side of pPage. More siblings are taken from one side, however,
55207: ** if there are fewer than NN siblings on the other side. If pParent
55208: ** has NB or fewer children then all children of pParent are taken.
55209: **
55210: ** This loop also drops the divider cells from the parent page. This
55211: ** way, the remainder of the function does not have to deal with any
55212: ** overflow cells in the parent page, since if any existed they will
55213: ** have already been removed.
55214: */
55215: i = pParent->nOverflow + pParent->nCell;
55216: if( i<2 ){
55217: nxDiv = 0;
55218: nOld = i+1;
55219: }else{
55220: nOld = 3;
55221: if( iParentIdx==0 ){
55222: nxDiv = 0;
55223: }else if( iParentIdx==i ){
55224: nxDiv = i-2;
55225: }else{
55226: nxDiv = iParentIdx-1;
55227: }
55228: i = 2;
55229: }
55230: if( (i+nxDiv-pParent->nOverflow)==pParent->nCell ){
55231: pRight = &pParent->aData[pParent->hdrOffset+8];
55232: }else{
55233: pRight = findCell(pParent, i+nxDiv-pParent->nOverflow);
55234: }
55235: pgno = get4byte(pRight);
55236: while( 1 ){
55237: rc = getAndInitPage(pBt, pgno, &apOld[i]);
55238: if( rc ){
55239: memset(apOld, 0, (i+1)*sizeof(MemPage*));
55240: goto balance_cleanup;
55241: }
55242: nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
55243: if( (i--)==0 ) break;
55244:
55245: if( i+nxDiv==pParent->aOvfl[0].idx && pParent->nOverflow ){
55246: apDiv[i] = pParent->aOvfl[0].pCell;
55247: pgno = get4byte(apDiv[i]);
55248: szNew[i] = cellSizePtr(pParent, apDiv[i]);
55249: pParent->nOverflow = 0;
55250: }else{
55251: apDiv[i] = findCell(pParent, i+nxDiv-pParent->nOverflow);
55252: pgno = get4byte(apDiv[i]);
55253: szNew[i] = cellSizePtr(pParent, apDiv[i]);
55254:
55255: /* Drop the cell from the parent page. apDiv[i] still points to
55256: ** the cell within the parent, even though it has been dropped.
55257: ** This is safe because dropping a cell only overwrites the first
55258: ** four bytes of it, and this function does not need the first
55259: ** four bytes of the divider cell. So the pointer is safe to use
55260: ** later on.
55261: **
55262: ** But not if we are in secure-delete mode. In secure-delete mode,
55263: ** the dropCell() routine will overwrite the entire cell with zeroes.
55264: ** In this case, temporarily copy the cell into the aOvflSpace[]
55265: ** buffer. It will be copied out again as soon as the aSpace[] buffer
55266: ** is allocated. */
55267: if( pBt->btsFlags & BTS_SECURE_DELETE ){
55268: int iOff;
55269:
55270: iOff = SQLITE_PTR_TO_INT(apDiv[i]) - SQLITE_PTR_TO_INT(pParent->aData);
55271: if( (iOff+szNew[i])>(int)pBt->usableSize ){
55272: rc = SQLITE_CORRUPT_BKPT;
55273: memset(apOld, 0, (i+1)*sizeof(MemPage*));
55274: goto balance_cleanup;
55275: }else{
55276: memcpy(&aOvflSpace[iOff], apDiv[i], szNew[i]);
55277: apDiv[i] = &aOvflSpace[apDiv[i]-pParent->aData];
55278: }
55279: }
55280: dropCell(pParent, i+nxDiv-pParent->nOverflow, szNew[i], &rc);
55281: }
55282: }
55283:
55284: /* Make nMaxCells a multiple of 4 in order to preserve 8-byte
55285: ** alignment */
55286: nMaxCells = (nMaxCells + 3)&~3;
55287:
55288: /*
55289: ** Allocate space for memory structures
55290: */
55291: k = pBt->pageSize + ROUND8(sizeof(MemPage));
55292: szScratch =
55293: nMaxCells*sizeof(u8*) /* apCell */
55294: + nMaxCells*sizeof(u16) /* szCell */
55295: + pBt->pageSize /* aSpace1 */
55296: + k*nOld; /* Page copies (apCopy) */
55297: apCell = sqlite3ScratchMalloc( szScratch );
55298: if( apCell==0 ){
55299: rc = SQLITE_NOMEM;
55300: goto balance_cleanup;
55301: }
55302: szCell = (u16*)&apCell[nMaxCells];
55303: aSpace1 = (u8*)&szCell[nMaxCells];
55304: assert( EIGHT_BYTE_ALIGNMENT(aSpace1) );
55305:
55306: /*
55307: ** Load pointers to all cells on sibling pages and the divider cells
55308: ** into the local apCell[] array. Make copies of the divider cells
55309: ** into space obtained from aSpace1[] and remove the the divider Cells
55310: ** from pParent.
55311: **
55312: ** If the siblings are on leaf pages, then the child pointers of the
55313: ** divider cells are stripped from the cells before they are copied
55314: ** into aSpace1[]. In this way, all cells in apCell[] are without
55315: ** child pointers. If siblings are not leaves, then all cell in
55316: ** apCell[] include child pointers. Either way, all cells in apCell[]
55317: ** are alike.
55318: **
55319: ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
55320: ** leafData: 1 if pPage holds key+data and pParent holds only keys.
55321: */
55322: leafCorrection = apOld[0]->leaf*4;
55323: leafData = apOld[0]->hasData;
55324: for(i=0; i<nOld; i++){
55325: int limit;
55326:
55327: /* Before doing anything else, take a copy of the i'th original sibling
55328: ** The rest of this function will use data from the copies rather
55329: ** that the original pages since the original pages will be in the
55330: ** process of being overwritten. */
55331: MemPage *pOld = apCopy[i] = (MemPage*)&aSpace1[pBt->pageSize + k*i];
55332: memcpy(pOld, apOld[i], sizeof(MemPage));
55333: pOld->aData = (void*)&pOld[1];
55334: memcpy(pOld->aData, apOld[i]->aData, pBt->pageSize);
55335:
55336: limit = pOld->nCell+pOld->nOverflow;
55337: if( pOld->nOverflow>0 ){
55338: for(j=0; j<limit; j++){
55339: assert( nCell<nMaxCells );
55340: apCell[nCell] = findOverflowCell(pOld, j);
55341: szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
55342: nCell++;
55343: }
55344: }else{
55345: u8 *aData = pOld->aData;
55346: u16 maskPage = pOld->maskPage;
55347: u16 cellOffset = pOld->cellOffset;
55348: for(j=0; j<limit; j++){
55349: assert( nCell<nMaxCells );
55350: apCell[nCell] = findCellv2(aData, maskPage, cellOffset, j);
55351: szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
55352: nCell++;
55353: }
55354: }
55355: if( i<nOld-1 && !leafData){
55356: u16 sz = (u16)szNew[i];
55357: u8 *pTemp;
55358: assert( nCell<nMaxCells );
55359: szCell[nCell] = sz;
55360: pTemp = &aSpace1[iSpace1];
55361: iSpace1 += sz;
55362: assert( sz<=pBt->maxLocal+23 );
55363: assert( iSpace1 <= (int)pBt->pageSize );
55364: memcpy(pTemp, apDiv[i], sz);
55365: apCell[nCell] = pTemp+leafCorrection;
55366: assert( leafCorrection==0 || leafCorrection==4 );
55367: szCell[nCell] = szCell[nCell] - leafCorrection;
55368: if( !pOld->leaf ){
55369: assert( leafCorrection==0 );
55370: assert( pOld->hdrOffset==0 );
55371: /* The right pointer of the child page pOld becomes the left
55372: ** pointer of the divider cell */
55373: memcpy(apCell[nCell], &pOld->aData[8], 4);
55374: }else{
55375: assert( leafCorrection==4 );
55376: if( szCell[nCell]<4 ){
55377: /* Do not allow any cells smaller than 4 bytes. */
55378: szCell[nCell] = 4;
55379: }
55380: }
55381: nCell++;
55382: }
55383: }
55384:
55385: /*
55386: ** Figure out the number of pages needed to hold all nCell cells.
55387: ** Store this number in "k". Also compute szNew[] which is the total
55388: ** size of all cells on the i-th page and cntNew[] which is the index
55389: ** in apCell[] of the cell that divides page i from page i+1.
55390: ** cntNew[k] should equal nCell.
55391: **
55392: ** Values computed by this block:
55393: **
55394: ** k: The total number of sibling pages
55395: ** szNew[i]: Spaced used on the i-th sibling page.
55396: ** cntNew[i]: Index in apCell[] and szCell[] for the first cell to
55397: ** the right of the i-th sibling page.
55398: ** usableSpace: Number of bytes of space available on each sibling.
55399: **
55400: */
55401: usableSpace = pBt->usableSize - 12 + leafCorrection;
55402: for(subtotal=k=i=0; i<nCell; i++){
55403: assert( i<nMaxCells );
55404: subtotal += szCell[i] + 2;
55405: if( subtotal > usableSpace ){
55406: szNew[k] = subtotal - szCell[i];
55407: cntNew[k] = i;
55408: if( leafData ){ i--; }
55409: subtotal = 0;
55410: k++;
55411: if( k>NB+1 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; }
55412: }
55413: }
55414: szNew[k] = subtotal;
55415: cntNew[k] = nCell;
55416: k++;
55417:
55418: /*
55419: ** The packing computed by the previous block is biased toward the siblings
55420: ** on the left side. The left siblings are always nearly full, while the
55421: ** right-most sibling might be nearly empty. This block of code attempts
55422: ** to adjust the packing of siblings to get a better balance.
55423: **
55424: ** This adjustment is more than an optimization. The packing above might
55425: ** be so out of balance as to be illegal. For example, the right-most
55426: ** sibling might be completely empty. This adjustment is not optional.
55427: */
55428: for(i=k-1; i>0; i--){
55429: int szRight = szNew[i]; /* Size of sibling on the right */
55430: int szLeft = szNew[i-1]; /* Size of sibling on the left */
55431: int r; /* Index of right-most cell in left sibling */
55432: int d; /* Index of first cell to the left of right sibling */
55433:
55434: r = cntNew[i-1] - 1;
55435: d = r + 1 - leafData;
55436: assert( d<nMaxCells );
55437: assert( r<nMaxCells );
55438: while( szRight==0 || szRight+szCell[d]+2<=szLeft-(szCell[r]+2) ){
55439: szRight += szCell[d] + 2;
55440: szLeft -= szCell[r] + 2;
55441: cntNew[i-1]--;
55442: r = cntNew[i-1] - 1;
55443: d = r + 1 - leafData;
55444: }
55445: szNew[i] = szRight;
55446: szNew[i-1] = szLeft;
55447: }
55448:
55449: /* Either we found one or more cells (cntnew[0])>0) or pPage is
55450: ** a virtual root page. A virtual root page is when the real root
55451: ** page is page 1 and we are the only child of that page.
55452: **
55453: ** UPDATE: The assert() below is not necessarily true if the database
55454: ** file is corrupt. The corruption will be detected and reported later
55455: ** in this procedure so there is no need to act upon it now.
55456: */
55457: #if 0
55458: assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
55459: #endif
55460:
55461: TRACE(("BALANCE: old: %d %d %d ",
55462: apOld[0]->pgno,
55463: nOld>=2 ? apOld[1]->pgno : 0,
55464: nOld>=3 ? apOld[2]->pgno : 0
55465: ));
55466:
55467: /*
55468: ** Allocate k new pages. Reuse old pages where possible.
55469: */
55470: if( apOld[0]->pgno<=1 ){
55471: rc = SQLITE_CORRUPT_BKPT;
55472: goto balance_cleanup;
55473: }
55474: pageFlags = apOld[0]->aData[0];
55475: for(i=0; i<k; i++){
55476: MemPage *pNew;
55477: if( i<nOld ){
55478: pNew = apNew[i] = apOld[i];
55479: apOld[i] = 0;
55480: rc = sqlite3PagerWrite(pNew->pDbPage);
55481: nNew++;
55482: if( rc ) goto balance_cleanup;
55483: }else{
55484: assert( i>0 );
55485: rc = allocateBtreePage(pBt, &pNew, &pgno, pgno, 0);
55486: if( rc ) goto balance_cleanup;
55487: apNew[i] = pNew;
55488: nNew++;
55489:
55490: /* Set the pointer-map entry for the new sibling page. */
55491: if( ISAUTOVACUUM ){
55492: ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno, &rc);
55493: if( rc!=SQLITE_OK ){
55494: goto balance_cleanup;
55495: }
55496: }
55497: }
55498: }
55499:
55500: /* Free any old pages that were not reused as new pages.
55501: */
55502: while( i<nOld ){
55503: freePage(apOld[i], &rc);
55504: if( rc ) goto balance_cleanup;
55505: releasePage(apOld[i]);
55506: apOld[i] = 0;
55507: i++;
55508: }
55509:
55510: /*
55511: ** Put the new pages in accending order. This helps to
55512: ** keep entries in the disk file in order so that a scan
55513: ** of the table is a linear scan through the file. That
55514: ** in turn helps the operating system to deliver pages
55515: ** from the disk more rapidly.
55516: **
55517: ** An O(n^2) insertion sort algorithm is used, but since
55518: ** n is never more than NB (a small constant), that should
55519: ** not be a problem.
55520: **
55521: ** When NB==3, this one optimization makes the database
55522: ** about 25% faster for large insertions and deletions.
55523: */
55524: for(i=0; i<k-1; i++){
55525: int minV = apNew[i]->pgno;
55526: int minI = i;
55527: for(j=i+1; j<k; j++){
55528: if( apNew[j]->pgno<(unsigned)minV ){
55529: minI = j;
55530: minV = apNew[j]->pgno;
55531: }
55532: }
55533: if( minI>i ){
55534: MemPage *pT;
55535: pT = apNew[i];
55536: apNew[i] = apNew[minI];
55537: apNew[minI] = pT;
55538: }
55539: }
55540: TRACE(("new: %d(%d) %d(%d) %d(%d) %d(%d) %d(%d)\n",
55541: apNew[0]->pgno, szNew[0],
55542: nNew>=2 ? apNew[1]->pgno : 0, nNew>=2 ? szNew[1] : 0,
55543: nNew>=3 ? apNew[2]->pgno : 0, nNew>=3 ? szNew[2] : 0,
55544: nNew>=4 ? apNew[3]->pgno : 0, nNew>=4 ? szNew[3] : 0,
55545: nNew>=5 ? apNew[4]->pgno : 0, nNew>=5 ? szNew[4] : 0));
55546:
55547: assert( sqlite3PagerIswriteable(pParent->pDbPage) );
55548: put4byte(pRight, apNew[nNew-1]->pgno);
55549:
55550: /*
55551: ** Evenly distribute the data in apCell[] across the new pages.
55552: ** Insert divider cells into pParent as necessary.
55553: */
55554: j = 0;
55555: for(i=0; i<nNew; i++){
55556: /* Assemble the new sibling page. */
55557: MemPage *pNew = apNew[i];
55558: assert( j<nMaxCells );
55559: zeroPage(pNew, pageFlags);
55560: assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]);
55561: assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
55562: assert( pNew->nOverflow==0 );
55563:
55564: j = cntNew[i];
55565:
55566: /* If the sibling page assembled above was not the right-most sibling,
55567: ** insert a divider cell into the parent page.
55568: */
55569: assert( i<nNew-1 || j==nCell );
55570: if( j<nCell ){
55571: u8 *pCell;
55572: u8 *pTemp;
55573: int sz;
55574:
55575: assert( j<nMaxCells );
55576: pCell = apCell[j];
55577: sz = szCell[j] + leafCorrection;
55578: pTemp = &aOvflSpace[iOvflSpace];
55579: if( !pNew->leaf ){
55580: memcpy(&pNew->aData[8], pCell, 4);
55581: }else if( leafData ){
55582: /* If the tree is a leaf-data tree, and the siblings are leaves,
55583: ** then there is no divider cell in apCell[]. Instead, the divider
55584: ** cell consists of the integer key for the right-most cell of
55585: ** the sibling-page assembled above only.
55586: */
55587: CellInfo info;
55588: j--;
55589: btreeParseCellPtr(pNew, apCell[j], &info);
55590: pCell = pTemp;
55591: sz = 4 + putVarint(&pCell[4], info.nKey);
55592: pTemp = 0;
55593: }else{
55594: pCell -= 4;
55595: /* Obscure case for non-leaf-data trees: If the cell at pCell was
55596: ** previously stored on a leaf node, and its reported size was 4
55597: ** bytes, then it may actually be smaller than this
55598: ** (see btreeParseCellPtr(), 4 bytes is the minimum size of
55599: ** any cell). But it is important to pass the correct size to
55600: ** insertCell(), so reparse the cell now.
55601: **
55602: ** Note that this can never happen in an SQLite data file, as all
55603: ** cells are at least 4 bytes. It only happens in b-trees used
55604: ** to evaluate "IN (SELECT ...)" and similar clauses.
55605: */
55606: if( szCell[j]==4 ){
55607: assert(leafCorrection==4);
55608: sz = cellSizePtr(pParent, pCell);
55609: }
55610: }
55611: iOvflSpace += sz;
55612: assert( sz<=pBt->maxLocal+23 );
55613: assert( iOvflSpace <= (int)pBt->pageSize );
55614: insertCell(pParent, nxDiv, pCell, sz, pTemp, pNew->pgno, &rc);
55615: if( rc!=SQLITE_OK ) goto balance_cleanup;
55616: assert( sqlite3PagerIswriteable(pParent->pDbPage) );
55617:
55618: j++;
55619: nxDiv++;
55620: }
55621: }
55622: assert( j==nCell );
55623: assert( nOld>0 );
55624: assert( nNew>0 );
55625: if( (pageFlags & PTF_LEAF)==0 ){
55626: u8 *zChild = &apCopy[nOld-1]->aData[8];
55627: memcpy(&apNew[nNew-1]->aData[8], zChild, 4);
55628: }
55629:
55630: if( isRoot && pParent->nCell==0 && pParent->hdrOffset<=apNew[0]->nFree ){
55631: /* The root page of the b-tree now contains no cells. The only sibling
55632: ** page is the right-child of the parent. Copy the contents of the
55633: ** child page into the parent, decreasing the overall height of the
55634: ** b-tree structure by one. This is described as the "balance-shallower"
55635: ** sub-algorithm in some documentation.
55636: **
55637: ** If this is an auto-vacuum database, the call to copyNodeContent()
55638: ** sets all pointer-map entries corresponding to database image pages
55639: ** for which the pointer is stored within the content being copied.
55640: **
55641: ** The second assert below verifies that the child page is defragmented
55642: ** (it must be, as it was just reconstructed using assemblePage()). This
55643: ** is important if the parent page happens to be page 1 of the database
55644: ** image. */
55645: assert( nNew==1 );
55646: assert( apNew[0]->nFree ==
55647: (get2byte(&apNew[0]->aData[5])-apNew[0]->cellOffset-apNew[0]->nCell*2)
55648: );
55649: copyNodeContent(apNew[0], pParent, &rc);
55650: freePage(apNew[0], &rc);
55651: }else if( ISAUTOVACUUM ){
55652: /* Fix the pointer-map entries for all the cells that were shifted around.
55653: ** There are several different types of pointer-map entries that need to
55654: ** be dealt with by this routine. Some of these have been set already, but
55655: ** many have not. The following is a summary:
55656: **
55657: ** 1) The entries associated with new sibling pages that were not
55658: ** siblings when this function was called. These have already
55659: ** been set. We don't need to worry about old siblings that were
55660: ** moved to the free-list - the freePage() code has taken care
55661: ** of those.
55662: **
55663: ** 2) The pointer-map entries associated with the first overflow
55664: ** page in any overflow chains used by new divider cells. These
55665: ** have also already been taken care of by the insertCell() code.
55666: **
55667: ** 3) If the sibling pages are not leaves, then the child pages of
55668: ** cells stored on the sibling pages may need to be updated.
55669: **
55670: ** 4) If the sibling pages are not internal intkey nodes, then any
55671: ** overflow pages used by these cells may need to be updated
55672: ** (internal intkey nodes never contain pointers to overflow pages).
55673: **
55674: ** 5) If the sibling pages are not leaves, then the pointer-map
55675: ** entries for the right-child pages of each sibling may need
55676: ** to be updated.
55677: **
55678: ** Cases 1 and 2 are dealt with above by other code. The next
55679: ** block deals with cases 3 and 4 and the one after that, case 5. Since
55680: ** setting a pointer map entry is a relatively expensive operation, this
55681: ** code only sets pointer map entries for child or overflow pages that have
55682: ** actually moved between pages. */
55683: MemPage *pNew = apNew[0];
55684: MemPage *pOld = apCopy[0];
55685: int nOverflow = pOld->nOverflow;
55686: int iNextOld = pOld->nCell + nOverflow;
55687: int iOverflow = (nOverflow ? pOld->aOvfl[0].idx : -1);
55688: j = 0; /* Current 'old' sibling page */
55689: k = 0; /* Current 'new' sibling page */
55690: for(i=0; i<nCell; i++){
55691: int isDivider = 0;
55692: while( i==iNextOld ){
55693: /* Cell i is the cell immediately following the last cell on old
55694: ** sibling page j. If the siblings are not leaf pages of an
55695: ** intkey b-tree, then cell i was a divider cell. */
55696: assert( j+1 < ArraySize(apCopy) );
55697: pOld = apCopy[++j];
55698: iNextOld = i + !leafData + pOld->nCell + pOld->nOverflow;
55699: if( pOld->nOverflow ){
55700: nOverflow = pOld->nOverflow;
55701: iOverflow = i + !leafData + pOld->aOvfl[0].idx;
55702: }
55703: isDivider = !leafData;
55704: }
55705:
55706: assert(nOverflow>0 || iOverflow<i );
55707: assert(nOverflow<2 || pOld->aOvfl[0].idx==pOld->aOvfl[1].idx-1);
55708: assert(nOverflow<3 || pOld->aOvfl[1].idx==pOld->aOvfl[2].idx-1);
55709: if( i==iOverflow ){
55710: isDivider = 1;
55711: if( (--nOverflow)>0 ){
55712: iOverflow++;
55713: }
55714: }
55715:
55716: if( i==cntNew[k] ){
55717: /* Cell i is the cell immediately following the last cell on new
55718: ** sibling page k. If the siblings are not leaf pages of an
55719: ** intkey b-tree, then cell i is a divider cell. */
55720: pNew = apNew[++k];
55721: if( !leafData ) continue;
55722: }
55723: assert( j<nOld );
55724: assert( k<nNew );
55725:
55726: /* If the cell was originally divider cell (and is not now) or
55727: ** an overflow cell, or if the cell was located on a different sibling
55728: ** page before the balancing, then the pointer map entries associated
55729: ** with any child or overflow pages need to be updated. */
55730: if( isDivider || pOld->pgno!=pNew->pgno ){
55731: if( !leafCorrection ){
55732: ptrmapPut(pBt, get4byte(apCell[i]), PTRMAP_BTREE, pNew->pgno, &rc);
55733: }
55734: if( szCell[i]>pNew->minLocal ){
55735: ptrmapPutOvflPtr(pNew, apCell[i], &rc);
55736: }
55737: }
55738: }
55739:
55740: if( !leafCorrection ){
55741: for(i=0; i<nNew; i++){
55742: u32 key = get4byte(&apNew[i]->aData[8]);
55743: ptrmapPut(pBt, key, PTRMAP_BTREE, apNew[i]->pgno, &rc);
55744: }
55745: }
55746:
55747: #if 0
55748: /* The ptrmapCheckPages() contains assert() statements that verify that
55749: ** all pointer map pages are set correctly. This is helpful while
55750: ** debugging. This is usually disabled because a corrupt database may
55751: ** cause an assert() statement to fail. */
55752: ptrmapCheckPages(apNew, nNew);
55753: ptrmapCheckPages(&pParent, 1);
55754: #endif
55755: }
55756:
55757: assert( pParent->isInit );
55758: TRACE(("BALANCE: finished: old=%d new=%d cells=%d\n",
55759: nOld, nNew, nCell));
55760:
55761: /*
55762: ** Cleanup before returning.
55763: */
55764: balance_cleanup:
55765: sqlite3ScratchFree(apCell);
55766: for(i=0; i<nOld; i++){
55767: releasePage(apOld[i]);
55768: }
55769: for(i=0; i<nNew; i++){
55770: releasePage(apNew[i]);
55771: }
55772:
55773: return rc;
55774: }
55775:
55776:
55777: /*
55778: ** This function is called when the root page of a b-tree structure is
55779: ** overfull (has one or more overflow pages).
55780: **
55781: ** A new child page is allocated and the contents of the current root
55782: ** page, including overflow cells, are copied into the child. The root
55783: ** page is then overwritten to make it an empty page with the right-child
55784: ** pointer pointing to the new page.
55785: **
55786: ** Before returning, all pointer-map entries corresponding to pages
55787: ** that the new child-page now contains pointers to are updated. The
55788: ** entry corresponding to the new right-child pointer of the root
55789: ** page is also updated.
55790: **
55791: ** If successful, *ppChild is set to contain a reference to the child
55792: ** page and SQLITE_OK is returned. In this case the caller is required
55793: ** to call releasePage() on *ppChild exactly once. If an error occurs,
55794: ** an error code is returned and *ppChild is set to 0.
55795: */
55796: static int balance_deeper(MemPage *pRoot, MemPage **ppChild){
55797: int rc; /* Return value from subprocedures */
55798: MemPage *pChild = 0; /* Pointer to a new child page */
55799: Pgno pgnoChild = 0; /* Page number of the new child page */
55800: BtShared *pBt = pRoot->pBt; /* The BTree */
55801:
55802: assert( pRoot->nOverflow>0 );
55803: assert( sqlite3_mutex_held(pBt->mutex) );
55804:
55805: /* Make pRoot, the root page of the b-tree, writable. Allocate a new
55806: ** page that will become the new right-child of pPage. Copy the contents
55807: ** of the node stored on pRoot into the new child page.
55808: */
55809: rc = sqlite3PagerWrite(pRoot->pDbPage);
55810: if( rc==SQLITE_OK ){
55811: rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
55812: copyNodeContent(pRoot, pChild, &rc);
55813: if( ISAUTOVACUUM ){
55814: ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
55815: }
55816: }
55817: if( rc ){
55818: *ppChild = 0;
55819: releasePage(pChild);
55820: return rc;
55821: }
55822: assert( sqlite3PagerIswriteable(pChild->pDbPage) );
55823: assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
55824: assert( pChild->nCell==pRoot->nCell );
55825:
55826: TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));
55827:
55828: /* Copy the overflow cells from pRoot to pChild */
55829: memcpy(pChild->aOvfl, pRoot->aOvfl, pRoot->nOverflow*sizeof(pRoot->aOvfl[0]));
55830: pChild->nOverflow = pRoot->nOverflow;
55831:
55832: /* Zero the contents of pRoot. Then install pChild as the right-child. */
55833: zeroPage(pRoot, pChild->aData[0] & ~PTF_LEAF);
55834: put4byte(&pRoot->aData[pRoot->hdrOffset+8], pgnoChild);
55835:
55836: *ppChild = pChild;
55837: return SQLITE_OK;
55838: }
55839:
55840: /*
55841: ** The page that pCur currently points to has just been modified in
55842: ** some way. This function figures out if this modification means the
55843: ** tree needs to be balanced, and if so calls the appropriate balancing
55844: ** routine. Balancing routines are:
55845: **
55846: ** balance_quick()
55847: ** balance_deeper()
55848: ** balance_nonroot()
55849: */
55850: static int balance(BtCursor *pCur){
55851: int rc = SQLITE_OK;
55852: const int nMin = pCur->pBt->usableSize * 2 / 3;
55853: u8 aBalanceQuickSpace[13];
55854: u8 *pFree = 0;
55855:
55856: TESTONLY( int balance_quick_called = 0 );
55857: TESTONLY( int balance_deeper_called = 0 );
55858:
55859: do {
55860: int iPage = pCur->iPage;
55861: MemPage *pPage = pCur->apPage[iPage];
55862:
55863: if( iPage==0 ){
55864: if( pPage->nOverflow ){
55865: /* The root page of the b-tree is overfull. In this case call the
55866: ** balance_deeper() function to create a new child for the root-page
55867: ** and copy the current contents of the root-page to it. The
55868: ** next iteration of the do-loop will balance the child page.
55869: */
55870: assert( (balance_deeper_called++)==0 );
55871: rc = balance_deeper(pPage, &pCur->apPage[1]);
55872: if( rc==SQLITE_OK ){
55873: pCur->iPage = 1;
55874: pCur->aiIdx[0] = 0;
55875: pCur->aiIdx[1] = 0;
55876: assert( pCur->apPage[1]->nOverflow );
55877: }
55878: }else{
55879: break;
55880: }
55881: }else if( pPage->nOverflow==0 && pPage->nFree<=nMin ){
55882: break;
55883: }else{
55884: MemPage * const pParent = pCur->apPage[iPage-1];
55885: int const iIdx = pCur->aiIdx[iPage-1];
55886:
55887: rc = sqlite3PagerWrite(pParent->pDbPage);
55888: if( rc==SQLITE_OK ){
55889: #ifndef SQLITE_OMIT_QUICKBALANCE
55890: if( pPage->hasData
55891: && pPage->nOverflow==1
55892: && pPage->aOvfl[0].idx==pPage->nCell
55893: && pParent->pgno!=1
55894: && pParent->nCell==iIdx
55895: ){
55896: /* Call balance_quick() to create a new sibling of pPage on which
55897: ** to store the overflow cell. balance_quick() inserts a new cell
55898: ** into pParent, which may cause pParent overflow. If this
55899: ** happens, the next interation of the do-loop will balance pParent
55900: ** use either balance_nonroot() or balance_deeper(). Until this
55901: ** happens, the overflow cell is stored in the aBalanceQuickSpace[]
55902: ** buffer.
55903: **
55904: ** The purpose of the following assert() is to check that only a
55905: ** single call to balance_quick() is made for each call to this
55906: ** function. If this were not verified, a subtle bug involving reuse
55907: ** of the aBalanceQuickSpace[] might sneak in.
55908: */
55909: assert( (balance_quick_called++)==0 );
55910: rc = balance_quick(pParent, pPage, aBalanceQuickSpace);
55911: }else
55912: #endif
55913: {
55914: /* In this case, call balance_nonroot() to redistribute cells
55915: ** between pPage and up to 2 of its sibling pages. This involves
55916: ** modifying the contents of pParent, which may cause pParent to
55917: ** become overfull or underfull. The next iteration of the do-loop
55918: ** will balance the parent page to correct this.
55919: **
55920: ** If the parent page becomes overfull, the overflow cell or cells
55921: ** are stored in the pSpace buffer allocated immediately below.
55922: ** A subsequent iteration of the do-loop will deal with this by
55923: ** calling balance_nonroot() (balance_deeper() may be called first,
55924: ** but it doesn't deal with overflow cells - just moves them to a
55925: ** different page). Once this subsequent call to balance_nonroot()
55926: ** has completed, it is safe to release the pSpace buffer used by
55927: ** the previous call, as the overflow cell data will have been
55928: ** copied either into the body of a database page or into the new
55929: ** pSpace buffer passed to the latter call to balance_nonroot().
55930: */
55931: u8 *pSpace = sqlite3PageMalloc(pCur->pBt->pageSize);
55932: rc = balance_nonroot(pParent, iIdx, pSpace, iPage==1);
55933: if( pFree ){
55934: /* If pFree is not NULL, it points to the pSpace buffer used
55935: ** by a previous call to balance_nonroot(). Its contents are
55936: ** now stored either on real database pages or within the
55937: ** new pSpace buffer, so it may be safely freed here. */
55938: sqlite3PageFree(pFree);
55939: }
55940:
55941: /* The pSpace buffer will be freed after the next call to
55942: ** balance_nonroot(), or just before this function returns, whichever
55943: ** comes first. */
55944: pFree = pSpace;
55945: }
55946: }
55947:
55948: pPage->nOverflow = 0;
55949:
55950: /* The next iteration of the do-loop balances the parent page. */
55951: releasePage(pPage);
55952: pCur->iPage--;
55953: }
55954: }while( rc==SQLITE_OK );
55955:
55956: if( pFree ){
55957: sqlite3PageFree(pFree);
55958: }
55959: return rc;
55960: }
55961:
55962:
55963: /*
55964: ** Insert a new record into the BTree. The key is given by (pKey,nKey)
55965: ** and the data is given by (pData,nData). The cursor is used only to
55966: ** define what table the record should be inserted into. The cursor
55967: ** is left pointing at a random location.
55968: **
55969: ** For an INTKEY table, only the nKey value of the key is used. pKey is
55970: ** ignored. For a ZERODATA table, the pData and nData are both ignored.
55971: **
55972: ** If the seekResult parameter is non-zero, then a successful call to
55973: ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
55974: ** been performed. seekResult is the search result returned (a negative
55975: ** number if pCur points at an entry that is smaller than (pKey, nKey), or
55976: ** a positive value if pCur points at an etry that is larger than
55977: ** (pKey, nKey)).
55978: **
55979: ** If the seekResult parameter is non-zero, then the caller guarantees that
55980: ** cursor pCur is pointing at the existing copy of a row that is to be
55981: ** overwritten. If the seekResult parameter is 0, then cursor pCur may
55982: ** point to any entry or to no entry at all and so this function has to seek
55983: ** the cursor before the new key can be inserted.
55984: */
55985: SQLITE_PRIVATE int sqlite3BtreeInsert(
55986: BtCursor *pCur, /* Insert data into the table of this cursor */
55987: const void *pKey, i64 nKey, /* The key of the new record */
55988: const void *pData, int nData, /* The data of the new record */
55989: int nZero, /* Number of extra 0 bytes to append to data */
55990: int appendBias, /* True if this is likely an append */
55991: int seekResult /* Result of prior MovetoUnpacked() call */
55992: ){
55993: int rc;
55994: int loc = seekResult; /* -1: before desired location +1: after */
55995: int szNew = 0;
55996: int idx;
55997: MemPage *pPage;
55998: Btree *p = pCur->pBtree;
55999: BtShared *pBt = p->pBt;
56000: unsigned char *oldCell;
56001: unsigned char *newCell = 0;
56002:
56003: if( pCur->eState==CURSOR_FAULT ){
56004: assert( pCur->skipNext!=SQLITE_OK );
56005: return pCur->skipNext;
56006: }
56007:
56008: assert( cursorHoldsMutex(pCur) );
56009: assert( pCur->wrFlag && pBt->inTransaction==TRANS_WRITE
56010: && (pBt->btsFlags & BTS_READ_ONLY)==0 );
56011: assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
56012:
56013: /* Assert that the caller has been consistent. If this cursor was opened
56014: ** expecting an index b-tree, then the caller should be inserting blob
56015: ** keys with no associated data. If the cursor was opened expecting an
56016: ** intkey table, the caller should be inserting integer keys with a
56017: ** blob of associated data. */
56018: assert( (pKey==0)==(pCur->pKeyInfo==0) );
56019:
56020: /* If this is an insert into a table b-tree, invalidate any incrblob
56021: ** cursors open on the row being replaced (assuming this is a replace
56022: ** operation - if it is not, the following is a no-op). */
56023: if( pCur->pKeyInfo==0 ){
56024: invalidateIncrblobCursors(p, nKey, 0);
56025: }
56026:
56027: /* Save the positions of any other cursors open on this table.
56028: **
56029: ** In some cases, the call to btreeMoveto() below is a no-op. For
56030: ** example, when inserting data into a table with auto-generated integer
56031: ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the
56032: ** integer key to use. It then calls this function to actually insert the
56033: ** data into the intkey B-Tree. In this case btreeMoveto() recognizes
56034: ** that the cursor is already where it needs to be and returns without
56035: ** doing any work. To avoid thwarting these optimizations, it is important
56036: ** not to clear the cursor here.
56037: */
56038: rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
56039: if( rc ) return rc;
56040: if( !loc ){
56041: rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
56042: if( rc ) return rc;
56043: }
56044: assert( pCur->eState==CURSOR_VALID || (pCur->eState==CURSOR_INVALID && loc) );
56045:
56046: pPage = pCur->apPage[pCur->iPage];
56047: assert( pPage->intKey || nKey>=0 );
56048: assert( pPage->leaf || !pPage->intKey );
56049:
56050: TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
56051: pCur->pgnoRoot, nKey, nData, pPage->pgno,
56052: loc==0 ? "overwrite" : "new entry"));
56053: assert( pPage->isInit );
56054: allocateTempSpace(pBt);
56055: newCell = pBt->pTmpSpace;
56056: if( newCell==0 ) return SQLITE_NOMEM;
56057: rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
56058: if( rc ) goto end_insert;
56059: assert( szNew==cellSizePtr(pPage, newCell) );
56060: assert( szNew <= MX_CELL_SIZE(pBt) );
56061: idx = pCur->aiIdx[pCur->iPage];
56062: if( loc==0 ){
56063: u16 szOld;
56064: assert( idx<pPage->nCell );
56065: rc = sqlite3PagerWrite(pPage->pDbPage);
56066: if( rc ){
56067: goto end_insert;
56068: }
56069: oldCell = findCell(pPage, idx);
56070: if( !pPage->leaf ){
56071: memcpy(newCell, oldCell, 4);
56072: }
56073: szOld = cellSizePtr(pPage, oldCell);
56074: rc = clearCell(pPage, oldCell);
56075: dropCell(pPage, idx, szOld, &rc);
56076: if( rc ) goto end_insert;
56077: }else if( loc<0 && pPage->nCell>0 ){
56078: assert( pPage->leaf );
56079: idx = ++pCur->aiIdx[pCur->iPage];
56080: }else{
56081: assert( pPage->leaf );
56082: }
56083: insertCell(pPage, idx, newCell, szNew, 0, 0, &rc);
56084: assert( rc!=SQLITE_OK || pPage->nCell>0 || pPage->nOverflow>0 );
56085:
56086: /* If no error has occured and pPage has an overflow cell, call balance()
56087: ** to redistribute the cells within the tree. Since balance() may move
56088: ** the cursor, zero the BtCursor.info.nSize and BtCursor.validNKey
56089: ** variables.
56090: **
56091: ** Previous versions of SQLite called moveToRoot() to move the cursor
56092: ** back to the root page as balance() used to invalidate the contents
56093: ** of BtCursor.apPage[] and BtCursor.aiIdx[]. Instead of doing that,
56094: ** set the cursor state to "invalid". This makes common insert operations
56095: ** slightly faster.
56096: **
56097: ** There is a subtle but important optimization here too. When inserting
56098: ** multiple records into an intkey b-tree using a single cursor (as can
56099: ** happen while processing an "INSERT INTO ... SELECT" statement), it
56100: ** is advantageous to leave the cursor pointing to the last entry in
56101: ** the b-tree if possible. If the cursor is left pointing to the last
56102: ** entry in the table, and the next row inserted has an integer key
56103: ** larger than the largest existing key, it is possible to insert the
56104: ** row without seeking the cursor. This can be a big performance boost.
56105: */
56106: pCur->info.nSize = 0;
56107: pCur->validNKey = 0;
56108: if( rc==SQLITE_OK && pPage->nOverflow ){
56109: rc = balance(pCur);
56110:
56111: /* Must make sure nOverflow is reset to zero even if the balance()
56112: ** fails. Internal data structure corruption will result otherwise.
56113: ** Also, set the cursor state to invalid. This stops saveCursorPosition()
56114: ** from trying to save the current position of the cursor. */
56115: pCur->apPage[pCur->iPage]->nOverflow = 0;
56116: pCur->eState = CURSOR_INVALID;
56117: }
56118: assert( pCur->apPage[pCur->iPage]->nOverflow==0 );
56119:
56120: end_insert:
56121: return rc;
56122: }
56123:
56124: /*
56125: ** Delete the entry that the cursor is pointing to. The cursor
56126: ** is left pointing at a arbitrary location.
56127: */
56128: SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur){
56129: Btree *p = pCur->pBtree;
56130: BtShared *pBt = p->pBt;
56131: int rc; /* Return code */
56132: MemPage *pPage; /* Page to delete cell from */
56133: unsigned char *pCell; /* Pointer to cell to delete */
56134: int iCellIdx; /* Index of cell to delete */
56135: int iCellDepth; /* Depth of node containing pCell */
56136:
56137: assert( cursorHoldsMutex(pCur) );
56138: assert( pBt->inTransaction==TRANS_WRITE );
56139: assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
56140: assert( pCur->wrFlag );
56141: assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
56142: assert( !hasReadConflicts(p, pCur->pgnoRoot) );
56143:
56144: if( NEVER(pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell)
56145: || NEVER(pCur->eState!=CURSOR_VALID)
56146: ){
56147: return SQLITE_ERROR; /* Something has gone awry. */
56148: }
56149:
56150: /* If this is a delete operation to remove a row from a table b-tree,
56151: ** invalidate any incrblob cursors open on the row being deleted. */
56152: if( pCur->pKeyInfo==0 ){
56153: invalidateIncrblobCursors(p, pCur->info.nKey, 0);
56154: }
56155:
56156: iCellDepth = pCur->iPage;
56157: iCellIdx = pCur->aiIdx[iCellDepth];
56158: pPage = pCur->apPage[iCellDepth];
56159: pCell = findCell(pPage, iCellIdx);
56160:
56161: /* If the page containing the entry to delete is not a leaf page, move
56162: ** the cursor to the largest entry in the tree that is smaller than
56163: ** the entry being deleted. This cell will replace the cell being deleted
56164: ** from the internal node. The 'previous' entry is used for this instead
56165: ** of the 'next' entry, as the previous entry is always a part of the
56166: ** sub-tree headed by the child page of the cell being deleted. This makes
56167: ** balancing the tree following the delete operation easier. */
56168: if( !pPage->leaf ){
56169: int notUsed;
56170: rc = sqlite3BtreePrevious(pCur, ¬Used);
56171: if( rc ) return rc;
56172: }
56173:
56174: /* Save the positions of any other cursors open on this table before
56175: ** making any modifications. Make the page containing the entry to be
56176: ** deleted writable. Then free any overflow pages associated with the
56177: ** entry and finally remove the cell itself from within the page.
56178: */
56179: rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur);
56180: if( rc ) return rc;
56181: rc = sqlite3PagerWrite(pPage->pDbPage);
56182: if( rc ) return rc;
56183: rc = clearCell(pPage, pCell);
56184: dropCell(pPage, iCellIdx, cellSizePtr(pPage, pCell), &rc);
56185: if( rc ) return rc;
56186:
56187: /* If the cell deleted was not located on a leaf page, then the cursor
56188: ** is currently pointing to the largest entry in the sub-tree headed
56189: ** by the child-page of the cell that was just deleted from an internal
56190: ** node. The cell from the leaf node needs to be moved to the internal
56191: ** node to replace the deleted cell. */
56192: if( !pPage->leaf ){
56193: MemPage *pLeaf = pCur->apPage[pCur->iPage];
56194: int nCell;
56195: Pgno n = pCur->apPage[iCellDepth+1]->pgno;
56196: unsigned char *pTmp;
56197:
56198: pCell = findCell(pLeaf, pLeaf->nCell-1);
56199: nCell = cellSizePtr(pLeaf, pCell);
56200: assert( MX_CELL_SIZE(pBt) >= nCell );
56201:
56202: allocateTempSpace(pBt);
56203: pTmp = pBt->pTmpSpace;
56204:
56205: rc = sqlite3PagerWrite(pLeaf->pDbPage);
56206: insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
56207: dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);
56208: if( rc ) return rc;
56209: }
56210:
56211: /* Balance the tree. If the entry deleted was located on a leaf page,
56212: ** then the cursor still points to that page. In this case the first
56213: ** call to balance() repairs the tree, and the if(...) condition is
56214: ** never true.
56215: **
56216: ** Otherwise, if the entry deleted was on an internal node page, then
56217: ** pCur is pointing to the leaf page from which a cell was removed to
56218: ** replace the cell deleted from the internal node. This is slightly
56219: ** tricky as the leaf node may be underfull, and the internal node may
56220: ** be either under or overfull. In this case run the balancing algorithm
56221: ** on the leaf node first. If the balance proceeds far enough up the
56222: ** tree that we can be sure that any problem in the internal node has
56223: ** been corrected, so be it. Otherwise, after balancing the leaf node,
56224: ** walk the cursor up the tree to the internal node and balance it as
56225: ** well. */
56226: rc = balance(pCur);
56227: if( rc==SQLITE_OK && pCur->iPage>iCellDepth ){
56228: while( pCur->iPage>iCellDepth ){
56229: releasePage(pCur->apPage[pCur->iPage--]);
56230: }
56231: rc = balance(pCur);
56232: }
56233:
56234: if( rc==SQLITE_OK ){
56235: moveToRoot(pCur);
56236: }
56237: return rc;
56238: }
56239:
56240: /*
56241: ** Create a new BTree table. Write into *piTable the page
56242: ** number for the root page of the new table.
56243: **
56244: ** The type of type is determined by the flags parameter. Only the
56245: ** following values of flags are currently in use. Other values for
56246: ** flags might not work:
56247: **
56248: ** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys
56249: ** BTREE_ZERODATA Used for SQL indices
56250: */
56251: static int btreeCreateTable(Btree *p, int *piTable, int createTabFlags){
56252: BtShared *pBt = p->pBt;
56253: MemPage *pRoot;
56254: Pgno pgnoRoot;
56255: int rc;
56256: int ptfFlags; /* Page-type flage for the root page of new table */
56257:
56258: assert( sqlite3BtreeHoldsMutex(p) );
56259: assert( pBt->inTransaction==TRANS_WRITE );
56260: assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
56261:
56262: #ifdef SQLITE_OMIT_AUTOVACUUM
56263: rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
56264: if( rc ){
56265: return rc;
56266: }
56267: #else
56268: if( pBt->autoVacuum ){
56269: Pgno pgnoMove; /* Move a page here to make room for the root-page */
56270: MemPage *pPageMove; /* The page to move to. */
56271:
56272: /* Creating a new table may probably require moving an existing database
56273: ** to make room for the new tables root page. In case this page turns
56274: ** out to be an overflow page, delete all overflow page-map caches
56275: ** held by open cursors.
56276: */
56277: invalidateAllOverflowCache(pBt);
56278:
56279: /* Read the value of meta[3] from the database to determine where the
56280: ** root page of the new table should go. meta[3] is the largest root-page
56281: ** created so far, so the new root-page is (meta[3]+1).
56282: */
56283: sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &pgnoRoot);
56284: pgnoRoot++;
56285:
56286: /* The new root-page may not be allocated on a pointer-map page, or the
56287: ** PENDING_BYTE page.
56288: */
56289: while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) ||
56290: pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
56291: pgnoRoot++;
56292: }
56293: assert( pgnoRoot>=3 );
56294:
56295: /* Allocate a page. The page that currently resides at pgnoRoot will
56296: ** be moved to the allocated page (unless the allocated page happens
56297: ** to reside at pgnoRoot).
56298: */
56299: rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1);
56300: if( rc!=SQLITE_OK ){
56301: return rc;
56302: }
56303:
56304: if( pgnoMove!=pgnoRoot ){
56305: /* pgnoRoot is the page that will be used for the root-page of
56306: ** the new table (assuming an error did not occur). But we were
56307: ** allocated pgnoMove. If required (i.e. if it was not allocated
56308: ** by extending the file), the current page at position pgnoMove
56309: ** is already journaled.
56310: */
56311: u8 eType = 0;
56312: Pgno iPtrPage = 0;
56313:
56314: releasePage(pPageMove);
56315:
56316: /* Move the page currently at pgnoRoot to pgnoMove. */
56317: rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
56318: if( rc!=SQLITE_OK ){
56319: return rc;
56320: }
56321: rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
56322: if( eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){
56323: rc = SQLITE_CORRUPT_BKPT;
56324: }
56325: if( rc!=SQLITE_OK ){
56326: releasePage(pRoot);
56327: return rc;
56328: }
56329: assert( eType!=PTRMAP_ROOTPAGE );
56330: assert( eType!=PTRMAP_FREEPAGE );
56331: rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0);
56332: releasePage(pRoot);
56333:
56334: /* Obtain the page at pgnoRoot */
56335: if( rc!=SQLITE_OK ){
56336: return rc;
56337: }
56338: rc = btreeGetPage(pBt, pgnoRoot, &pRoot, 0);
56339: if( rc!=SQLITE_OK ){
56340: return rc;
56341: }
56342: rc = sqlite3PagerWrite(pRoot->pDbPage);
56343: if( rc!=SQLITE_OK ){
56344: releasePage(pRoot);
56345: return rc;
56346: }
56347: }else{
56348: pRoot = pPageMove;
56349: }
56350:
56351: /* Update the pointer-map and meta-data with the new root-page number. */
56352: ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0, &rc);
56353: if( rc ){
56354: releasePage(pRoot);
56355: return rc;
56356: }
56357:
56358: /* When the new root page was allocated, page 1 was made writable in
56359: ** order either to increase the database filesize, or to decrement the
56360: ** freelist count. Hence, the sqlite3BtreeUpdateMeta() call cannot fail.
56361: */
56362: assert( sqlite3PagerIswriteable(pBt->pPage1->pDbPage) );
56363: rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot);
56364: if( NEVER(rc) ){
56365: releasePage(pRoot);
56366: return rc;
56367: }
56368:
56369: }else{
56370: rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
56371: if( rc ) return rc;
56372: }
56373: #endif
56374: assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
56375: if( createTabFlags & BTREE_INTKEY ){
56376: ptfFlags = PTF_INTKEY | PTF_LEAFDATA | PTF_LEAF;
56377: }else{
56378: ptfFlags = PTF_ZERODATA | PTF_LEAF;
56379: }
56380: zeroPage(pRoot, ptfFlags);
56381: sqlite3PagerUnref(pRoot->pDbPage);
56382: assert( (pBt->openFlags & BTREE_SINGLE)==0 || pgnoRoot==2 );
56383: *piTable = (int)pgnoRoot;
56384: return SQLITE_OK;
56385: }
56386: SQLITE_PRIVATE int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){
56387: int rc;
56388: sqlite3BtreeEnter(p);
56389: rc = btreeCreateTable(p, piTable, flags);
56390: sqlite3BtreeLeave(p);
56391: return rc;
56392: }
56393:
56394: /*
56395: ** Erase the given database page and all its children. Return
56396: ** the page to the freelist.
56397: */
56398: static int clearDatabasePage(
56399: BtShared *pBt, /* The BTree that contains the table */
56400: Pgno pgno, /* Page number to clear */
56401: int freePageFlag, /* Deallocate page if true */
56402: int *pnChange /* Add number of Cells freed to this counter */
56403: ){
56404: MemPage *pPage;
56405: int rc;
56406: unsigned char *pCell;
56407: int i;
56408:
56409: assert( sqlite3_mutex_held(pBt->mutex) );
56410: if( pgno>btreePagecount(pBt) ){
56411: return SQLITE_CORRUPT_BKPT;
56412: }
56413:
56414: rc = getAndInitPage(pBt, pgno, &pPage);
56415: if( rc ) return rc;
56416: for(i=0; i<pPage->nCell; i++){
56417: pCell = findCell(pPage, i);
56418: if( !pPage->leaf ){
56419: rc = clearDatabasePage(pBt, get4byte(pCell), 1, pnChange);
56420: if( rc ) goto cleardatabasepage_out;
56421: }
56422: rc = clearCell(pPage, pCell);
56423: if( rc ) goto cleardatabasepage_out;
56424: }
56425: if( !pPage->leaf ){
56426: rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), 1, pnChange);
56427: if( rc ) goto cleardatabasepage_out;
56428: }else if( pnChange ){
56429: assert( pPage->intKey );
56430: *pnChange += pPage->nCell;
56431: }
56432: if( freePageFlag ){
56433: freePage(pPage, &rc);
56434: }else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){
56435: zeroPage(pPage, pPage->aData[0] | PTF_LEAF);
56436: }
56437:
56438: cleardatabasepage_out:
56439: releasePage(pPage);
56440: return rc;
56441: }
56442:
56443: /*
56444: ** Delete all information from a single table in the database. iTable is
56445: ** the page number of the root of the table. After this routine returns,
56446: ** the root page is empty, but still exists.
56447: **
56448: ** This routine will fail with SQLITE_LOCKED if there are any open
56449: ** read cursors on the table. Open write cursors are moved to the
56450: ** root of the table.
56451: **
56452: ** If pnChange is not NULL, then table iTable must be an intkey table. The
56453: ** integer value pointed to by pnChange is incremented by the number of
56454: ** entries in the table.
56455: */
56456: SQLITE_PRIVATE int sqlite3BtreeClearTable(Btree *p, int iTable, int *pnChange){
56457: int rc;
56458: BtShared *pBt = p->pBt;
56459: sqlite3BtreeEnter(p);
56460: assert( p->inTrans==TRANS_WRITE );
56461:
56462: /* Invalidate all incrblob cursors open on table iTable (assuming iTable
56463: ** is the root of a table b-tree - if it is not, the following call is
56464: ** a no-op). */
56465: invalidateIncrblobCursors(p, 0, 1);
56466:
56467: rc = saveAllCursors(pBt, (Pgno)iTable, 0);
56468: if( SQLITE_OK==rc ){
56469: rc = clearDatabasePage(pBt, (Pgno)iTable, 0, pnChange);
56470: }
56471: sqlite3BtreeLeave(p);
56472: return rc;
56473: }
56474:
56475: /*
56476: ** Erase all information in a table and add the root of the table to
56477: ** the freelist. Except, the root of the principle table (the one on
56478: ** page 1) is never added to the freelist.
56479: **
56480: ** This routine will fail with SQLITE_LOCKED if there are any open
56481: ** cursors on the table.
56482: **
56483: ** If AUTOVACUUM is enabled and the page at iTable is not the last
56484: ** root page in the database file, then the last root page
56485: ** in the database file is moved into the slot formerly occupied by
56486: ** iTable and that last slot formerly occupied by the last root page
56487: ** is added to the freelist instead of iTable. In this say, all
56488: ** root pages are kept at the beginning of the database file, which
56489: ** is necessary for AUTOVACUUM to work right. *piMoved is set to the
56490: ** page number that used to be the last root page in the file before
56491: ** the move. If no page gets moved, *piMoved is set to 0.
56492: ** The last root page is recorded in meta[3] and the value of
56493: ** meta[3] is updated by this procedure.
56494: */
56495: static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
56496: int rc;
56497: MemPage *pPage = 0;
56498: BtShared *pBt = p->pBt;
56499:
56500: assert( sqlite3BtreeHoldsMutex(p) );
56501: assert( p->inTrans==TRANS_WRITE );
56502:
56503: /* It is illegal to drop a table if any cursors are open on the
56504: ** database. This is because in auto-vacuum mode the backend may
56505: ** need to move another root-page to fill a gap left by the deleted
56506: ** root page. If an open cursor was using this page a problem would
56507: ** occur.
56508: **
56509: ** This error is caught long before control reaches this point.
56510: */
56511: if( NEVER(pBt->pCursor) ){
56512: sqlite3ConnectionBlocked(p->db, pBt->pCursor->pBtree->db);
56513: return SQLITE_LOCKED_SHAREDCACHE;
56514: }
56515:
56516: rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
56517: if( rc ) return rc;
56518: rc = sqlite3BtreeClearTable(p, iTable, 0);
56519: if( rc ){
56520: releasePage(pPage);
56521: return rc;
56522: }
56523:
56524: *piMoved = 0;
56525:
56526: if( iTable>1 ){
56527: #ifdef SQLITE_OMIT_AUTOVACUUM
56528: freePage(pPage, &rc);
56529: releasePage(pPage);
56530: #else
56531: if( pBt->autoVacuum ){
56532: Pgno maxRootPgno;
56533: sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno);
56534:
56535: if( iTable==maxRootPgno ){
56536: /* If the table being dropped is the table with the largest root-page
56537: ** number in the database, put the root page on the free list.
56538: */
56539: freePage(pPage, &rc);
56540: releasePage(pPage);
56541: if( rc!=SQLITE_OK ){
56542: return rc;
56543: }
56544: }else{
56545: /* The table being dropped does not have the largest root-page
56546: ** number in the database. So move the page that does into the
56547: ** gap left by the deleted root-page.
56548: */
56549: MemPage *pMove;
56550: releasePage(pPage);
56551: rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
56552: if( rc!=SQLITE_OK ){
56553: return rc;
56554: }
56555: rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
56556: releasePage(pMove);
56557: if( rc!=SQLITE_OK ){
56558: return rc;
56559: }
56560: pMove = 0;
56561: rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
56562: freePage(pMove, &rc);
56563: releasePage(pMove);
56564: if( rc!=SQLITE_OK ){
56565: return rc;
56566: }
56567: *piMoved = maxRootPgno;
56568: }
56569:
56570: /* Set the new 'max-root-page' value in the database header. This
56571: ** is the old value less one, less one more if that happens to
56572: ** be a root-page number, less one again if that is the
56573: ** PENDING_BYTE_PAGE.
56574: */
56575: maxRootPgno--;
56576: while( maxRootPgno==PENDING_BYTE_PAGE(pBt)
56577: || PTRMAP_ISPAGE(pBt, maxRootPgno) ){
56578: maxRootPgno--;
56579: }
56580: assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
56581:
56582: rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno);
56583: }else{
56584: freePage(pPage, &rc);
56585: releasePage(pPage);
56586: }
56587: #endif
56588: }else{
56589: /* If sqlite3BtreeDropTable was called on page 1.
56590: ** This really never should happen except in a corrupt
56591: ** database.
56592: */
56593: zeroPage(pPage, PTF_INTKEY|PTF_LEAF );
56594: releasePage(pPage);
56595: }
56596: return rc;
56597: }
56598: SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){
56599: int rc;
56600: sqlite3BtreeEnter(p);
56601: rc = btreeDropTable(p, iTable, piMoved);
56602: sqlite3BtreeLeave(p);
56603: return rc;
56604: }
56605:
56606:
56607: /*
56608: ** This function may only be called if the b-tree connection already
56609: ** has a read or write transaction open on the database.
56610: **
56611: ** Read the meta-information out of a database file. Meta[0]
56612: ** is the number of free pages currently in the database. Meta[1]
56613: ** through meta[15] are available for use by higher layers. Meta[0]
56614: ** is read-only, the others are read/write.
56615: **
56616: ** The schema layer numbers meta values differently. At the schema
56617: ** layer (and the SetCookie and ReadCookie opcodes) the number of
56618: ** free pages is not visible. So Cookie[0] is the same as Meta[1].
56619: */
56620: SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
56621: BtShared *pBt = p->pBt;
56622:
56623: sqlite3BtreeEnter(p);
56624: assert( p->inTrans>TRANS_NONE );
56625: assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
56626: assert( pBt->pPage1 );
56627: assert( idx>=0 && idx<=15 );
56628:
56629: *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
56630:
56631: /* If auto-vacuum is disabled in this build and this is an auto-vacuum
56632: ** database, mark the database as read-only. */
56633: #ifdef SQLITE_OMIT_AUTOVACUUM
56634: if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ){
56635: pBt->btsFlags |= BTS_READ_ONLY;
56636: }
56637: #endif
56638:
56639: sqlite3BtreeLeave(p);
56640: }
56641:
56642: /*
56643: ** Write meta-information back into the database. Meta[0] is
56644: ** read-only and may not be written.
56645: */
56646: SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
56647: BtShared *pBt = p->pBt;
56648: unsigned char *pP1;
56649: int rc;
56650: assert( idx>=1 && idx<=15 );
56651: sqlite3BtreeEnter(p);
56652: assert( p->inTrans==TRANS_WRITE );
56653: assert( pBt->pPage1!=0 );
56654: pP1 = pBt->pPage1->aData;
56655: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
56656: if( rc==SQLITE_OK ){
56657: put4byte(&pP1[36 + idx*4], iMeta);
56658: #ifndef SQLITE_OMIT_AUTOVACUUM
56659: if( idx==BTREE_INCR_VACUUM ){
56660: assert( pBt->autoVacuum || iMeta==0 );
56661: assert( iMeta==0 || iMeta==1 );
56662: pBt->incrVacuum = (u8)iMeta;
56663: }
56664: #endif
56665: }
56666: sqlite3BtreeLeave(p);
56667: return rc;
56668: }
56669:
56670: #ifndef SQLITE_OMIT_BTREECOUNT
56671: /*
56672: ** The first argument, pCur, is a cursor opened on some b-tree. Count the
56673: ** number of entries in the b-tree and write the result to *pnEntry.
56674: **
56675: ** SQLITE_OK is returned if the operation is successfully executed.
56676: ** Otherwise, if an error is encountered (i.e. an IO error or database
56677: ** corruption) an SQLite error code is returned.
56678: */
56679: SQLITE_PRIVATE int sqlite3BtreeCount(BtCursor *pCur, i64 *pnEntry){
56680: i64 nEntry = 0; /* Value to return in *pnEntry */
56681: int rc; /* Return code */
56682:
56683: if( pCur->pgnoRoot==0 ){
56684: *pnEntry = 0;
56685: return SQLITE_OK;
56686: }
56687: rc = moveToRoot(pCur);
56688:
56689: /* Unless an error occurs, the following loop runs one iteration for each
56690: ** page in the B-Tree structure (not including overflow pages).
56691: */
56692: while( rc==SQLITE_OK ){
56693: int iIdx; /* Index of child node in parent */
56694: MemPage *pPage; /* Current page of the b-tree */
56695:
56696: /* If this is a leaf page or the tree is not an int-key tree, then
56697: ** this page contains countable entries. Increment the entry counter
56698: ** accordingly.
56699: */
56700: pPage = pCur->apPage[pCur->iPage];
56701: if( pPage->leaf || !pPage->intKey ){
56702: nEntry += pPage->nCell;
56703: }
56704:
56705: /* pPage is a leaf node. This loop navigates the cursor so that it
56706: ** points to the first interior cell that it points to the parent of
56707: ** the next page in the tree that has not yet been visited. The
56708: ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
56709: ** of the page, or to the number of cells in the page if the next page
56710: ** to visit is the right-child of its parent.
56711: **
56712: ** If all pages in the tree have been visited, return SQLITE_OK to the
56713: ** caller.
56714: */
56715: if( pPage->leaf ){
56716: do {
56717: if( pCur->iPage==0 ){
56718: /* All pages of the b-tree have been visited. Return successfully. */
56719: *pnEntry = nEntry;
56720: return SQLITE_OK;
56721: }
56722: moveToParent(pCur);
56723: }while ( pCur->aiIdx[pCur->iPage]>=pCur->apPage[pCur->iPage]->nCell );
56724:
56725: pCur->aiIdx[pCur->iPage]++;
56726: pPage = pCur->apPage[pCur->iPage];
56727: }
56728:
56729: /* Descend to the child node of the cell that the cursor currently
56730: ** points at. This is the right-child if (iIdx==pPage->nCell).
56731: */
56732: iIdx = pCur->aiIdx[pCur->iPage];
56733: if( iIdx==pPage->nCell ){
56734: rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
56735: }else{
56736: rc = moveToChild(pCur, get4byte(findCell(pPage, iIdx)));
56737: }
56738: }
56739:
56740: /* An error has occurred. Return an error code. */
56741: return rc;
56742: }
56743: #endif
56744:
56745: /*
56746: ** Return the pager associated with a BTree. This routine is used for
56747: ** testing and debugging only.
56748: */
56749: SQLITE_PRIVATE Pager *sqlite3BtreePager(Btree *p){
56750: return p->pBt->pPager;
56751: }
56752:
56753: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
56754: /*
56755: ** Append a message to the error message string.
56756: */
56757: static void checkAppendMsg(
56758: IntegrityCk *pCheck,
56759: char *zMsg1,
56760: const char *zFormat,
56761: ...
56762: ){
56763: va_list ap;
56764: if( !pCheck->mxErr ) return;
56765: pCheck->mxErr--;
56766: pCheck->nErr++;
56767: va_start(ap, zFormat);
56768: if( pCheck->errMsg.nChar ){
56769: sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1);
56770: }
56771: if( zMsg1 ){
56772: sqlite3StrAccumAppend(&pCheck->errMsg, zMsg1, -1);
56773: }
56774: sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap);
56775: va_end(ap);
56776: if( pCheck->errMsg.mallocFailed ){
56777: pCheck->mallocFailed = 1;
56778: }
56779: }
56780: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
56781:
56782: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
56783: /*
56784: ** Add 1 to the reference count for page iPage. If this is the second
56785: ** reference to the page, add an error message to pCheck->zErrMsg.
56786: ** Return 1 if there are 2 ore more references to the page and 0 if
56787: ** if this is the first reference to the page.
56788: **
56789: ** Also check that the page number is in bounds.
56790: */
56791: static int checkRef(IntegrityCk *pCheck, Pgno iPage, char *zContext){
56792: if( iPage==0 ) return 1;
56793: if( iPage>pCheck->nPage ){
56794: checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage);
56795: return 1;
56796: }
56797: if( pCheck->anRef[iPage]==1 ){
56798: checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage);
56799: return 1;
56800: }
56801: return (pCheck->anRef[iPage]++)>1;
56802: }
56803:
56804: #ifndef SQLITE_OMIT_AUTOVACUUM
56805: /*
56806: ** Check that the entry in the pointer-map for page iChild maps to
56807: ** page iParent, pointer type ptrType. If not, append an error message
56808: ** to pCheck.
56809: */
56810: static void checkPtrmap(
56811: IntegrityCk *pCheck, /* Integrity check context */
56812: Pgno iChild, /* Child page number */
56813: u8 eType, /* Expected pointer map type */
56814: Pgno iParent, /* Expected pointer map parent page number */
56815: char *zContext /* Context description (used for error msg) */
56816: ){
56817: int rc;
56818: u8 ePtrmapType;
56819: Pgno iPtrmapParent;
56820:
56821: rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
56822: if( rc!=SQLITE_OK ){
56823: if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->mallocFailed = 1;
56824: checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild);
56825: return;
56826: }
56827:
56828: if( ePtrmapType!=eType || iPtrmapParent!=iParent ){
56829: checkAppendMsg(pCheck, zContext,
56830: "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)",
56831: iChild, eType, iParent, ePtrmapType, iPtrmapParent);
56832: }
56833: }
56834: #endif
56835:
56836: /*
56837: ** Check the integrity of the freelist or of an overflow page list.
56838: ** Verify that the number of pages on the list is N.
56839: */
56840: static void checkList(
56841: IntegrityCk *pCheck, /* Integrity checking context */
56842: int isFreeList, /* True for a freelist. False for overflow page list */
56843: int iPage, /* Page number for first page in the list */
56844: int N, /* Expected number of pages in the list */
56845: char *zContext /* Context for error messages */
56846: ){
56847: int i;
56848: int expected = N;
56849: int iFirst = iPage;
56850: while( N-- > 0 && pCheck->mxErr ){
56851: DbPage *pOvflPage;
56852: unsigned char *pOvflData;
56853: if( iPage<1 ){
56854: checkAppendMsg(pCheck, zContext,
56855: "%d of %d pages missing from overflow list starting at %d",
56856: N+1, expected, iFirst);
56857: break;
56858: }
56859: if( checkRef(pCheck, iPage, zContext) ) break;
56860: if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
56861: checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage);
56862: break;
56863: }
56864: pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage);
56865: if( isFreeList ){
56866: int n = get4byte(&pOvflData[4]);
56867: #ifndef SQLITE_OMIT_AUTOVACUUM
56868: if( pCheck->pBt->autoVacuum ){
56869: checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext);
56870: }
56871: #endif
56872: if( n>(int)pCheck->pBt->usableSize/4-2 ){
56873: checkAppendMsg(pCheck, zContext,
56874: "freelist leaf count too big on page %d", iPage);
56875: N--;
56876: }else{
56877: for(i=0; i<n; i++){
56878: Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
56879: #ifndef SQLITE_OMIT_AUTOVACUUM
56880: if( pCheck->pBt->autoVacuum ){
56881: checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext);
56882: }
56883: #endif
56884: checkRef(pCheck, iFreePage, zContext);
56885: }
56886: N -= n;
56887: }
56888: }
56889: #ifndef SQLITE_OMIT_AUTOVACUUM
56890: else{
56891: /* If this database supports auto-vacuum and iPage is not the last
56892: ** page in this overflow list, check that the pointer-map entry for
56893: ** the following page matches iPage.
56894: */
56895: if( pCheck->pBt->autoVacuum && N>0 ){
56896: i = get4byte(pOvflData);
56897: checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext);
56898: }
56899: }
56900: #endif
56901: iPage = get4byte(pOvflData);
56902: sqlite3PagerUnref(pOvflPage);
56903: }
56904: }
56905: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
56906:
56907: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
56908: /*
56909: ** Do various sanity checks on a single page of a tree. Return
56910: ** the tree depth. Root pages return 0. Parents of root pages
56911: ** return 1, and so forth.
56912: **
56913: ** These checks are done:
56914: **
56915: ** 1. Make sure that cells and freeblocks do not overlap
56916: ** but combine to completely cover the page.
56917: ** NO 2. Make sure cell keys are in order.
56918: ** NO 3. Make sure no key is less than or equal to zLowerBound.
56919: ** NO 4. Make sure no key is greater than or equal to zUpperBound.
56920: ** 5. Check the integrity of overflow pages.
56921: ** 6. Recursively call checkTreePage on all children.
56922: ** 7. Verify that the depth of all children is the same.
56923: ** 8. Make sure this page is at least 33% full or else it is
56924: ** the root of the tree.
56925: */
56926: static int checkTreePage(
56927: IntegrityCk *pCheck, /* Context for the sanity check */
56928: int iPage, /* Page number of the page to check */
56929: char *zParentContext, /* Parent context */
56930: i64 *pnParentMinKey,
56931: i64 *pnParentMaxKey
56932: ){
56933: MemPage *pPage;
56934: int i, rc, depth, d2, pgno, cnt;
56935: int hdr, cellStart;
56936: int nCell;
56937: u8 *data;
56938: BtShared *pBt;
56939: int usableSize;
56940: char zContext[100];
56941: char *hit = 0;
56942: i64 nMinKey = 0;
56943: i64 nMaxKey = 0;
56944:
56945: sqlite3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage);
56946:
56947: /* Check that the page exists
56948: */
56949: pBt = pCheck->pBt;
56950: usableSize = pBt->usableSize;
56951: if( iPage==0 ) return 0;
56952: if( checkRef(pCheck, iPage, zParentContext) ) return 0;
56953: if( (rc = btreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
56954: checkAppendMsg(pCheck, zContext,
56955: "unable to get the page. error code=%d", rc);
56956: return 0;
56957: }
56958:
56959: /* Clear MemPage.isInit to make sure the corruption detection code in
56960: ** btreeInitPage() is executed. */
56961: pPage->isInit = 0;
56962: if( (rc = btreeInitPage(pPage))!=0 ){
56963: assert( rc==SQLITE_CORRUPT ); /* The only possible error from InitPage */
56964: checkAppendMsg(pCheck, zContext,
56965: "btreeInitPage() returns error code %d", rc);
56966: releasePage(pPage);
56967: return 0;
56968: }
56969:
56970: /* Check out all the cells.
56971: */
56972: depth = 0;
56973: for(i=0; i<pPage->nCell && pCheck->mxErr; i++){
56974: u8 *pCell;
56975: u32 sz;
56976: CellInfo info;
56977:
56978: /* Check payload overflow pages
56979: */
56980: sqlite3_snprintf(sizeof(zContext), zContext,
56981: "On tree page %d cell %d: ", iPage, i);
56982: pCell = findCell(pPage,i);
56983: btreeParseCellPtr(pPage, pCell, &info);
56984: sz = info.nData;
56985: if( !pPage->intKey ) sz += (int)info.nKey;
56986: /* For intKey pages, check that the keys are in order.
56987: */
56988: else if( i==0 ) nMinKey = nMaxKey = info.nKey;
56989: else{
56990: if( info.nKey <= nMaxKey ){
56991: checkAppendMsg(pCheck, zContext,
56992: "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey);
56993: }
56994: nMaxKey = info.nKey;
56995: }
56996: assert( sz==info.nPayload );
56997: if( (sz>info.nLocal)
56998: && (&pCell[info.iOverflow]<=&pPage->aData[pBt->usableSize])
56999: ){
57000: int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4);
57001: Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
57002: #ifndef SQLITE_OMIT_AUTOVACUUM
57003: if( pBt->autoVacuum ){
57004: checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext);
57005: }
57006: #endif
57007: checkList(pCheck, 0, pgnoOvfl, nPage, zContext);
57008: }
57009:
57010: /* Check sanity of left child page.
57011: */
57012: if( !pPage->leaf ){
57013: pgno = get4byte(pCell);
57014: #ifndef SQLITE_OMIT_AUTOVACUUM
57015: if( pBt->autoVacuum ){
57016: checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
57017: }
57018: #endif
57019: d2 = checkTreePage(pCheck, pgno, zContext, &nMinKey, i==0 ? NULL : &nMaxKey);
57020: if( i>0 && d2!=depth ){
57021: checkAppendMsg(pCheck, zContext, "Child page depth differs");
57022: }
57023: depth = d2;
57024: }
57025: }
57026:
57027: if( !pPage->leaf ){
57028: pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
57029: sqlite3_snprintf(sizeof(zContext), zContext,
57030: "On page %d at right child: ", iPage);
57031: #ifndef SQLITE_OMIT_AUTOVACUUM
57032: if( pBt->autoVacuum ){
57033: checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
57034: }
57035: #endif
57036: checkTreePage(pCheck, pgno, zContext, NULL, !pPage->nCell ? NULL : &nMaxKey);
57037: }
57038:
57039: /* For intKey leaf pages, check that the min/max keys are in order
57040: ** with any left/parent/right pages.
57041: */
57042: if( pPage->leaf && pPage->intKey ){
57043: /* if we are a left child page */
57044: if( pnParentMinKey ){
57045: /* if we are the left most child page */
57046: if( !pnParentMaxKey ){
57047: if( nMaxKey > *pnParentMinKey ){
57048: checkAppendMsg(pCheck, zContext,
57049: "Rowid %lld out of order (max larger than parent min of %lld)",
57050: nMaxKey, *pnParentMinKey);
57051: }
57052: }else{
57053: if( nMinKey <= *pnParentMinKey ){
57054: checkAppendMsg(pCheck, zContext,
57055: "Rowid %lld out of order (min less than parent min of %lld)",
57056: nMinKey, *pnParentMinKey);
57057: }
57058: if( nMaxKey > *pnParentMaxKey ){
57059: checkAppendMsg(pCheck, zContext,
57060: "Rowid %lld out of order (max larger than parent max of %lld)",
57061: nMaxKey, *pnParentMaxKey);
57062: }
57063: *pnParentMinKey = nMaxKey;
57064: }
57065: /* else if we're a right child page */
57066: } else if( pnParentMaxKey ){
57067: if( nMinKey <= *pnParentMaxKey ){
57068: checkAppendMsg(pCheck, zContext,
57069: "Rowid %lld out of order (min less than parent max of %lld)",
57070: nMinKey, *pnParentMaxKey);
57071: }
57072: }
57073: }
57074:
57075: /* Check for complete coverage of the page
57076: */
57077: data = pPage->aData;
57078: hdr = pPage->hdrOffset;
57079: hit = sqlite3PageMalloc( pBt->pageSize );
57080: if( hit==0 ){
57081: pCheck->mallocFailed = 1;
57082: }else{
57083: int contentOffset = get2byteNotZero(&data[hdr+5]);
57084: assert( contentOffset<=usableSize ); /* Enforced by btreeInitPage() */
57085: memset(hit+contentOffset, 0, usableSize-contentOffset);
57086: memset(hit, 1, contentOffset);
57087: nCell = get2byte(&data[hdr+3]);
57088: cellStart = hdr + 12 - 4*pPage->leaf;
57089: for(i=0; i<nCell; i++){
57090: int pc = get2byte(&data[cellStart+i*2]);
57091: u32 size = 65536;
57092: int j;
57093: if( pc<=usableSize-4 ){
57094: size = cellSizePtr(pPage, &data[pc]);
57095: }
57096: if( (int)(pc+size-1)>=usableSize ){
57097: checkAppendMsg(pCheck, 0,
57098: "Corruption detected in cell %d on page %d",i,iPage);
57099: }else{
57100: for(j=pc+size-1; j>=pc; j--) hit[j]++;
57101: }
57102: }
57103: i = get2byte(&data[hdr+1]);
57104: while( i>0 ){
57105: int size, j;
57106: assert( i<=usableSize-4 ); /* Enforced by btreeInitPage() */
57107: size = get2byte(&data[i+2]);
57108: assert( i+size<=usableSize ); /* Enforced by btreeInitPage() */
57109: for(j=i+size-1; j>=i; j--) hit[j]++;
57110: j = get2byte(&data[i]);
57111: assert( j==0 || j>i+size ); /* Enforced by btreeInitPage() */
57112: assert( j<=usableSize-4 ); /* Enforced by btreeInitPage() */
57113: i = j;
57114: }
57115: for(i=cnt=0; i<usableSize; i++){
57116: if( hit[i]==0 ){
57117: cnt++;
57118: }else if( hit[i]>1 ){
57119: checkAppendMsg(pCheck, 0,
57120: "Multiple uses for byte %d of page %d", i, iPage);
57121: break;
57122: }
57123: }
57124: if( cnt!=data[hdr+7] ){
57125: checkAppendMsg(pCheck, 0,
57126: "Fragmentation of %d bytes reported as %d on page %d",
57127: cnt, data[hdr+7], iPage);
57128: }
57129: }
57130: sqlite3PageFree(hit);
57131: releasePage(pPage);
57132: return depth+1;
57133: }
57134: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
57135:
57136: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
57137: /*
57138: ** This routine does a complete check of the given BTree file. aRoot[] is
57139: ** an array of pages numbers were each page number is the root page of
57140: ** a table. nRoot is the number of entries in aRoot.
57141: **
57142: ** A read-only or read-write transaction must be opened before calling
57143: ** this function.
57144: **
57145: ** Write the number of error seen in *pnErr. Except for some memory
57146: ** allocation errors, an error message held in memory obtained from
57147: ** malloc is returned if *pnErr is non-zero. If *pnErr==0 then NULL is
57148: ** returned. If a memory allocation error occurs, NULL is returned.
57149: */
57150: SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(
57151: Btree *p, /* The btree to be checked */
57152: int *aRoot, /* An array of root pages numbers for individual trees */
57153: int nRoot, /* Number of entries in aRoot[] */
57154: int mxErr, /* Stop reporting errors after this many */
57155: int *pnErr /* Write number of errors seen to this variable */
57156: ){
57157: Pgno i;
57158: int nRef;
57159: IntegrityCk sCheck;
57160: BtShared *pBt = p->pBt;
57161: char zErr[100];
57162:
57163: sqlite3BtreeEnter(p);
57164: assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
57165: nRef = sqlite3PagerRefcount(pBt->pPager);
57166: sCheck.pBt = pBt;
57167: sCheck.pPager = pBt->pPager;
57168: sCheck.nPage = btreePagecount(sCheck.pBt);
57169: sCheck.mxErr = mxErr;
57170: sCheck.nErr = 0;
57171: sCheck.mallocFailed = 0;
57172: *pnErr = 0;
57173: if( sCheck.nPage==0 ){
57174: sqlite3BtreeLeave(p);
57175: return 0;
57176: }
57177: sCheck.anRef = sqlite3Malloc( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) );
57178: if( !sCheck.anRef ){
57179: *pnErr = 1;
57180: sqlite3BtreeLeave(p);
57181: return 0;
57182: }
57183: for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; }
57184: i = PENDING_BYTE_PAGE(pBt);
57185: if( i<=sCheck.nPage ){
57186: sCheck.anRef[i] = 1;
57187: }
57188: sqlite3StrAccumInit(&sCheck.errMsg, zErr, sizeof(zErr), 20000);
57189: sCheck.errMsg.useMalloc = 2;
57190:
57191: /* Check the integrity of the freelist
57192: */
57193: checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
57194: get4byte(&pBt->pPage1->aData[36]), "Main freelist: ");
57195:
57196: /* Check all the tables.
57197: */
57198: for(i=0; (int)i<nRoot && sCheck.mxErr; i++){
57199: if( aRoot[i]==0 ) continue;
57200: #ifndef SQLITE_OMIT_AUTOVACUUM
57201: if( pBt->autoVacuum && aRoot[i]>1 ){
57202: checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0);
57203: }
57204: #endif
57205: checkTreePage(&sCheck, aRoot[i], "List of tree roots: ", NULL, NULL);
57206: }
57207:
57208: /* Make sure every page in the file is referenced
57209: */
57210: for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){
57211: #ifdef SQLITE_OMIT_AUTOVACUUM
57212: if( sCheck.anRef[i]==0 ){
57213: checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
57214: }
57215: #else
57216: /* If the database supports auto-vacuum, make sure no tables contain
57217: ** references to pointer-map pages.
57218: */
57219: if( sCheck.anRef[i]==0 &&
57220: (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
57221: checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
57222: }
57223: if( sCheck.anRef[i]!=0 &&
57224: (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
57225: checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i);
57226: }
57227: #endif
57228: }
57229:
57230: /* Make sure this analysis did not leave any unref() pages.
57231: ** This is an internal consistency check; an integrity check
57232: ** of the integrity check.
57233: */
57234: if( NEVER(nRef != sqlite3PagerRefcount(pBt->pPager)) ){
57235: checkAppendMsg(&sCheck, 0,
57236: "Outstanding page count goes from %d to %d during this analysis",
57237: nRef, sqlite3PagerRefcount(pBt->pPager)
57238: );
57239: }
57240:
57241: /* Clean up and report errors.
57242: */
57243: sqlite3BtreeLeave(p);
57244: sqlite3_free(sCheck.anRef);
57245: if( sCheck.mallocFailed ){
57246: sqlite3StrAccumReset(&sCheck.errMsg);
57247: *pnErr = sCheck.nErr+1;
57248: return 0;
57249: }
57250: *pnErr = sCheck.nErr;
57251: if( sCheck.nErr==0 ) sqlite3StrAccumReset(&sCheck.errMsg);
57252: return sqlite3StrAccumFinish(&sCheck.errMsg);
57253: }
57254: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
57255:
57256: /*
57257: ** Return the full pathname of the underlying database file.
57258: **
57259: ** The pager filename is invariant as long as the pager is
57260: ** open so it is safe to access without the BtShared mutex.
57261: */
57262: SQLITE_PRIVATE const char *sqlite3BtreeGetFilename(Btree *p){
57263: assert( p->pBt->pPager!=0 );
57264: return sqlite3PagerFilename(p->pBt->pPager);
57265: }
57266:
57267: /*
57268: ** Return the pathname of the journal file for this database. The return
57269: ** value of this routine is the same regardless of whether the journal file
57270: ** has been created or not.
57271: **
57272: ** The pager journal filename is invariant as long as the pager is
57273: ** open so it is safe to access without the BtShared mutex.
57274: */
57275: SQLITE_PRIVATE const char *sqlite3BtreeGetJournalname(Btree *p){
57276: assert( p->pBt->pPager!=0 );
57277: return sqlite3PagerJournalname(p->pBt->pPager);
57278: }
57279:
57280: /*
57281: ** Return non-zero if a transaction is active.
57282: */
57283: SQLITE_PRIVATE int sqlite3BtreeIsInTrans(Btree *p){
57284: assert( p==0 || sqlite3_mutex_held(p->db->mutex) );
57285: return (p && (p->inTrans==TRANS_WRITE));
57286: }
57287:
57288: #ifndef SQLITE_OMIT_WAL
57289: /*
57290: ** Run a checkpoint on the Btree passed as the first argument.
57291: **
57292: ** Return SQLITE_LOCKED if this or any other connection has an open
57293: ** transaction on the shared-cache the argument Btree is connected to.
57294: **
57295: ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
57296: */
57297: SQLITE_PRIVATE int sqlite3BtreeCheckpoint(Btree *p, int eMode, int *pnLog, int *pnCkpt){
57298: int rc = SQLITE_OK;
57299: if( p ){
57300: BtShared *pBt = p->pBt;
57301: sqlite3BtreeEnter(p);
57302: if( pBt->inTransaction!=TRANS_NONE ){
57303: rc = SQLITE_LOCKED;
57304: }else{
57305: rc = sqlite3PagerCheckpoint(pBt->pPager, eMode, pnLog, pnCkpt);
57306: }
57307: sqlite3BtreeLeave(p);
57308: }
57309: return rc;
57310: }
57311: #endif
57312:
57313: /*
57314: ** Return non-zero if a read (or write) transaction is active.
57315: */
57316: SQLITE_PRIVATE int sqlite3BtreeIsInReadTrans(Btree *p){
57317: assert( p );
57318: assert( sqlite3_mutex_held(p->db->mutex) );
57319: return p->inTrans!=TRANS_NONE;
57320: }
57321:
57322: SQLITE_PRIVATE int sqlite3BtreeIsInBackup(Btree *p){
57323: assert( p );
57324: assert( sqlite3_mutex_held(p->db->mutex) );
57325: return p->nBackup!=0;
57326: }
57327:
57328: /*
57329: ** This function returns a pointer to a blob of memory associated with
57330: ** a single shared-btree. The memory is used by client code for its own
57331: ** purposes (for example, to store a high-level schema associated with
57332: ** the shared-btree). The btree layer manages reference counting issues.
57333: **
57334: ** The first time this is called on a shared-btree, nBytes bytes of memory
57335: ** are allocated, zeroed, and returned to the caller. For each subsequent
57336: ** call the nBytes parameter is ignored and a pointer to the same blob
57337: ** of memory returned.
57338: **
57339: ** If the nBytes parameter is 0 and the blob of memory has not yet been
57340: ** allocated, a null pointer is returned. If the blob has already been
57341: ** allocated, it is returned as normal.
57342: **
57343: ** Just before the shared-btree is closed, the function passed as the
57344: ** xFree argument when the memory allocation was made is invoked on the
57345: ** blob of allocated memory. The xFree function should not call sqlite3_free()
57346: ** on the memory, the btree layer does that.
57347: */
57348: SQLITE_PRIVATE void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
57349: BtShared *pBt = p->pBt;
57350: sqlite3BtreeEnter(p);
57351: if( !pBt->pSchema && nBytes ){
57352: pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
57353: pBt->xFreeSchema = xFree;
57354: }
57355: sqlite3BtreeLeave(p);
57356: return pBt->pSchema;
57357: }
57358:
57359: /*
57360: ** Return SQLITE_LOCKED_SHAREDCACHE if another user of the same shared
57361: ** btree as the argument handle holds an exclusive lock on the
57362: ** sqlite_master table. Otherwise SQLITE_OK.
57363: */
57364: SQLITE_PRIVATE int sqlite3BtreeSchemaLocked(Btree *p){
57365: int rc;
57366: assert( sqlite3_mutex_held(p->db->mutex) );
57367: sqlite3BtreeEnter(p);
57368: rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
57369: assert( rc==SQLITE_OK || rc==SQLITE_LOCKED_SHAREDCACHE );
57370: sqlite3BtreeLeave(p);
57371: return rc;
57372: }
57373:
57374:
57375: #ifndef SQLITE_OMIT_SHARED_CACHE
57376: /*
57377: ** Obtain a lock on the table whose root page is iTab. The
57378: ** lock is a write lock if isWritelock is true or a read lock
57379: ** if it is false.
57380: */
57381: SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
57382: int rc = SQLITE_OK;
57383: assert( p->inTrans!=TRANS_NONE );
57384: if( p->sharable ){
57385: u8 lockType = READ_LOCK + isWriteLock;
57386: assert( READ_LOCK+1==WRITE_LOCK );
57387: assert( isWriteLock==0 || isWriteLock==1 );
57388:
57389: sqlite3BtreeEnter(p);
57390: rc = querySharedCacheTableLock(p, iTab, lockType);
57391: if( rc==SQLITE_OK ){
57392: rc = setSharedCacheTableLock(p, iTab, lockType);
57393: }
57394: sqlite3BtreeLeave(p);
57395: }
57396: return rc;
57397: }
57398: #endif
57399:
57400: #ifndef SQLITE_OMIT_INCRBLOB
57401: /*
57402: ** Argument pCsr must be a cursor opened for writing on an
57403: ** INTKEY table currently pointing at a valid table entry.
57404: ** This function modifies the data stored as part of that entry.
57405: **
57406: ** Only the data content may only be modified, it is not possible to
57407: ** change the length of the data stored. If this function is called with
57408: ** parameters that attempt to write past the end of the existing data,
57409: ** no modifications are made and SQLITE_CORRUPT is returned.
57410: */
57411: SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
57412: int rc;
57413: assert( cursorHoldsMutex(pCsr) );
57414: assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
57415: assert( pCsr->isIncrblobHandle );
57416:
57417: rc = restoreCursorPosition(pCsr);
57418: if( rc!=SQLITE_OK ){
57419: return rc;
57420: }
57421: assert( pCsr->eState!=CURSOR_REQUIRESEEK );
57422: if( pCsr->eState!=CURSOR_VALID ){
57423: return SQLITE_ABORT;
57424: }
57425:
57426: /* Check some assumptions:
57427: ** (a) the cursor is open for writing,
57428: ** (b) there is a read/write transaction open,
57429: ** (c) the connection holds a write-lock on the table (if required),
57430: ** (d) there are no conflicting read-locks, and
57431: ** (e) the cursor points at a valid row of an intKey table.
57432: */
57433: if( !pCsr->wrFlag ){
57434: return SQLITE_READONLY;
57435: }
57436: assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
57437: && pCsr->pBt->inTransaction==TRANS_WRITE );
57438: assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
57439: assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
57440: assert( pCsr->apPage[pCsr->iPage]->intKey );
57441:
57442: return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
57443: }
57444:
57445: /*
57446: ** Set a flag on this cursor to cache the locations of pages from the
57447: ** overflow list for the current row. This is used by cursors opened
57448: ** for incremental blob IO only.
57449: **
57450: ** This function sets a flag only. The actual page location cache
57451: ** (stored in BtCursor.aOverflow[]) is allocated and used by function
57452: ** accessPayload() (the worker function for sqlite3BtreeData() and
57453: ** sqlite3BtreePutData()).
57454: */
57455: SQLITE_PRIVATE void sqlite3BtreeCacheOverflow(BtCursor *pCur){
57456: assert( cursorHoldsMutex(pCur) );
57457: assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
57458: invalidateOverflowCache(pCur);
57459: pCur->isIncrblobHandle = 1;
57460: }
57461: #endif
57462:
57463: /*
57464: ** Set both the "read version" (single byte at byte offset 18) and
57465: ** "write version" (single byte at byte offset 19) fields in the database
57466: ** header to iVersion.
57467: */
57468: SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){
57469: BtShared *pBt = pBtree->pBt;
57470: int rc; /* Return code */
57471:
57472: assert( iVersion==1 || iVersion==2 );
57473:
57474: /* If setting the version fields to 1, do not automatically open the
57475: ** WAL connection, even if the version fields are currently set to 2.
57476: */
57477: pBt->btsFlags &= ~BTS_NO_WAL;
57478: if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL;
57479:
57480: rc = sqlite3BtreeBeginTrans(pBtree, 0);
57481: if( rc==SQLITE_OK ){
57482: u8 *aData = pBt->pPage1->aData;
57483: if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){
57484: rc = sqlite3BtreeBeginTrans(pBtree, 2);
57485: if( rc==SQLITE_OK ){
57486: rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
57487: if( rc==SQLITE_OK ){
57488: aData[18] = (u8)iVersion;
57489: aData[19] = (u8)iVersion;
57490: }
57491: }
57492: }
57493: }
57494:
57495: pBt->btsFlags &= ~BTS_NO_WAL;
57496: return rc;
57497: }
57498:
57499: /************** End of btree.c ***********************************************/
57500: /************** Begin file backup.c ******************************************/
57501: /*
57502: ** 2009 January 28
57503: **
57504: ** The author disclaims copyright to this source code. In place of
57505: ** a legal notice, here is a blessing:
57506: **
57507: ** May you do good and not evil.
57508: ** May you find forgiveness for yourself and forgive others.
57509: ** May you share freely, never taking more than you give.
57510: **
57511: *************************************************************************
57512: ** This file contains the implementation of the sqlite3_backup_XXX()
57513: ** API functions and the related features.
57514: */
57515:
57516: /* Macro to find the minimum of two numeric values.
57517: */
57518: #ifndef MIN
57519: # define MIN(x,y) ((x)<(y)?(x):(y))
57520: #endif
57521:
57522: /*
57523: ** Structure allocated for each backup operation.
57524: */
57525: struct sqlite3_backup {
57526: sqlite3* pDestDb; /* Destination database handle */
57527: Btree *pDest; /* Destination b-tree file */
57528: u32 iDestSchema; /* Original schema cookie in destination */
57529: int bDestLocked; /* True once a write-transaction is open on pDest */
57530:
57531: Pgno iNext; /* Page number of the next source page to copy */
57532: sqlite3* pSrcDb; /* Source database handle */
57533: Btree *pSrc; /* Source b-tree file */
57534:
57535: int rc; /* Backup process error code */
57536:
57537: /* These two variables are set by every call to backup_step(). They are
57538: ** read by calls to backup_remaining() and backup_pagecount().
57539: */
57540: Pgno nRemaining; /* Number of pages left to copy */
57541: Pgno nPagecount; /* Total number of pages to copy */
57542:
57543: int isAttached; /* True once backup has been registered with pager */
57544: sqlite3_backup *pNext; /* Next backup associated with source pager */
57545: };
57546:
57547: /*
57548: ** THREAD SAFETY NOTES:
57549: **
57550: ** Once it has been created using backup_init(), a single sqlite3_backup
57551: ** structure may be accessed via two groups of thread-safe entry points:
57552: **
57553: ** * Via the sqlite3_backup_XXX() API function backup_step() and
57554: ** backup_finish(). Both these functions obtain the source database
57555: ** handle mutex and the mutex associated with the source BtShared
57556: ** structure, in that order.
57557: **
57558: ** * Via the BackupUpdate() and BackupRestart() functions, which are
57559: ** invoked by the pager layer to report various state changes in
57560: ** the page cache associated with the source database. The mutex
57561: ** associated with the source database BtShared structure will always
57562: ** be held when either of these functions are invoked.
57563: **
57564: ** The other sqlite3_backup_XXX() API functions, backup_remaining() and
57565: ** backup_pagecount() are not thread-safe functions. If they are called
57566: ** while some other thread is calling backup_step() or backup_finish(),
57567: ** the values returned may be invalid. There is no way for a call to
57568: ** BackupUpdate() or BackupRestart() to interfere with backup_remaining()
57569: ** or backup_pagecount().
57570: **
57571: ** Depending on the SQLite configuration, the database handles and/or
57572: ** the Btree objects may have their own mutexes that require locking.
57573: ** Non-sharable Btrees (in-memory databases for example), do not have
57574: ** associated mutexes.
57575: */
57576:
57577: /*
57578: ** Return a pointer corresponding to database zDb (i.e. "main", "temp")
57579: ** in connection handle pDb. If such a database cannot be found, return
57580: ** a NULL pointer and write an error message to pErrorDb.
57581: **
57582: ** If the "temp" database is requested, it may need to be opened by this
57583: ** function. If an error occurs while doing so, return 0 and write an
57584: ** error message to pErrorDb.
57585: */
57586: static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){
57587: int i = sqlite3FindDbName(pDb, zDb);
57588:
57589: if( i==1 ){
57590: Parse *pParse;
57591: int rc = 0;
57592: pParse = sqlite3StackAllocZero(pErrorDb, sizeof(*pParse));
57593: if( pParse==0 ){
57594: sqlite3Error(pErrorDb, SQLITE_NOMEM, "out of memory");
57595: rc = SQLITE_NOMEM;
57596: }else{
57597: pParse->db = pDb;
57598: if( sqlite3OpenTempDatabase(pParse) ){
57599: sqlite3Error(pErrorDb, pParse->rc, "%s", pParse->zErrMsg);
57600: rc = SQLITE_ERROR;
57601: }
57602: sqlite3DbFree(pErrorDb, pParse->zErrMsg);
57603: sqlite3StackFree(pErrorDb, pParse);
57604: }
57605: if( rc ){
57606: return 0;
57607: }
57608: }
57609:
57610: if( i<0 ){
57611: sqlite3Error(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb);
57612: return 0;
57613: }
57614:
57615: return pDb->aDb[i].pBt;
57616: }
57617:
57618: /*
57619: ** Attempt to set the page size of the destination to match the page size
57620: ** of the source.
57621: */
57622: static int setDestPgsz(sqlite3_backup *p){
57623: int rc;
57624: rc = sqlite3BtreeSetPageSize(p->pDest,sqlite3BtreeGetPageSize(p->pSrc),-1,0);
57625: return rc;
57626: }
57627:
57628: /*
57629: ** Create an sqlite3_backup process to copy the contents of zSrcDb from
57630: ** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
57631: ** a pointer to the new sqlite3_backup object.
57632: **
57633: ** If an error occurs, NULL is returned and an error code and error message
57634: ** stored in database handle pDestDb.
57635: */
57636: SQLITE_API sqlite3_backup *sqlite3_backup_init(
57637: sqlite3* pDestDb, /* Database to write to */
57638: const char *zDestDb, /* Name of database within pDestDb */
57639: sqlite3* pSrcDb, /* Database connection to read from */
57640: const char *zSrcDb /* Name of database within pSrcDb */
57641: ){
57642: sqlite3_backup *p; /* Value to return */
57643:
57644: /* Lock the source database handle. The destination database
57645: ** handle is not locked in this routine, but it is locked in
57646: ** sqlite3_backup_step(). The user is required to ensure that no
57647: ** other thread accesses the destination handle for the duration
57648: ** of the backup operation. Any attempt to use the destination
57649: ** database connection while a backup is in progress may cause
57650: ** a malfunction or a deadlock.
57651: */
57652: sqlite3_mutex_enter(pSrcDb->mutex);
57653: sqlite3_mutex_enter(pDestDb->mutex);
57654:
57655: if( pSrcDb==pDestDb ){
57656: sqlite3Error(
57657: pDestDb, SQLITE_ERROR, "source and destination must be distinct"
57658: );
57659: p = 0;
57660: }else {
57661: /* Allocate space for a new sqlite3_backup object...
57662: ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
57663: ** call to sqlite3_backup_init() and is destroyed by a call to
57664: ** sqlite3_backup_finish(). */
57665: p = (sqlite3_backup *)sqlite3_malloc(sizeof(sqlite3_backup));
57666: if( !p ){
57667: sqlite3Error(pDestDb, SQLITE_NOMEM, 0);
57668: }
57669: }
57670:
57671: /* If the allocation succeeded, populate the new object. */
57672: if( p ){
57673: memset(p, 0, sizeof(sqlite3_backup));
57674: p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
57675: p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
57676: p->pDestDb = pDestDb;
57677: p->pSrcDb = pSrcDb;
57678: p->iNext = 1;
57679: p->isAttached = 0;
57680:
57681: if( 0==p->pSrc || 0==p->pDest || setDestPgsz(p)==SQLITE_NOMEM ){
57682: /* One (or both) of the named databases did not exist or an OOM
57683: ** error was hit. The error has already been written into the
57684: ** pDestDb handle. All that is left to do here is free the
57685: ** sqlite3_backup structure.
57686: */
57687: sqlite3_free(p);
57688: p = 0;
57689: }
57690: }
57691: if( p ){
57692: p->pSrc->nBackup++;
57693: }
57694:
57695: sqlite3_mutex_leave(pDestDb->mutex);
57696: sqlite3_mutex_leave(pSrcDb->mutex);
57697: return p;
57698: }
57699:
57700: /*
57701: ** Argument rc is an SQLite error code. Return true if this error is
57702: ** considered fatal if encountered during a backup operation. All errors
57703: ** are considered fatal except for SQLITE_BUSY and SQLITE_LOCKED.
57704: */
57705: static int isFatalError(int rc){
57706: return (rc!=SQLITE_OK && rc!=SQLITE_BUSY && ALWAYS(rc!=SQLITE_LOCKED));
57707: }
57708:
57709: /*
57710: ** Parameter zSrcData points to a buffer containing the data for
57711: ** page iSrcPg from the source database. Copy this data into the
57712: ** destination database.
57713: */
57714: static int backupOnePage(sqlite3_backup *p, Pgno iSrcPg, const u8 *zSrcData){
57715: Pager * const pDestPager = sqlite3BtreePager(p->pDest);
57716: const int nSrcPgsz = sqlite3BtreeGetPageSize(p->pSrc);
57717: int nDestPgsz = sqlite3BtreeGetPageSize(p->pDest);
57718: const int nCopy = MIN(nSrcPgsz, nDestPgsz);
57719: const i64 iEnd = (i64)iSrcPg*(i64)nSrcPgsz;
57720: #ifdef SQLITE_HAS_CODEC
57721: int nSrcReserve = sqlite3BtreeGetReserve(p->pSrc);
57722: int nDestReserve = sqlite3BtreeGetReserve(p->pDest);
57723: #endif
57724:
57725: int rc = SQLITE_OK;
57726: i64 iOff;
57727:
57728: assert( p->bDestLocked );
57729: assert( !isFatalError(p->rc) );
57730: assert( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) );
57731: assert( zSrcData );
57732:
57733: /* Catch the case where the destination is an in-memory database and the
57734: ** page sizes of the source and destination differ.
57735: */
57736: if( nSrcPgsz!=nDestPgsz && sqlite3PagerIsMemdb(pDestPager) ){
57737: rc = SQLITE_READONLY;
57738: }
57739:
57740: #ifdef SQLITE_HAS_CODEC
57741: /* Backup is not possible if the page size of the destination is changing
57742: ** and a codec is in use.
57743: */
57744: if( nSrcPgsz!=nDestPgsz && sqlite3PagerGetCodec(pDestPager)!=0 ){
57745: rc = SQLITE_READONLY;
57746: }
57747:
57748: /* Backup is not possible if the number of bytes of reserve space differ
57749: ** between source and destination. If there is a difference, try to
57750: ** fix the destination to agree with the source. If that is not possible,
57751: ** then the backup cannot proceed.
57752: */
57753: if( nSrcReserve!=nDestReserve ){
57754: u32 newPgsz = nSrcPgsz;
57755: rc = sqlite3PagerSetPagesize(pDestPager, &newPgsz, nSrcReserve);
57756: if( rc==SQLITE_OK && newPgsz!=nSrcPgsz ) rc = SQLITE_READONLY;
57757: }
57758: #endif
57759:
57760: /* This loop runs once for each destination page spanned by the source
57761: ** page. For each iteration, variable iOff is set to the byte offset
57762: ** of the destination page.
57763: */
57764: for(iOff=iEnd-(i64)nSrcPgsz; rc==SQLITE_OK && iOff<iEnd; iOff+=nDestPgsz){
57765: DbPage *pDestPg = 0;
57766: Pgno iDest = (Pgno)(iOff/nDestPgsz)+1;
57767: if( iDest==PENDING_BYTE_PAGE(p->pDest->pBt) ) continue;
57768: if( SQLITE_OK==(rc = sqlite3PagerGet(pDestPager, iDest, &pDestPg))
57769: && SQLITE_OK==(rc = sqlite3PagerWrite(pDestPg))
57770: ){
57771: const u8 *zIn = &zSrcData[iOff%nSrcPgsz];
57772: u8 *zDestData = sqlite3PagerGetData(pDestPg);
57773: u8 *zOut = &zDestData[iOff%nDestPgsz];
57774:
57775: /* Copy the data from the source page into the destination page.
57776: ** Then clear the Btree layer MemPage.isInit flag. Both this module
57777: ** and the pager code use this trick (clearing the first byte
57778: ** of the page 'extra' space to invalidate the Btree layers
57779: ** cached parse of the page). MemPage.isInit is marked
57780: ** "MUST BE FIRST" for this purpose.
57781: */
57782: memcpy(zOut, zIn, nCopy);
57783: ((u8 *)sqlite3PagerGetExtra(pDestPg))[0] = 0;
57784: }
57785: sqlite3PagerUnref(pDestPg);
57786: }
57787:
57788: return rc;
57789: }
57790:
57791: /*
57792: ** If pFile is currently larger than iSize bytes, then truncate it to
57793: ** exactly iSize bytes. If pFile is not larger than iSize bytes, then
57794: ** this function is a no-op.
57795: **
57796: ** Return SQLITE_OK if everything is successful, or an SQLite error
57797: ** code if an error occurs.
57798: */
57799: static int backupTruncateFile(sqlite3_file *pFile, i64 iSize){
57800: i64 iCurrent;
57801: int rc = sqlite3OsFileSize(pFile, &iCurrent);
57802: if( rc==SQLITE_OK && iCurrent>iSize ){
57803: rc = sqlite3OsTruncate(pFile, iSize);
57804: }
57805: return rc;
57806: }
57807:
57808: /*
57809: ** Register this backup object with the associated source pager for
57810: ** callbacks when pages are changed or the cache invalidated.
57811: */
57812: static void attachBackupObject(sqlite3_backup *p){
57813: sqlite3_backup **pp;
57814: assert( sqlite3BtreeHoldsMutex(p->pSrc) );
57815: pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
57816: p->pNext = *pp;
57817: *pp = p;
57818: p->isAttached = 1;
57819: }
57820:
57821: /*
57822: ** Copy nPage pages from the source b-tree to the destination.
57823: */
57824: SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage){
57825: int rc;
57826: int destMode; /* Destination journal mode */
57827: int pgszSrc = 0; /* Source page size */
57828: int pgszDest = 0; /* Destination page size */
57829:
57830: sqlite3_mutex_enter(p->pSrcDb->mutex);
57831: sqlite3BtreeEnter(p->pSrc);
57832: if( p->pDestDb ){
57833: sqlite3_mutex_enter(p->pDestDb->mutex);
57834: }
57835:
57836: rc = p->rc;
57837: if( !isFatalError(rc) ){
57838: Pager * const pSrcPager = sqlite3BtreePager(p->pSrc); /* Source pager */
57839: Pager * const pDestPager = sqlite3BtreePager(p->pDest); /* Dest pager */
57840: int ii; /* Iterator variable */
57841: int nSrcPage = -1; /* Size of source db in pages */
57842: int bCloseTrans = 0; /* True if src db requires unlocking */
57843:
57844: /* If the source pager is currently in a write-transaction, return
57845: ** SQLITE_BUSY immediately.
57846: */
57847: if( p->pDestDb && p->pSrc->pBt->inTransaction==TRANS_WRITE ){
57848: rc = SQLITE_BUSY;
57849: }else{
57850: rc = SQLITE_OK;
57851: }
57852:
57853: /* Lock the destination database, if it is not locked already. */
57854: if( SQLITE_OK==rc && p->bDestLocked==0
57855: && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2))
57856: ){
57857: p->bDestLocked = 1;
57858: sqlite3BtreeGetMeta(p->pDest, BTREE_SCHEMA_VERSION, &p->iDestSchema);
57859: }
57860:
57861: /* If there is no open read-transaction on the source database, open
57862: ** one now. If a transaction is opened here, then it will be closed
57863: ** before this function exits.
57864: */
57865: if( rc==SQLITE_OK && 0==sqlite3BtreeIsInReadTrans(p->pSrc) ){
57866: rc = sqlite3BtreeBeginTrans(p->pSrc, 0);
57867: bCloseTrans = 1;
57868: }
57869:
57870: /* Do not allow backup if the destination database is in WAL mode
57871: ** and the page sizes are different between source and destination */
57872: pgszSrc = sqlite3BtreeGetPageSize(p->pSrc);
57873: pgszDest = sqlite3BtreeGetPageSize(p->pDest);
57874: destMode = sqlite3PagerGetJournalMode(sqlite3BtreePager(p->pDest));
57875: if( SQLITE_OK==rc && destMode==PAGER_JOURNALMODE_WAL && pgszSrc!=pgszDest ){
57876: rc = SQLITE_READONLY;
57877: }
57878:
57879: /* Now that there is a read-lock on the source database, query the
57880: ** source pager for the number of pages in the database.
57881: */
57882: nSrcPage = (int)sqlite3BtreeLastPage(p->pSrc);
57883: assert( nSrcPage>=0 );
57884: for(ii=0; (nPage<0 || ii<nPage) && p->iNext<=(Pgno)nSrcPage && !rc; ii++){
57885: const Pgno iSrcPg = p->iNext; /* Source page number */
57886: if( iSrcPg!=PENDING_BYTE_PAGE(p->pSrc->pBt) ){
57887: DbPage *pSrcPg; /* Source page object */
57888: rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg);
57889: if( rc==SQLITE_OK ){
57890: rc = backupOnePage(p, iSrcPg, sqlite3PagerGetData(pSrcPg));
57891: sqlite3PagerUnref(pSrcPg);
57892: }
57893: }
57894: p->iNext++;
57895: }
57896: if( rc==SQLITE_OK ){
57897: p->nPagecount = nSrcPage;
57898: p->nRemaining = nSrcPage+1-p->iNext;
57899: if( p->iNext>(Pgno)nSrcPage ){
57900: rc = SQLITE_DONE;
57901: }else if( !p->isAttached ){
57902: attachBackupObject(p);
57903: }
57904: }
57905:
57906: /* Update the schema version field in the destination database. This
57907: ** is to make sure that the schema-version really does change in
57908: ** the case where the source and destination databases have the
57909: ** same schema version.
57910: */
57911: if( rc==SQLITE_DONE ){
57912: rc = sqlite3BtreeUpdateMeta(p->pDest,1,p->iDestSchema+1);
57913: if( rc==SQLITE_OK ){
57914: if( p->pDestDb ){
57915: sqlite3ResetInternalSchema(p->pDestDb, -1);
57916: }
57917: if( destMode==PAGER_JOURNALMODE_WAL ){
57918: rc = sqlite3BtreeSetVersion(p->pDest, 2);
57919: }
57920: }
57921: if( rc==SQLITE_OK ){
57922: int nDestTruncate;
57923: /* Set nDestTruncate to the final number of pages in the destination
57924: ** database. The complication here is that the destination page
57925: ** size may be different to the source page size.
57926: **
57927: ** If the source page size is smaller than the destination page size,
57928: ** round up. In this case the call to sqlite3OsTruncate() below will
57929: ** fix the size of the file. However it is important to call
57930: ** sqlite3PagerTruncateImage() here so that any pages in the
57931: ** destination file that lie beyond the nDestTruncate page mark are
57932: ** journalled by PagerCommitPhaseOne() before they are destroyed
57933: ** by the file truncation.
57934: */
57935: assert( pgszSrc==sqlite3BtreeGetPageSize(p->pSrc) );
57936: assert( pgszDest==sqlite3BtreeGetPageSize(p->pDest) );
57937: if( pgszSrc<pgszDest ){
57938: int ratio = pgszDest/pgszSrc;
57939: nDestTruncate = (nSrcPage+ratio-1)/ratio;
57940: if( nDestTruncate==(int)PENDING_BYTE_PAGE(p->pDest->pBt) ){
57941: nDestTruncate--;
57942: }
57943: }else{
57944: nDestTruncate = nSrcPage * (pgszSrc/pgszDest);
57945: }
57946: sqlite3PagerTruncateImage(pDestPager, nDestTruncate);
57947:
57948: if( pgszSrc<pgszDest ){
57949: /* If the source page-size is smaller than the destination page-size,
57950: ** two extra things may need to happen:
57951: **
57952: ** * The destination may need to be truncated, and
57953: **
57954: ** * Data stored on the pages immediately following the
57955: ** pending-byte page in the source database may need to be
57956: ** copied into the destination database.
57957: */
57958: const i64 iSize = (i64)pgszSrc * (i64)nSrcPage;
57959: sqlite3_file * const pFile = sqlite3PagerFile(pDestPager);
57960: i64 iOff;
57961: i64 iEnd;
57962:
57963: assert( pFile );
57964: assert( (i64)nDestTruncate*(i64)pgszDest >= iSize || (
57965: nDestTruncate==(int)(PENDING_BYTE_PAGE(p->pDest->pBt)-1)
57966: && iSize>=PENDING_BYTE && iSize<=PENDING_BYTE+pgszDest
57967: ));
57968:
57969: /* This call ensures that all data required to recreate the original
57970: ** database has been stored in the journal for pDestPager and the
57971: ** journal synced to disk. So at this point we may safely modify
57972: ** the database file in any way, knowing that if a power failure
57973: ** occurs, the original database will be reconstructed from the
57974: ** journal file. */
57975: rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 1);
57976:
57977: /* Write the extra pages and truncate the database file as required */
57978: iEnd = MIN(PENDING_BYTE + pgszDest, iSize);
57979: for(
57980: iOff=PENDING_BYTE+pgszSrc;
57981: rc==SQLITE_OK && iOff<iEnd;
57982: iOff+=pgszSrc
57983: ){
57984: PgHdr *pSrcPg = 0;
57985: const Pgno iSrcPg = (Pgno)((iOff/pgszSrc)+1);
57986: rc = sqlite3PagerGet(pSrcPager, iSrcPg, &pSrcPg);
57987: if( rc==SQLITE_OK ){
57988: u8 *zData = sqlite3PagerGetData(pSrcPg);
57989: rc = sqlite3OsWrite(pFile, zData, pgszSrc, iOff);
57990: }
57991: sqlite3PagerUnref(pSrcPg);
57992: }
57993: if( rc==SQLITE_OK ){
57994: rc = backupTruncateFile(pFile, iSize);
57995: }
57996:
57997: /* Sync the database file to disk. */
57998: if( rc==SQLITE_OK ){
57999: rc = sqlite3PagerSync(pDestPager);
58000: }
58001: }else{
58002: rc = sqlite3PagerCommitPhaseOne(pDestPager, 0, 0);
58003: }
58004:
58005: /* Finish committing the transaction to the destination database. */
58006: if( SQLITE_OK==rc
58007: && SQLITE_OK==(rc = sqlite3BtreeCommitPhaseTwo(p->pDest, 0))
58008: ){
58009: rc = SQLITE_DONE;
58010: }
58011: }
58012: }
58013:
58014: /* If bCloseTrans is true, then this function opened a read transaction
58015: ** on the source database. Close the read transaction here. There is
58016: ** no need to check the return values of the btree methods here, as
58017: ** "committing" a read-only transaction cannot fail.
58018: */
58019: if( bCloseTrans ){
58020: TESTONLY( int rc2 );
58021: TESTONLY( rc2 = ) sqlite3BtreeCommitPhaseOne(p->pSrc, 0);
58022: TESTONLY( rc2 |= ) sqlite3BtreeCommitPhaseTwo(p->pSrc, 0);
58023: assert( rc2==SQLITE_OK );
58024: }
58025:
58026: if( rc==SQLITE_IOERR_NOMEM ){
58027: rc = SQLITE_NOMEM;
58028: }
58029: p->rc = rc;
58030: }
58031: if( p->pDestDb ){
58032: sqlite3_mutex_leave(p->pDestDb->mutex);
58033: }
58034: sqlite3BtreeLeave(p->pSrc);
58035: sqlite3_mutex_leave(p->pSrcDb->mutex);
58036: return rc;
58037: }
58038:
58039: /*
58040: ** Release all resources associated with an sqlite3_backup* handle.
58041: */
58042: SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p){
58043: sqlite3_backup **pp; /* Ptr to head of pagers backup list */
58044: MUTEX_LOGIC( sqlite3_mutex *mutex; ) /* Mutex to protect source database */
58045: int rc; /* Value to return */
58046:
58047: /* Enter the mutexes */
58048: if( p==0 ) return SQLITE_OK;
58049: sqlite3_mutex_enter(p->pSrcDb->mutex);
58050: sqlite3BtreeEnter(p->pSrc);
58051: MUTEX_LOGIC( mutex = p->pSrcDb->mutex; )
58052: if( p->pDestDb ){
58053: sqlite3_mutex_enter(p->pDestDb->mutex);
58054: }
58055:
58056: /* Detach this backup from the source pager. */
58057: if( p->pDestDb ){
58058: p->pSrc->nBackup--;
58059: }
58060: if( p->isAttached ){
58061: pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
58062: while( *pp!=p ){
58063: pp = &(*pp)->pNext;
58064: }
58065: *pp = p->pNext;
58066: }
58067:
58068: /* If a transaction is still open on the Btree, roll it back. */
58069: sqlite3BtreeRollback(p->pDest);
58070:
58071: /* Set the error code of the destination database handle. */
58072: rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
58073: sqlite3Error(p->pDestDb, rc, 0);
58074:
58075: /* Exit the mutexes and free the backup context structure. */
58076: if( p->pDestDb ){
58077: sqlite3_mutex_leave(p->pDestDb->mutex);
58078: }
58079: sqlite3BtreeLeave(p->pSrc);
58080: if( p->pDestDb ){
58081: /* EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
58082: ** call to sqlite3_backup_init() and is destroyed by a call to
58083: ** sqlite3_backup_finish(). */
58084: sqlite3_free(p);
58085: }
58086: sqlite3_mutex_leave(mutex);
58087: return rc;
58088: }
58089:
58090: /*
58091: ** Return the number of pages still to be backed up as of the most recent
58092: ** call to sqlite3_backup_step().
58093: */
58094: SQLITE_API int sqlite3_backup_remaining(sqlite3_backup *p){
58095: return p->nRemaining;
58096: }
58097:
58098: /*
58099: ** Return the total number of pages in the source database as of the most
58100: ** recent call to sqlite3_backup_step().
58101: */
58102: SQLITE_API int sqlite3_backup_pagecount(sqlite3_backup *p){
58103: return p->nPagecount;
58104: }
58105:
58106: /*
58107: ** This function is called after the contents of page iPage of the
58108: ** source database have been modified. If page iPage has already been
58109: ** copied into the destination database, then the data written to the
58110: ** destination is now invalidated. The destination copy of iPage needs
58111: ** to be updated with the new data before the backup operation is
58112: ** complete.
58113: **
58114: ** It is assumed that the mutex associated with the BtShared object
58115: ** corresponding to the source database is held when this function is
58116: ** called.
58117: */
58118: SQLITE_PRIVATE void sqlite3BackupUpdate(sqlite3_backup *pBackup, Pgno iPage, const u8 *aData){
58119: sqlite3_backup *p; /* Iterator variable */
58120: for(p=pBackup; p; p=p->pNext){
58121: assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
58122: if( !isFatalError(p->rc) && iPage<p->iNext ){
58123: /* The backup process p has already copied page iPage. But now it
58124: ** has been modified by a transaction on the source pager. Copy
58125: ** the new data into the backup.
58126: */
58127: int rc;
58128: assert( p->pDestDb );
58129: sqlite3_mutex_enter(p->pDestDb->mutex);
58130: rc = backupOnePage(p, iPage, aData);
58131: sqlite3_mutex_leave(p->pDestDb->mutex);
58132: assert( rc!=SQLITE_BUSY && rc!=SQLITE_LOCKED );
58133: if( rc!=SQLITE_OK ){
58134: p->rc = rc;
58135: }
58136: }
58137: }
58138: }
58139:
58140: /*
58141: ** Restart the backup process. This is called when the pager layer
58142: ** detects that the database has been modified by an external database
58143: ** connection. In this case there is no way of knowing which of the
58144: ** pages that have been copied into the destination database are still
58145: ** valid and which are not, so the entire process needs to be restarted.
58146: **
58147: ** It is assumed that the mutex associated with the BtShared object
58148: ** corresponding to the source database is held when this function is
58149: ** called.
58150: */
58151: SQLITE_PRIVATE void sqlite3BackupRestart(sqlite3_backup *pBackup){
58152: sqlite3_backup *p; /* Iterator variable */
58153: for(p=pBackup; p; p=p->pNext){
58154: assert( sqlite3_mutex_held(p->pSrc->pBt->mutex) );
58155: p->iNext = 1;
58156: }
58157: }
58158:
58159: #ifndef SQLITE_OMIT_VACUUM
58160: /*
58161: ** Copy the complete content of pBtFrom into pBtTo. A transaction
58162: ** must be active for both files.
58163: **
58164: ** The size of file pTo may be reduced by this operation. If anything
58165: ** goes wrong, the transaction on pTo is rolled back. If successful, the
58166: ** transaction is committed before returning.
58167: */
58168: SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){
58169: int rc;
58170: sqlite3_file *pFd; /* File descriptor for database pTo */
58171: sqlite3_backup b;
58172: sqlite3BtreeEnter(pTo);
58173: sqlite3BtreeEnter(pFrom);
58174:
58175: assert( sqlite3BtreeIsInTrans(pTo) );
58176: pFd = sqlite3PagerFile(sqlite3BtreePager(pTo));
58177: if( pFd->pMethods ){
58178: i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom);
58179: rc = sqlite3OsFileControl(pFd, SQLITE_FCNTL_OVERWRITE, &nByte);
58180: if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
58181: if( rc ) goto copy_finished;
58182: }
58183:
58184: /* Set up an sqlite3_backup object. sqlite3_backup.pDestDb must be set
58185: ** to 0. This is used by the implementations of sqlite3_backup_step()
58186: ** and sqlite3_backup_finish() to detect that they are being called
58187: ** from this function, not directly by the user.
58188: */
58189: memset(&b, 0, sizeof(b));
58190: b.pSrcDb = pFrom->db;
58191: b.pSrc = pFrom;
58192: b.pDest = pTo;
58193: b.iNext = 1;
58194:
58195: /* 0x7FFFFFFF is the hard limit for the number of pages in a database
58196: ** file. By passing this as the number of pages to copy to
58197: ** sqlite3_backup_step(), we can guarantee that the copy finishes
58198: ** within a single call (unless an error occurs). The assert() statement
58199: ** checks this assumption - (p->rc) should be set to either SQLITE_DONE
58200: ** or an error code.
58201: */
58202: sqlite3_backup_step(&b, 0x7FFFFFFF);
58203: assert( b.rc!=SQLITE_OK );
58204: rc = sqlite3_backup_finish(&b);
58205: if( rc==SQLITE_OK ){
58206: pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;
58207: }else{
58208: sqlite3PagerClearCache(sqlite3BtreePager(b.pDest));
58209: }
58210:
58211: assert( sqlite3BtreeIsInTrans(pTo)==0 );
58212: copy_finished:
58213: sqlite3BtreeLeave(pFrom);
58214: sqlite3BtreeLeave(pTo);
58215: return rc;
58216: }
58217: #endif /* SQLITE_OMIT_VACUUM */
58218:
58219: /************** End of backup.c **********************************************/
58220: /************** Begin file vdbemem.c *****************************************/
58221: /*
58222: ** 2004 May 26
58223: **
58224: ** The author disclaims copyright to this source code. In place of
58225: ** a legal notice, here is a blessing:
58226: **
58227: ** May you do good and not evil.
58228: ** May you find forgiveness for yourself and forgive others.
58229: ** May you share freely, never taking more than you give.
58230: **
58231: *************************************************************************
58232: **
58233: ** This file contains code use to manipulate "Mem" structure. A "Mem"
58234: ** stores a single value in the VDBE. Mem is an opaque structure visible
58235: ** only within the VDBE. Interface routines refer to a Mem using the
58236: ** name sqlite_value
58237: */
58238:
58239: /*
58240: ** If pMem is an object with a valid string representation, this routine
58241: ** ensures the internal encoding for the string representation is
58242: ** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
58243: **
58244: ** If pMem is not a string object, or the encoding of the string
58245: ** representation is already stored using the requested encoding, then this
58246: ** routine is a no-op.
58247: **
58248: ** SQLITE_OK is returned if the conversion is successful (or not required).
58249: ** SQLITE_NOMEM may be returned if a malloc() fails during conversion
58250: ** between formats.
58251: */
58252: SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
58253: int rc;
58254: assert( (pMem->flags&MEM_RowSet)==0 );
58255: assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
58256: || desiredEnc==SQLITE_UTF16BE );
58257: if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
58258: return SQLITE_OK;
58259: }
58260: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58261: #ifdef SQLITE_OMIT_UTF16
58262: return SQLITE_ERROR;
58263: #else
58264:
58265: /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
58266: ** then the encoding of the value may not have changed.
58267: */
58268: rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc);
58269: assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
58270: assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
58271: assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
58272: return rc;
58273: #endif
58274: }
58275:
58276: /*
58277: ** Make sure pMem->z points to a writable allocation of at least
58278: ** n bytes.
58279: **
58280: ** If the memory cell currently contains string or blob data
58281: ** and the third argument passed to this function is true, the
58282: ** current content of the cell is preserved. Otherwise, it may
58283: ** be discarded.
58284: **
58285: ** This function sets the MEM_Dyn flag and clears any xDel callback.
58286: ** It also clears MEM_Ephem and MEM_Static. If the preserve flag is
58287: ** not set, Mem.n is zeroed.
58288: */
58289: SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
58290: assert( 1 >=
58291: ((pMem->zMalloc && pMem->zMalloc==pMem->z) ? 1 : 0) +
58292: (((pMem->flags&MEM_Dyn)&&pMem->xDel) ? 1 : 0) +
58293: ((pMem->flags&MEM_Ephem) ? 1 : 0) +
58294: ((pMem->flags&MEM_Static) ? 1 : 0)
58295: );
58296: assert( (pMem->flags&MEM_RowSet)==0 );
58297:
58298: if( n<32 ) n = 32;
58299: if( sqlite3DbMallocSize(pMem->db, pMem->zMalloc)<n ){
58300: if( preserve && pMem->z==pMem->zMalloc ){
58301: pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
58302: preserve = 0;
58303: }else{
58304: sqlite3DbFree(pMem->db, pMem->zMalloc);
58305: pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
58306: }
58307: }
58308:
58309: if( pMem->z && preserve && pMem->zMalloc && pMem->z!=pMem->zMalloc ){
58310: memcpy(pMem->zMalloc, pMem->z, pMem->n);
58311: }
58312: if( pMem->flags&MEM_Dyn && pMem->xDel ){
58313: pMem->xDel((void *)(pMem->z));
58314: }
58315:
58316: pMem->z = pMem->zMalloc;
58317: if( pMem->z==0 ){
58318: pMem->flags = MEM_Null;
58319: }else{
58320: pMem->flags &= ~(MEM_Ephem|MEM_Static);
58321: }
58322: pMem->xDel = 0;
58323: return (pMem->z ? SQLITE_OK : SQLITE_NOMEM);
58324: }
58325:
58326: /*
58327: ** Make the given Mem object MEM_Dyn. In other words, make it so
58328: ** that any TEXT or BLOB content is stored in memory obtained from
58329: ** malloc(). In this way, we know that the memory is safe to be
58330: ** overwritten or altered.
58331: **
58332: ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
58333: */
58334: SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
58335: int f;
58336: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58337: assert( (pMem->flags&MEM_RowSet)==0 );
58338: ExpandBlob(pMem);
58339: f = pMem->flags;
58340: if( (f&(MEM_Str|MEM_Blob)) && pMem->z!=pMem->zMalloc ){
58341: if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
58342: return SQLITE_NOMEM;
58343: }
58344: pMem->z[pMem->n] = 0;
58345: pMem->z[pMem->n+1] = 0;
58346: pMem->flags |= MEM_Term;
58347: #ifdef SQLITE_DEBUG
58348: pMem->pScopyFrom = 0;
58349: #endif
58350: }
58351:
58352: return SQLITE_OK;
58353: }
58354:
58355: /*
58356: ** If the given Mem* has a zero-filled tail, turn it into an ordinary
58357: ** blob stored in dynamically allocated space.
58358: */
58359: #ifndef SQLITE_OMIT_INCRBLOB
58360: SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
58361: if( pMem->flags & MEM_Zero ){
58362: int nByte;
58363: assert( pMem->flags&MEM_Blob );
58364: assert( (pMem->flags&MEM_RowSet)==0 );
58365: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58366:
58367: /* Set nByte to the number of bytes required to store the expanded blob. */
58368: nByte = pMem->n + pMem->u.nZero;
58369: if( nByte<=0 ){
58370: nByte = 1;
58371: }
58372: if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
58373: return SQLITE_NOMEM;
58374: }
58375:
58376: memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
58377: pMem->n += pMem->u.nZero;
58378: pMem->flags &= ~(MEM_Zero|MEM_Term);
58379: }
58380: return SQLITE_OK;
58381: }
58382: #endif
58383:
58384:
58385: /*
58386: ** Make sure the given Mem is \u0000 terminated.
58387: */
58388: SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
58389: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58390: if( (pMem->flags & MEM_Term)!=0 || (pMem->flags & MEM_Str)==0 ){
58391: return SQLITE_OK; /* Nothing to do */
58392: }
58393: if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){
58394: return SQLITE_NOMEM;
58395: }
58396: pMem->z[pMem->n] = 0;
58397: pMem->z[pMem->n+1] = 0;
58398: pMem->flags |= MEM_Term;
58399: return SQLITE_OK;
58400: }
58401:
58402: /*
58403: ** Add MEM_Str to the set of representations for the given Mem. Numbers
58404: ** are converted using sqlite3_snprintf(). Converting a BLOB to a string
58405: ** is a no-op.
58406: **
58407: ** Existing representations MEM_Int and MEM_Real are *not* invalidated.
58408: **
58409: ** A MEM_Null value will never be passed to this function. This function is
58410: ** used for converting values to text for returning to the user (i.e. via
58411: ** sqlite3_value_text()), or for ensuring that values to be used as btree
58412: ** keys are strings. In the former case a NULL pointer is returned the
58413: ** user and the later is an internal programming error.
58414: */
58415: SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, int enc){
58416: int rc = SQLITE_OK;
58417: int fg = pMem->flags;
58418: const int nByte = 32;
58419:
58420: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58421: assert( !(fg&MEM_Zero) );
58422: assert( !(fg&(MEM_Str|MEM_Blob)) );
58423: assert( fg&(MEM_Int|MEM_Real) );
58424: assert( (pMem->flags&MEM_RowSet)==0 );
58425: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58426:
58427:
58428: if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
58429: return SQLITE_NOMEM;
58430: }
58431:
58432: /* For a Real or Integer, use sqlite3_mprintf() to produce the UTF-8
58433: ** string representation of the value. Then, if the required encoding
58434: ** is UTF-16le or UTF-16be do a translation.
58435: **
58436: ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
58437: */
58438: if( fg & MEM_Int ){
58439: sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
58440: }else{
58441: assert( fg & MEM_Real );
58442: sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
58443: }
58444: pMem->n = sqlite3Strlen30(pMem->z);
58445: pMem->enc = SQLITE_UTF8;
58446: pMem->flags |= MEM_Str|MEM_Term;
58447: sqlite3VdbeChangeEncoding(pMem, enc);
58448: return rc;
58449: }
58450:
58451: /*
58452: ** Memory cell pMem contains the context of an aggregate function.
58453: ** This routine calls the finalize method for that function. The
58454: ** result of the aggregate is stored back into pMem.
58455: **
58456: ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
58457: ** otherwise.
58458: */
58459: SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
58460: int rc = SQLITE_OK;
58461: if( ALWAYS(pFunc && pFunc->xFinalize) ){
58462: sqlite3_context ctx;
58463: assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
58464: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58465: memset(&ctx, 0, sizeof(ctx));
58466: ctx.s.flags = MEM_Null;
58467: ctx.s.db = pMem->db;
58468: ctx.pMem = pMem;
58469: ctx.pFunc = pFunc;
58470: pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
58471: assert( 0==(pMem->flags&MEM_Dyn) && !pMem->xDel );
58472: sqlite3DbFree(pMem->db, pMem->zMalloc);
58473: memcpy(pMem, &ctx.s, sizeof(ctx.s));
58474: rc = ctx.isError;
58475: }
58476: return rc;
58477: }
58478:
58479: /*
58480: ** If the memory cell contains a string value that must be freed by
58481: ** invoking an external callback, free it now. Calling this function
58482: ** does not free any Mem.zMalloc buffer.
58483: */
58484: SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p){
58485: assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
58486: if( p->flags&MEM_Agg ){
58487: sqlite3VdbeMemFinalize(p, p->u.pDef);
58488: assert( (p->flags & MEM_Agg)==0 );
58489: sqlite3VdbeMemRelease(p);
58490: }else if( p->flags&MEM_Dyn && p->xDel ){
58491: assert( (p->flags&MEM_RowSet)==0 );
58492: p->xDel((void *)p->z);
58493: p->xDel = 0;
58494: }else if( p->flags&MEM_RowSet ){
58495: sqlite3RowSetClear(p->u.pRowSet);
58496: }else if( p->flags&MEM_Frame ){
58497: sqlite3VdbeMemSetNull(p);
58498: }
58499: }
58500:
58501: /*
58502: ** Release any memory held by the Mem. This may leave the Mem in an
58503: ** inconsistent state, for example with (Mem.z==0) and
58504: ** (Mem.type==SQLITE_TEXT).
58505: */
58506: SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
58507: VdbeMemRelease(p);
58508: sqlite3DbFree(p->db, p->zMalloc);
58509: p->z = 0;
58510: p->zMalloc = 0;
58511: p->xDel = 0;
58512: }
58513:
58514: /*
58515: ** Convert a 64-bit IEEE double into a 64-bit signed integer.
58516: ** If the double is too large, return 0x8000000000000000.
58517: **
58518: ** Most systems appear to do this simply by assigning
58519: ** variables and without the extra range tests. But
58520: ** there are reports that windows throws an expection
58521: ** if the floating point value is out of range. (See ticket #2880.)
58522: ** Because we do not completely understand the problem, we will
58523: ** take the conservative approach and always do range tests
58524: ** before attempting the conversion.
58525: */
58526: static i64 doubleToInt64(double r){
58527: #ifdef SQLITE_OMIT_FLOATING_POINT
58528: /* When floating-point is omitted, double and int64 are the same thing */
58529: return r;
58530: #else
58531: /*
58532: ** Many compilers we encounter do not define constants for the
58533: ** minimum and maximum 64-bit integers, or they define them
58534: ** inconsistently. And many do not understand the "LL" notation.
58535: ** So we define our own static constants here using nothing
58536: ** larger than a 32-bit integer constant.
58537: */
58538: static const i64 maxInt = LARGEST_INT64;
58539: static const i64 minInt = SMALLEST_INT64;
58540:
58541: if( r<(double)minInt ){
58542: return minInt;
58543: }else if( r>(double)maxInt ){
58544: /* minInt is correct here - not maxInt. It turns out that assigning
58545: ** a very large positive number to an integer results in a very large
58546: ** negative integer. This makes no sense, but it is what x86 hardware
58547: ** does so for compatibility we will do the same in software. */
58548: return minInt;
58549: }else{
58550: return (i64)r;
58551: }
58552: #endif
58553: }
58554:
58555: /*
58556: ** Return some kind of integer value which is the best we can do
58557: ** at representing the value that *pMem describes as an integer.
58558: ** If pMem is an integer, then the value is exact. If pMem is
58559: ** a floating-point then the value returned is the integer part.
58560: ** If pMem is a string or blob, then we make an attempt to convert
58561: ** it into a integer and return that. If pMem represents an
58562: ** an SQL-NULL value, return 0.
58563: **
58564: ** If pMem represents a string value, its encoding might be changed.
58565: */
58566: SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
58567: int flags;
58568: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58569: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58570: flags = pMem->flags;
58571: if( flags & MEM_Int ){
58572: return pMem->u.i;
58573: }else if( flags & MEM_Real ){
58574: return doubleToInt64(pMem->r);
58575: }else if( flags & (MEM_Str|MEM_Blob) ){
58576: i64 value = 0;
58577: assert( pMem->z || pMem->n==0 );
58578: testcase( pMem->z==0 );
58579: sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
58580: return value;
58581: }else{
58582: return 0;
58583: }
58584: }
58585:
58586: /*
58587: ** Return the best representation of pMem that we can get into a
58588: ** double. If pMem is already a double or an integer, return its
58589: ** value. If it is a string or blob, try to convert it to a double.
58590: ** If it is a NULL, return 0.0.
58591: */
58592: SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
58593: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58594: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58595: if( pMem->flags & MEM_Real ){
58596: return pMem->r;
58597: }else if( pMem->flags & MEM_Int ){
58598: return (double)pMem->u.i;
58599: }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
58600: /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
58601: double val = (double)0;
58602: sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
58603: return val;
58604: }else{
58605: /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
58606: return (double)0;
58607: }
58608: }
58609:
58610: /*
58611: ** The MEM structure is already a MEM_Real. Try to also make it a
58612: ** MEM_Int if we can.
58613: */
58614: SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
58615: assert( pMem->flags & MEM_Real );
58616: assert( (pMem->flags & MEM_RowSet)==0 );
58617: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58618: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58619:
58620: pMem->u.i = doubleToInt64(pMem->r);
58621:
58622: /* Only mark the value as an integer if
58623: **
58624: ** (1) the round-trip conversion real->int->real is a no-op, and
58625: ** (2) The integer is neither the largest nor the smallest
58626: ** possible integer (ticket #3922)
58627: **
58628: ** The second and third terms in the following conditional enforces
58629: ** the second condition under the assumption that addition overflow causes
58630: ** values to wrap around. On x86 hardware, the third term is always
58631: ** true and could be omitted. But we leave it in because other
58632: ** architectures might behave differently.
58633: */
58634: if( pMem->r==(double)pMem->u.i && pMem->u.i>SMALLEST_INT64
58635: && ALWAYS(pMem->u.i<LARGEST_INT64) ){
58636: pMem->flags |= MEM_Int;
58637: }
58638: }
58639:
58640: /*
58641: ** Convert pMem to type integer. Invalidate any prior representations.
58642: */
58643: SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
58644: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58645: assert( (pMem->flags & MEM_RowSet)==0 );
58646: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58647:
58648: pMem->u.i = sqlite3VdbeIntValue(pMem);
58649: MemSetTypeFlag(pMem, MEM_Int);
58650: return SQLITE_OK;
58651: }
58652:
58653: /*
58654: ** Convert pMem so that it is of type MEM_Real.
58655: ** Invalidate any prior representations.
58656: */
58657: SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){
58658: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58659: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
58660:
58661: pMem->r = sqlite3VdbeRealValue(pMem);
58662: MemSetTypeFlag(pMem, MEM_Real);
58663: return SQLITE_OK;
58664: }
58665:
58666: /*
58667: ** Convert pMem so that it has types MEM_Real or MEM_Int or both.
58668: ** Invalidate any prior representations.
58669: **
58670: ** Every effort is made to force the conversion, even if the input
58671: ** is a string that does not look completely like a number. Convert
58672: ** as much of the string as we can and ignore the rest.
58673: */
58674: SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
58675: if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){
58676: assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
58677: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58678: if( 0==sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc) ){
58679: MemSetTypeFlag(pMem, MEM_Int);
58680: }else{
58681: pMem->r = sqlite3VdbeRealValue(pMem);
58682: MemSetTypeFlag(pMem, MEM_Real);
58683: sqlite3VdbeIntegerAffinity(pMem);
58684: }
58685: }
58686: assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
58687: pMem->flags &= ~(MEM_Str|MEM_Blob);
58688: return SQLITE_OK;
58689: }
58690:
58691: /*
58692: ** Delete any previous value and set the value stored in *pMem to NULL.
58693: */
58694: SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){
58695: if( pMem->flags & MEM_Frame ){
58696: VdbeFrame *pFrame = pMem->u.pFrame;
58697: pFrame->pParent = pFrame->v->pDelFrame;
58698: pFrame->v->pDelFrame = pFrame;
58699: }
58700: if( pMem->flags & MEM_RowSet ){
58701: sqlite3RowSetClear(pMem->u.pRowSet);
58702: }
58703: MemSetTypeFlag(pMem, MEM_Null);
58704: pMem->type = SQLITE_NULL;
58705: }
58706:
58707: /*
58708: ** Delete any previous value and set the value to be a BLOB of length
58709: ** n containing all zeros.
58710: */
58711: SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
58712: sqlite3VdbeMemRelease(pMem);
58713: pMem->flags = MEM_Blob|MEM_Zero;
58714: pMem->type = SQLITE_BLOB;
58715: pMem->n = 0;
58716: if( n<0 ) n = 0;
58717: pMem->u.nZero = n;
58718: pMem->enc = SQLITE_UTF8;
58719:
58720: #ifdef SQLITE_OMIT_INCRBLOB
58721: sqlite3VdbeMemGrow(pMem, n, 0);
58722: if( pMem->z ){
58723: pMem->n = n;
58724: memset(pMem->z, 0, n);
58725: }
58726: #endif
58727: }
58728:
58729: /*
58730: ** Delete any previous value and set the value stored in *pMem to val,
58731: ** manifest type INTEGER.
58732: */
58733: SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
58734: sqlite3VdbeMemRelease(pMem);
58735: pMem->u.i = val;
58736: pMem->flags = MEM_Int;
58737: pMem->type = SQLITE_INTEGER;
58738: }
58739:
58740: #ifndef SQLITE_OMIT_FLOATING_POINT
58741: /*
58742: ** Delete any previous value and set the value stored in *pMem to val,
58743: ** manifest type REAL.
58744: */
58745: SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
58746: if( sqlite3IsNaN(val) ){
58747: sqlite3VdbeMemSetNull(pMem);
58748: }else{
58749: sqlite3VdbeMemRelease(pMem);
58750: pMem->r = val;
58751: pMem->flags = MEM_Real;
58752: pMem->type = SQLITE_FLOAT;
58753: }
58754: }
58755: #endif
58756:
58757: /*
58758: ** Delete any previous value and set the value of pMem to be an
58759: ** empty boolean index.
58760: */
58761: SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){
58762: sqlite3 *db = pMem->db;
58763: assert( db!=0 );
58764: assert( (pMem->flags & MEM_RowSet)==0 );
58765: sqlite3VdbeMemRelease(pMem);
58766: pMem->zMalloc = sqlite3DbMallocRaw(db, 64);
58767: if( db->mallocFailed ){
58768: pMem->flags = MEM_Null;
58769: }else{
58770: assert( pMem->zMalloc );
58771: pMem->u.pRowSet = sqlite3RowSetInit(db, pMem->zMalloc,
58772: sqlite3DbMallocSize(db, pMem->zMalloc));
58773: assert( pMem->u.pRowSet!=0 );
58774: pMem->flags = MEM_RowSet;
58775: }
58776: }
58777:
58778: /*
58779: ** Return true if the Mem object contains a TEXT or BLOB that is
58780: ** too large - whose size exceeds SQLITE_MAX_LENGTH.
58781: */
58782: SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){
58783: assert( p->db!=0 );
58784: if( p->flags & (MEM_Str|MEM_Blob) ){
58785: int n = p->n;
58786: if( p->flags & MEM_Zero ){
58787: n += p->u.nZero;
58788: }
58789: return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
58790: }
58791: return 0;
58792: }
58793:
58794: #ifdef SQLITE_DEBUG
58795: /*
58796: ** This routine prepares a memory cell for modication by breaking
58797: ** its link to a shallow copy and by marking any current shallow
58798: ** copies of this cell as invalid.
58799: **
58800: ** This is used for testing and debugging only - to make sure shallow
58801: ** copies are not misused.
58802: */
58803: SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
58804: int i;
58805: Mem *pX;
58806: for(i=1, pX=&pVdbe->aMem[1]; i<=pVdbe->nMem; i++, pX++){
58807: if( pX->pScopyFrom==pMem ){
58808: pX->flags |= MEM_Invalid;
58809: pX->pScopyFrom = 0;
58810: }
58811: }
58812: pMem->pScopyFrom = 0;
58813: }
58814: #endif /* SQLITE_DEBUG */
58815:
58816: /*
58817: ** Size of struct Mem not including the Mem.zMalloc member.
58818: */
58819: #define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
58820:
58821: /*
58822: ** Make an shallow copy of pFrom into pTo. Prior contents of
58823: ** pTo are freed. The pFrom->z field is not duplicated. If
58824: ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
58825: ** and flags gets srcType (either MEM_Ephem or MEM_Static).
58826: */
58827: SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
58828: assert( (pFrom->flags & MEM_RowSet)==0 );
58829: VdbeMemRelease(pTo);
58830: memcpy(pTo, pFrom, MEMCELLSIZE);
58831: pTo->xDel = 0;
58832: if( (pFrom->flags&MEM_Static)==0 ){
58833: pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
58834: assert( srcType==MEM_Ephem || srcType==MEM_Static );
58835: pTo->flags |= srcType;
58836: }
58837: }
58838:
58839: /*
58840: ** Make a full copy of pFrom into pTo. Prior contents of pTo are
58841: ** freed before the copy is made.
58842: */
58843: SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
58844: int rc = SQLITE_OK;
58845:
58846: assert( (pFrom->flags & MEM_RowSet)==0 );
58847: VdbeMemRelease(pTo);
58848: memcpy(pTo, pFrom, MEMCELLSIZE);
58849: pTo->flags &= ~MEM_Dyn;
58850:
58851: if( pTo->flags&(MEM_Str|MEM_Blob) ){
58852: if( 0==(pFrom->flags&MEM_Static) ){
58853: pTo->flags |= MEM_Ephem;
58854: rc = sqlite3VdbeMemMakeWriteable(pTo);
58855: }
58856: }
58857:
58858: return rc;
58859: }
58860:
58861: /*
58862: ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
58863: ** freed. If pFrom contains ephemeral data, a copy is made.
58864: **
58865: ** pFrom contains an SQL NULL when this routine returns.
58866: */
58867: SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
58868: assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
58869: assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
58870: assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
58871:
58872: sqlite3VdbeMemRelease(pTo);
58873: memcpy(pTo, pFrom, sizeof(Mem));
58874: pFrom->flags = MEM_Null;
58875: pFrom->xDel = 0;
58876: pFrom->zMalloc = 0;
58877: }
58878:
58879: /*
58880: ** Change the value of a Mem to be a string or a BLOB.
58881: **
58882: ** The memory management strategy depends on the value of the xDel
58883: ** parameter. If the value passed is SQLITE_TRANSIENT, then the
58884: ** string is copied into a (possibly existing) buffer managed by the
58885: ** Mem structure. Otherwise, any existing buffer is freed and the
58886: ** pointer copied.
58887: **
58888: ** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH
58889: ** size limit) then no memory allocation occurs. If the string can be
58890: ** stored without allocating memory, then it is. If a memory allocation
58891: ** is required to store the string, then value of pMem is unchanged. In
58892: ** either case, SQLITE_TOOBIG is returned.
58893: */
58894: SQLITE_PRIVATE int sqlite3VdbeMemSetStr(
58895: Mem *pMem, /* Memory cell to set to string value */
58896: const char *z, /* String pointer */
58897: int n, /* Bytes in string, or negative */
58898: u8 enc, /* Encoding of z. 0 for BLOBs */
58899: void (*xDel)(void*) /* Destructor function */
58900: ){
58901: int nByte = n; /* New value for pMem->n */
58902: int iLimit; /* Maximum allowed string or blob size */
58903: u16 flags = 0; /* New value for pMem->flags */
58904:
58905: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
58906: assert( (pMem->flags & MEM_RowSet)==0 );
58907:
58908: /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
58909: if( !z ){
58910: sqlite3VdbeMemSetNull(pMem);
58911: return SQLITE_OK;
58912: }
58913:
58914: if( pMem->db ){
58915: iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
58916: }else{
58917: iLimit = SQLITE_MAX_LENGTH;
58918: }
58919: flags = (enc==0?MEM_Blob:MEM_Str);
58920: if( nByte<0 ){
58921: assert( enc!=0 );
58922: if( enc==SQLITE_UTF8 ){
58923: for(nByte=0; nByte<=iLimit && z[nByte]; nByte++){}
58924: }else{
58925: for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
58926: }
58927: flags |= MEM_Term;
58928: }
58929:
58930: /* The following block sets the new values of Mem.z and Mem.xDel. It
58931: ** also sets a flag in local variable "flags" to indicate the memory
58932: ** management (one of MEM_Dyn or MEM_Static).
58933: */
58934: if( xDel==SQLITE_TRANSIENT ){
58935: int nAlloc = nByte;
58936: if( flags&MEM_Term ){
58937: nAlloc += (enc==SQLITE_UTF8?1:2);
58938: }
58939: if( nByte>iLimit ){
58940: return SQLITE_TOOBIG;
58941: }
58942: if( sqlite3VdbeMemGrow(pMem, nAlloc, 0) ){
58943: return SQLITE_NOMEM;
58944: }
58945: memcpy(pMem->z, z, nAlloc);
58946: }else if( xDel==SQLITE_DYNAMIC ){
58947: sqlite3VdbeMemRelease(pMem);
58948: pMem->zMalloc = pMem->z = (char *)z;
58949: pMem->xDel = 0;
58950: }else{
58951: sqlite3VdbeMemRelease(pMem);
58952: pMem->z = (char *)z;
58953: pMem->xDel = xDel;
58954: flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
58955: }
58956:
58957: pMem->n = nByte;
58958: pMem->flags = flags;
58959: pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
58960: pMem->type = (enc==0 ? SQLITE_BLOB : SQLITE_TEXT);
58961:
58962: #ifndef SQLITE_OMIT_UTF16
58963: if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
58964: return SQLITE_NOMEM;
58965: }
58966: #endif
58967:
58968: if( nByte>iLimit ){
58969: return SQLITE_TOOBIG;
58970: }
58971:
58972: return SQLITE_OK;
58973: }
58974:
58975: /*
58976: ** Compare the values contained by the two memory cells, returning
58977: ** negative, zero or positive if pMem1 is less than, equal to, or greater
58978: ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
58979: ** and reals) sorted numerically, followed by text ordered by the collating
58980: ** sequence pColl and finally blob's ordered by memcmp().
58981: **
58982: ** Two NULL values are considered equal by this function.
58983: */
58984: SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
58985: int rc;
58986: int f1, f2;
58987: int combined_flags;
58988:
58989: f1 = pMem1->flags;
58990: f2 = pMem2->flags;
58991: combined_flags = f1|f2;
58992: assert( (combined_flags & MEM_RowSet)==0 );
58993:
58994: /* If one value is NULL, it is less than the other. If both values
58995: ** are NULL, return 0.
58996: */
58997: if( combined_flags&MEM_Null ){
58998: return (f2&MEM_Null) - (f1&MEM_Null);
58999: }
59000:
59001: /* If one value is a number and the other is not, the number is less.
59002: ** If both are numbers, compare as reals if one is a real, or as integers
59003: ** if both values are integers.
59004: */
59005: if( combined_flags&(MEM_Int|MEM_Real) ){
59006: if( !(f1&(MEM_Int|MEM_Real)) ){
59007: return 1;
59008: }
59009: if( !(f2&(MEM_Int|MEM_Real)) ){
59010: return -1;
59011: }
59012: if( (f1 & f2 & MEM_Int)==0 ){
59013: double r1, r2;
59014: if( (f1&MEM_Real)==0 ){
59015: r1 = (double)pMem1->u.i;
59016: }else{
59017: r1 = pMem1->r;
59018: }
59019: if( (f2&MEM_Real)==0 ){
59020: r2 = (double)pMem2->u.i;
59021: }else{
59022: r2 = pMem2->r;
59023: }
59024: if( r1<r2 ) return -1;
59025: if( r1>r2 ) return 1;
59026: return 0;
59027: }else{
59028: assert( f1&MEM_Int );
59029: assert( f2&MEM_Int );
59030: if( pMem1->u.i < pMem2->u.i ) return -1;
59031: if( pMem1->u.i > pMem2->u.i ) return 1;
59032: return 0;
59033: }
59034: }
59035:
59036: /* If one value is a string and the other is a blob, the string is less.
59037: ** If both are strings, compare using the collating functions.
59038: */
59039: if( combined_flags&MEM_Str ){
59040: if( (f1 & MEM_Str)==0 ){
59041: return 1;
59042: }
59043: if( (f2 & MEM_Str)==0 ){
59044: return -1;
59045: }
59046:
59047: assert( pMem1->enc==pMem2->enc );
59048: assert( pMem1->enc==SQLITE_UTF8 ||
59049: pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
59050:
59051: /* The collation sequence must be defined at this point, even if
59052: ** the user deletes the collation sequence after the vdbe program is
59053: ** compiled (this was not always the case).
59054: */
59055: assert( !pColl || pColl->xCmp );
59056:
59057: if( pColl ){
59058: if( pMem1->enc==pColl->enc ){
59059: /* The strings are already in the correct encoding. Call the
59060: ** comparison function directly */
59061: return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
59062: }else{
59063: const void *v1, *v2;
59064: int n1, n2;
59065: Mem c1;
59066: Mem c2;
59067: memset(&c1, 0, sizeof(c1));
59068: memset(&c2, 0, sizeof(c2));
59069: sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
59070: sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
59071: v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
59072: n1 = v1==0 ? 0 : c1.n;
59073: v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
59074: n2 = v2==0 ? 0 : c2.n;
59075: rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
59076: sqlite3VdbeMemRelease(&c1);
59077: sqlite3VdbeMemRelease(&c2);
59078: return rc;
59079: }
59080: }
59081: /* If a NULL pointer was passed as the collate function, fall through
59082: ** to the blob case and use memcmp(). */
59083: }
59084:
59085: /* Both values must be blobs. Compare using memcmp(). */
59086: rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n);
59087: if( rc==0 ){
59088: rc = pMem1->n - pMem2->n;
59089: }
59090: return rc;
59091: }
59092:
59093: /*
59094: ** Move data out of a btree key or data field and into a Mem structure.
59095: ** The data or key is taken from the entry that pCur is currently pointing
59096: ** to. offset and amt determine what portion of the data or key to retrieve.
59097: ** key is true to get the key or false to get data. The result is written
59098: ** into the pMem element.
59099: **
59100: ** The pMem structure is assumed to be uninitialized. Any prior content
59101: ** is overwritten without being freed.
59102: **
59103: ** If this routine fails for any reason (malloc returns NULL or unable
59104: ** to read from the disk) then the pMem is left in an inconsistent state.
59105: */
59106: SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(
59107: BtCursor *pCur, /* Cursor pointing at record to retrieve. */
59108: int offset, /* Offset from the start of data to return bytes from. */
59109: int amt, /* Number of bytes to return. */
59110: int key, /* If true, retrieve from the btree key, not data. */
59111: Mem *pMem /* OUT: Return data in this Mem structure. */
59112: ){
59113: char *zData; /* Data from the btree layer */
59114: int available = 0; /* Number of bytes available on the local btree page */
59115: int rc = SQLITE_OK; /* Return code */
59116:
59117: assert( sqlite3BtreeCursorIsValid(pCur) );
59118:
59119: /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert()
59120: ** that both the BtShared and database handle mutexes are held. */
59121: assert( (pMem->flags & MEM_RowSet)==0 );
59122: if( key ){
59123: zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
59124: }else{
59125: zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
59126: }
59127: assert( zData!=0 );
59128:
59129: if( offset+amt<=available && (pMem->flags&MEM_Dyn)==0 ){
59130: sqlite3VdbeMemRelease(pMem);
59131: pMem->z = &zData[offset];
59132: pMem->flags = MEM_Blob|MEM_Ephem;
59133: }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
59134: pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
59135: pMem->enc = 0;
59136: pMem->type = SQLITE_BLOB;
59137: if( key ){
59138: rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
59139: }else{
59140: rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
59141: }
59142: pMem->z[amt] = 0;
59143: pMem->z[amt+1] = 0;
59144: if( rc!=SQLITE_OK ){
59145: sqlite3VdbeMemRelease(pMem);
59146: }
59147: }
59148: pMem->n = amt;
59149:
59150: return rc;
59151: }
59152:
59153: /* This function is only available internally, it is not part of the
59154: ** external API. It works in a similar way to sqlite3_value_text(),
59155: ** except the data returned is in the encoding specified by the second
59156: ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
59157: ** SQLITE_UTF8.
59158: **
59159: ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
59160: ** If that is the case, then the result must be aligned on an even byte
59161: ** boundary.
59162: */
59163: SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
59164: if( !pVal ) return 0;
59165:
59166: assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
59167: assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
59168: assert( (pVal->flags & MEM_RowSet)==0 );
59169:
59170: if( pVal->flags&MEM_Null ){
59171: return 0;
59172: }
59173: assert( (MEM_Blob>>3) == MEM_Str );
59174: pVal->flags |= (pVal->flags & MEM_Blob)>>3;
59175: ExpandBlob(pVal);
59176: if( pVal->flags&MEM_Str ){
59177: sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
59178: if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
59179: assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
59180: if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
59181: return 0;
59182: }
59183: }
59184: sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
59185: }else{
59186: assert( (pVal->flags&MEM_Blob)==0 );
59187: sqlite3VdbeMemStringify(pVal, enc);
59188: assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
59189: }
59190: assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
59191: || pVal->db->mallocFailed );
59192: if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
59193: return pVal->z;
59194: }else{
59195: return 0;
59196: }
59197: }
59198:
59199: /*
59200: ** Create a new sqlite3_value object.
59201: */
59202: SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *db){
59203: Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
59204: if( p ){
59205: p->flags = MEM_Null;
59206: p->type = SQLITE_NULL;
59207: p->db = db;
59208: }
59209: return p;
59210: }
59211:
59212: /*
59213: ** Create a new sqlite3_value object, containing the value of pExpr.
59214: **
59215: ** This only works for very simple expressions that consist of one constant
59216: ** token (i.e. "5", "5.1", "'a string'"). If the expression can
59217: ** be converted directly into a value, then the value is allocated and
59218: ** a pointer written to *ppVal. The caller is responsible for deallocating
59219: ** the value by passing it to sqlite3ValueFree() later on. If the expression
59220: ** cannot be converted to a value, then *ppVal is set to NULL.
59221: */
59222: SQLITE_PRIVATE int sqlite3ValueFromExpr(
59223: sqlite3 *db, /* The database connection */
59224: Expr *pExpr, /* The expression to evaluate */
59225: u8 enc, /* Encoding to use */
59226: u8 affinity, /* Affinity to use */
59227: sqlite3_value **ppVal /* Write the new value here */
59228: ){
59229: int op;
59230: char *zVal = 0;
59231: sqlite3_value *pVal = 0;
59232: int negInt = 1;
59233: const char *zNeg = "";
59234:
59235: if( !pExpr ){
59236: *ppVal = 0;
59237: return SQLITE_OK;
59238: }
59239: op = pExpr->op;
59240:
59241: /* op can only be TK_REGISTER if we have compiled with SQLITE_ENABLE_STAT3.
59242: ** The ifdef here is to enable us to achieve 100% branch test coverage even
59243: ** when SQLITE_ENABLE_STAT3 is omitted.
59244: */
59245: #ifdef SQLITE_ENABLE_STAT3
59246: if( op==TK_REGISTER ) op = pExpr->op2;
59247: #else
59248: if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
59249: #endif
59250:
59251: /* Handle negative integers in a single step. This is needed in the
59252: ** case when the value is -9223372036854775808.
59253: */
59254: if( op==TK_UMINUS
59255: && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
59256: pExpr = pExpr->pLeft;
59257: op = pExpr->op;
59258: negInt = -1;
59259: zNeg = "-";
59260: }
59261:
59262: if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
59263: pVal = sqlite3ValueNew(db);
59264: if( pVal==0 ) goto no_mem;
59265: if( ExprHasProperty(pExpr, EP_IntValue) ){
59266: sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
59267: }else{
59268: zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
59269: if( zVal==0 ) goto no_mem;
59270: sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
59271: if( op==TK_FLOAT ) pVal->type = SQLITE_FLOAT;
59272: }
59273: if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
59274: sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
59275: }else{
59276: sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
59277: }
59278: if( pVal->flags & (MEM_Int|MEM_Real) ) pVal->flags &= ~MEM_Str;
59279: if( enc!=SQLITE_UTF8 ){
59280: sqlite3VdbeChangeEncoding(pVal, enc);
59281: }
59282: }else if( op==TK_UMINUS ) {
59283: /* This branch happens for multiple negative signs. Ex: -(-5) */
59284: if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
59285: sqlite3VdbeMemNumerify(pVal);
59286: if( pVal->u.i==SMALLEST_INT64 ){
59287: pVal->flags &= MEM_Int;
59288: pVal->flags |= MEM_Real;
59289: pVal->r = (double)LARGEST_INT64;
59290: }else{
59291: pVal->u.i = -pVal->u.i;
59292: }
59293: pVal->r = -pVal->r;
59294: sqlite3ValueApplyAffinity(pVal, affinity, enc);
59295: }
59296: }else if( op==TK_NULL ){
59297: pVal = sqlite3ValueNew(db);
59298: if( pVal==0 ) goto no_mem;
59299: }
59300: #ifndef SQLITE_OMIT_BLOB_LITERAL
59301: else if( op==TK_BLOB ){
59302: int nVal;
59303: assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
59304: assert( pExpr->u.zToken[1]=='\'' );
59305: pVal = sqlite3ValueNew(db);
59306: if( !pVal ) goto no_mem;
59307: zVal = &pExpr->u.zToken[2];
59308: nVal = sqlite3Strlen30(zVal)-1;
59309: assert( zVal[nVal]=='\'' );
59310: sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
59311: 0, SQLITE_DYNAMIC);
59312: }
59313: #endif
59314:
59315: if( pVal ){
59316: sqlite3VdbeMemStoreType(pVal);
59317: }
59318: *ppVal = pVal;
59319: return SQLITE_OK;
59320:
59321: no_mem:
59322: db->mallocFailed = 1;
59323: sqlite3DbFree(db, zVal);
59324: sqlite3ValueFree(pVal);
59325: *ppVal = 0;
59326: return SQLITE_NOMEM;
59327: }
59328:
59329: /*
59330: ** Change the string value of an sqlite3_value object
59331: */
59332: SQLITE_PRIVATE void sqlite3ValueSetStr(
59333: sqlite3_value *v, /* Value to be set */
59334: int n, /* Length of string z */
59335: const void *z, /* Text of the new string */
59336: u8 enc, /* Encoding to use */
59337: void (*xDel)(void*) /* Destructor for the string */
59338: ){
59339: if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
59340: }
59341:
59342: /*
59343: ** Free an sqlite3_value object
59344: */
59345: SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value *v){
59346: if( !v ) return;
59347: sqlite3VdbeMemRelease((Mem *)v);
59348: sqlite3DbFree(((Mem*)v)->db, v);
59349: }
59350:
59351: /*
59352: ** Return the number of bytes in the sqlite3_value object assuming
59353: ** that it uses the encoding "enc"
59354: */
59355: SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
59356: Mem *p = (Mem*)pVal;
59357: if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
59358: if( p->flags & MEM_Zero ){
59359: return p->n + p->u.nZero;
59360: }else{
59361: return p->n;
59362: }
59363: }
59364: return 0;
59365: }
59366:
59367: /************** End of vdbemem.c *********************************************/
59368: /************** Begin file vdbeaux.c *****************************************/
59369: /*
59370: ** 2003 September 6
59371: **
59372: ** The author disclaims copyright to this source code. In place of
59373: ** a legal notice, here is a blessing:
59374: **
59375: ** May you do good and not evil.
59376: ** May you find forgiveness for yourself and forgive others.
59377: ** May you share freely, never taking more than you give.
59378: **
59379: *************************************************************************
59380: ** This file contains code used for creating, destroying, and populating
59381: ** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) Prior
59382: ** to version 2.8.7, all this code was combined into the vdbe.c source file.
59383: ** But that file was getting too big so this subroutines were split out.
59384: */
59385:
59386:
59387:
59388: /*
59389: ** When debugging the code generator in a symbolic debugger, one can
59390: ** set the sqlite3VdbeAddopTrace to 1 and all opcodes will be printed
59391: ** as they are added to the instruction stream.
59392: */
59393: #ifdef SQLITE_DEBUG
59394: SQLITE_PRIVATE int sqlite3VdbeAddopTrace = 0;
59395: #endif
59396:
59397:
59398: /*
59399: ** Create a new virtual database engine.
59400: */
59401: SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3 *db){
59402: Vdbe *p;
59403: p = sqlite3DbMallocZero(db, sizeof(Vdbe) );
59404: if( p==0 ) return 0;
59405: p->db = db;
59406: if( db->pVdbe ){
59407: db->pVdbe->pPrev = p;
59408: }
59409: p->pNext = db->pVdbe;
59410: p->pPrev = 0;
59411: db->pVdbe = p;
59412: p->magic = VDBE_MAGIC_INIT;
59413: return p;
59414: }
59415:
59416: /*
59417: ** Remember the SQL string for a prepared statement.
59418: */
59419: SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, int isPrepareV2){
59420: assert( isPrepareV2==1 || isPrepareV2==0 );
59421: if( p==0 ) return;
59422: #ifdef SQLITE_OMIT_TRACE
59423: if( !isPrepareV2 ) return;
59424: #endif
59425: assert( p->zSql==0 );
59426: p->zSql = sqlite3DbStrNDup(p->db, z, n);
59427: p->isPrepareV2 = (u8)isPrepareV2;
59428: }
59429:
59430: /*
59431: ** Return the SQL associated with a prepared statement
59432: */
59433: SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt){
59434: Vdbe *p = (Vdbe *)pStmt;
59435: return (p && p->isPrepareV2) ? p->zSql : 0;
59436: }
59437:
59438: /*
59439: ** Swap all content between two VDBE structures.
59440: */
59441: SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
59442: Vdbe tmp, *pTmp;
59443: char *zTmp;
59444: tmp = *pA;
59445: *pA = *pB;
59446: *pB = tmp;
59447: pTmp = pA->pNext;
59448: pA->pNext = pB->pNext;
59449: pB->pNext = pTmp;
59450: pTmp = pA->pPrev;
59451: pA->pPrev = pB->pPrev;
59452: pB->pPrev = pTmp;
59453: zTmp = pA->zSql;
59454: pA->zSql = pB->zSql;
59455: pB->zSql = zTmp;
59456: pB->isPrepareV2 = pA->isPrepareV2;
59457: }
59458:
59459: #ifdef SQLITE_DEBUG
59460: /*
59461: ** Turn tracing on or off
59462: */
59463: SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe *p, FILE *trace){
59464: p->trace = trace;
59465: }
59466: #endif
59467:
59468: /*
59469: ** Resize the Vdbe.aOp array so that it is at least one op larger than
59470: ** it was.
59471: **
59472: ** If an out-of-memory error occurs while resizing the array, return
59473: ** SQLITE_NOMEM. In this case Vdbe.aOp and Vdbe.nOpAlloc remain
59474: ** unchanged (this is so that any opcodes already allocated can be
59475: ** correctly deallocated along with the rest of the Vdbe).
59476: */
59477: static int growOpArray(Vdbe *p){
59478: VdbeOp *pNew;
59479: int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op)));
59480: pNew = sqlite3DbRealloc(p->db, p->aOp, nNew*sizeof(Op));
59481: if( pNew ){
59482: p->nOpAlloc = sqlite3DbMallocSize(p->db, pNew)/sizeof(Op);
59483: p->aOp = pNew;
59484: }
59485: return (pNew ? SQLITE_OK : SQLITE_NOMEM);
59486: }
59487:
59488: /*
59489: ** Add a new instruction to the list of instructions current in the
59490: ** VDBE. Return the address of the new instruction.
59491: **
59492: ** Parameters:
59493: **
59494: ** p Pointer to the VDBE
59495: **
59496: ** op The opcode for this instruction
59497: **
59498: ** p1, p2, p3 Operands
59499: **
59500: ** Use the sqlite3VdbeResolveLabel() function to fix an address and
59501: ** the sqlite3VdbeChangeP4() function to change the value of the P4
59502: ** operand.
59503: */
59504: SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
59505: int i;
59506: VdbeOp *pOp;
59507:
59508: i = p->nOp;
59509: assert( p->magic==VDBE_MAGIC_INIT );
59510: assert( op>0 && op<0xff );
59511: if( p->nOpAlloc<=i ){
59512: if( growOpArray(p) ){
59513: return 1;
59514: }
59515: }
59516: p->nOp++;
59517: pOp = &p->aOp[i];
59518: pOp->opcode = (u8)op;
59519: pOp->p5 = 0;
59520: pOp->p1 = p1;
59521: pOp->p2 = p2;
59522: pOp->p3 = p3;
59523: pOp->p4.p = 0;
59524: pOp->p4type = P4_NOTUSED;
59525: #ifdef SQLITE_DEBUG
59526: pOp->zComment = 0;
59527: if( sqlite3VdbeAddopTrace ) sqlite3VdbePrintOp(0, i, &p->aOp[i]);
59528: #endif
59529: #ifdef VDBE_PROFILE
59530: pOp->cycles = 0;
59531: pOp->cnt = 0;
59532: #endif
59533: return i;
59534: }
59535: SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){
59536: return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
59537: }
59538: SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
59539: return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
59540: }
59541: SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
59542: return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
59543: }
59544:
59545:
59546: /*
59547: ** Add an opcode that includes the p4 value as a pointer.
59548: */
59549: SQLITE_PRIVATE int sqlite3VdbeAddOp4(
59550: Vdbe *p, /* Add the opcode to this VM */
59551: int op, /* The new opcode */
59552: int p1, /* The P1 operand */
59553: int p2, /* The P2 operand */
59554: int p3, /* The P3 operand */
59555: const char *zP4, /* The P4 operand */
59556: int p4type /* P4 operand type */
59557: ){
59558: int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
59559: sqlite3VdbeChangeP4(p, addr, zP4, p4type);
59560: return addr;
59561: }
59562:
59563: /*
59564: ** Add an OP_ParseSchema opcode. This routine is broken out from
59565: ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
59566: ** as having been used.
59567: **
59568: ** The zWhere string must have been obtained from sqlite3_malloc().
59569: ** This routine will take ownership of the allocated memory.
59570: */
59571: SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
59572: int j;
59573: int addr = sqlite3VdbeAddOp3(p, OP_ParseSchema, iDb, 0, 0);
59574: sqlite3VdbeChangeP4(p, addr, zWhere, P4_DYNAMIC);
59575: for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
59576: }
59577:
59578: /*
59579: ** Add an opcode that includes the p4 value as an integer.
59580: */
59581: SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(
59582: Vdbe *p, /* Add the opcode to this VM */
59583: int op, /* The new opcode */
59584: int p1, /* The P1 operand */
59585: int p2, /* The P2 operand */
59586: int p3, /* The P3 operand */
59587: int p4 /* The P4 operand as an integer */
59588: ){
59589: int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
59590: sqlite3VdbeChangeP4(p, addr, SQLITE_INT_TO_PTR(p4), P4_INT32);
59591: return addr;
59592: }
59593:
59594: /*
59595: ** Create a new symbolic label for an instruction that has yet to be
59596: ** coded. The symbolic label is really just a negative number. The
59597: ** label can be used as the P2 value of an operation. Later, when
59598: ** the label is resolved to a specific address, the VDBE will scan
59599: ** through its operation list and change all values of P2 which match
59600: ** the label into the resolved address.
59601: **
59602: ** The VDBE knows that a P2 value is a label because labels are
59603: ** always negative and P2 values are suppose to be non-negative.
59604: ** Hence, a negative P2 value is a label that has yet to be resolved.
59605: **
59606: ** Zero is returned if a malloc() fails.
59607: */
59608: SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe *p){
59609: int i;
59610: i = p->nLabel++;
59611: assert( p->magic==VDBE_MAGIC_INIT );
59612: if( i>=p->nLabelAlloc ){
59613: int n = p->nLabelAlloc*2 + 5;
59614: p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
59615: n*sizeof(p->aLabel[0]));
59616: p->nLabelAlloc = sqlite3DbMallocSize(p->db, p->aLabel)/sizeof(p->aLabel[0]);
59617: }
59618: if( p->aLabel ){
59619: p->aLabel[i] = -1;
59620: }
59621: return -1-i;
59622: }
59623:
59624: /*
59625: ** Resolve label "x" to be the address of the next instruction to
59626: ** be inserted. The parameter "x" must have been obtained from
59627: ** a prior call to sqlite3VdbeMakeLabel().
59628: */
59629: SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *p, int x){
59630: int j = -1-x;
59631: assert( p->magic==VDBE_MAGIC_INIT );
59632: assert( j>=0 && j<p->nLabel );
59633: if( p->aLabel ){
59634: p->aLabel[j] = p->nOp;
59635: }
59636: }
59637:
59638: /*
59639: ** Mark the VDBE as one that can only be run one time.
59640: */
59641: SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe *p){
59642: p->runOnlyOnce = 1;
59643: }
59644:
59645: #ifdef SQLITE_DEBUG /* sqlite3AssertMayAbort() logic */
59646:
59647: /*
59648: ** The following type and function are used to iterate through all opcodes
59649: ** in a Vdbe main program and each of the sub-programs (triggers) it may
59650: ** invoke directly or indirectly. It should be used as follows:
59651: **
59652: ** Op *pOp;
59653: ** VdbeOpIter sIter;
59654: **
59655: ** memset(&sIter, 0, sizeof(sIter));
59656: ** sIter.v = v; // v is of type Vdbe*
59657: ** while( (pOp = opIterNext(&sIter)) ){
59658: ** // Do something with pOp
59659: ** }
59660: ** sqlite3DbFree(v->db, sIter.apSub);
59661: **
59662: */
59663: typedef struct VdbeOpIter VdbeOpIter;
59664: struct VdbeOpIter {
59665: Vdbe *v; /* Vdbe to iterate through the opcodes of */
59666: SubProgram **apSub; /* Array of subprograms */
59667: int nSub; /* Number of entries in apSub */
59668: int iAddr; /* Address of next instruction to return */
59669: int iSub; /* 0 = main program, 1 = first sub-program etc. */
59670: };
59671: static Op *opIterNext(VdbeOpIter *p){
59672: Vdbe *v = p->v;
59673: Op *pRet = 0;
59674: Op *aOp;
59675: int nOp;
59676:
59677: if( p->iSub<=p->nSub ){
59678:
59679: if( p->iSub==0 ){
59680: aOp = v->aOp;
59681: nOp = v->nOp;
59682: }else{
59683: aOp = p->apSub[p->iSub-1]->aOp;
59684: nOp = p->apSub[p->iSub-1]->nOp;
59685: }
59686: assert( p->iAddr<nOp );
59687:
59688: pRet = &aOp[p->iAddr];
59689: p->iAddr++;
59690: if( p->iAddr==nOp ){
59691: p->iSub++;
59692: p->iAddr = 0;
59693: }
59694:
59695: if( pRet->p4type==P4_SUBPROGRAM ){
59696: int nByte = (p->nSub+1)*sizeof(SubProgram*);
59697: int j;
59698: for(j=0; j<p->nSub; j++){
59699: if( p->apSub[j]==pRet->p4.pProgram ) break;
59700: }
59701: if( j==p->nSub ){
59702: p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
59703: if( !p->apSub ){
59704: pRet = 0;
59705: }else{
59706: p->apSub[p->nSub++] = pRet->p4.pProgram;
59707: }
59708: }
59709: }
59710: }
59711:
59712: return pRet;
59713: }
59714:
59715: /*
59716: ** Check if the program stored in the VM associated with pParse may
59717: ** throw an ABORT exception (causing the statement, but not entire transaction
59718: ** to be rolled back). This condition is true if the main program or any
59719: ** sub-programs contains any of the following:
59720: **
59721: ** * OP_Halt with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
59722: ** * OP_HaltIfNull with P1=SQLITE_CONSTRAINT and P2=OE_Abort.
59723: ** * OP_Destroy
59724: ** * OP_VUpdate
59725: ** * OP_VRename
59726: ** * OP_FkCounter with P2==0 (immediate foreign key constraint)
59727: **
59728: ** Then check that the value of Parse.mayAbort is true if an
59729: ** ABORT may be thrown, or false otherwise. Return true if it does
59730: ** match, or false otherwise. This function is intended to be used as
59731: ** part of an assert statement in the compiler. Similar to:
59732: **
59733: ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
59734: */
59735: SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
59736: int hasAbort = 0;
59737: Op *pOp;
59738: VdbeOpIter sIter;
59739: memset(&sIter, 0, sizeof(sIter));
59740: sIter.v = v;
59741:
59742: while( (pOp = opIterNext(&sIter))!=0 ){
59743: int opcode = pOp->opcode;
59744: if( opcode==OP_Destroy || opcode==OP_VUpdate || opcode==OP_VRename
59745: #ifndef SQLITE_OMIT_FOREIGN_KEY
59746: || (opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1)
59747: #endif
59748: || ((opcode==OP_Halt || opcode==OP_HaltIfNull)
59749: && (pOp->p1==SQLITE_CONSTRAINT && pOp->p2==OE_Abort))
59750: ){
59751: hasAbort = 1;
59752: break;
59753: }
59754: }
59755: sqlite3DbFree(v->db, sIter.apSub);
59756:
59757: /* Return true if hasAbort==mayAbort. Or if a malloc failure occured.
59758: ** If malloc failed, then the while() loop above may not have iterated
59759: ** through all opcodes and hasAbort may be set incorrectly. Return
59760: ** true for this case to prevent the assert() in the callers frame
59761: ** from failing. */
59762: return ( v->db->mallocFailed || hasAbort==mayAbort );
59763: }
59764: #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */
59765:
59766: /*
59767: ** Loop through the program looking for P2 values that are negative
59768: ** on jump instructions. Each such value is a label. Resolve the
59769: ** label by setting the P2 value to its correct non-zero value.
59770: **
59771: ** This routine is called once after all opcodes have been inserted.
59772: **
59773: ** Variable *pMaxFuncArgs is set to the maximum value of any P2 argument
59774: ** to an OP_Function, OP_AggStep or OP_VFilter opcode. This is used by
59775: ** sqlite3VdbeMakeReady() to size the Vdbe.apArg[] array.
59776: **
59777: ** The Op.opflags field is set on all opcodes.
59778: */
59779: static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
59780: int i;
59781: int nMaxArgs = *pMaxFuncArgs;
59782: Op *pOp;
59783: int *aLabel = p->aLabel;
59784: p->readOnly = 1;
59785: for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
59786: u8 opcode = pOp->opcode;
59787:
59788: pOp->opflags = sqlite3OpcodeProperty[opcode];
59789: if( opcode==OP_Function || opcode==OP_AggStep ){
59790: if( pOp->p5>nMaxArgs ) nMaxArgs = pOp->p5;
59791: }else if( (opcode==OP_Transaction && pOp->p2!=0) || opcode==OP_Vacuum ){
59792: p->readOnly = 0;
59793: #ifndef SQLITE_OMIT_VIRTUALTABLE
59794: }else if( opcode==OP_VUpdate ){
59795: if( pOp->p2>nMaxArgs ) nMaxArgs = pOp->p2;
59796: }else if( opcode==OP_VFilter ){
59797: int n;
59798: assert( p->nOp - i >= 3 );
59799: assert( pOp[-1].opcode==OP_Integer );
59800: n = pOp[-1].p1;
59801: if( n>nMaxArgs ) nMaxArgs = n;
59802: #endif
59803: }else if( opcode==OP_Next || opcode==OP_SorterNext ){
59804: pOp->p4.xAdvance = sqlite3BtreeNext;
59805: pOp->p4type = P4_ADVANCE;
59806: }else if( opcode==OP_Prev ){
59807: pOp->p4.xAdvance = sqlite3BtreePrevious;
59808: pOp->p4type = P4_ADVANCE;
59809: }
59810:
59811: if( (pOp->opflags & OPFLG_JUMP)!=0 && pOp->p2<0 ){
59812: assert( -1-pOp->p2<p->nLabel );
59813: pOp->p2 = aLabel[-1-pOp->p2];
59814: }
59815: }
59816: sqlite3DbFree(p->db, p->aLabel);
59817: p->aLabel = 0;
59818:
59819: *pMaxFuncArgs = nMaxArgs;
59820: }
59821:
59822: /*
59823: ** Return the address of the next instruction to be inserted.
59824: */
59825: SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){
59826: assert( p->magic==VDBE_MAGIC_INIT );
59827: return p->nOp;
59828: }
59829:
59830: /*
59831: ** This function returns a pointer to the array of opcodes associated with
59832: ** the Vdbe passed as the first argument. It is the callers responsibility
59833: ** to arrange for the returned array to be eventually freed using the
59834: ** vdbeFreeOpArray() function.
59835: **
59836: ** Before returning, *pnOp is set to the number of entries in the returned
59837: ** array. Also, *pnMaxArg is set to the larger of its current value and
59838: ** the number of entries in the Vdbe.apArg[] array required to execute the
59839: ** returned program.
59840: */
59841: SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){
59842: VdbeOp *aOp = p->aOp;
59843: assert( aOp && !p->db->mallocFailed );
59844:
59845: /* Check that sqlite3VdbeUsesBtree() was not called on this VM */
59846: assert( p->btreeMask==0 );
59847:
59848: resolveP2Values(p, pnMaxArg);
59849: *pnOp = p->nOp;
59850: p->aOp = 0;
59851: return aOp;
59852: }
59853:
59854: /*
59855: ** Add a whole list of operations to the operation stack. Return the
59856: ** address of the first operation added.
59857: */
59858: SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){
59859: int addr;
59860: assert( p->magic==VDBE_MAGIC_INIT );
59861: if( p->nOp + nOp > p->nOpAlloc && growOpArray(p) ){
59862: return 0;
59863: }
59864: addr = p->nOp;
59865: if( ALWAYS(nOp>0) ){
59866: int i;
59867: VdbeOpList const *pIn = aOp;
59868: for(i=0; i<nOp; i++, pIn++){
59869: int p2 = pIn->p2;
59870: VdbeOp *pOut = &p->aOp[i+addr];
59871: pOut->opcode = pIn->opcode;
59872: pOut->p1 = pIn->p1;
59873: if( p2<0 && (sqlite3OpcodeProperty[pOut->opcode] & OPFLG_JUMP)!=0 ){
59874: pOut->p2 = addr + ADDR(p2);
59875: }else{
59876: pOut->p2 = p2;
59877: }
59878: pOut->p3 = pIn->p3;
59879: pOut->p4type = P4_NOTUSED;
59880: pOut->p4.p = 0;
59881: pOut->p5 = 0;
59882: #ifdef SQLITE_DEBUG
59883: pOut->zComment = 0;
59884: if( sqlite3VdbeAddopTrace ){
59885: sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]);
59886: }
59887: #endif
59888: }
59889: p->nOp += nOp;
59890: }
59891: return addr;
59892: }
59893:
59894: /*
59895: ** Change the value of the P1 operand for a specific instruction.
59896: ** This routine is useful when a large program is loaded from a
59897: ** static array using sqlite3VdbeAddOpList but we want to make a
59898: ** few minor changes to the program.
59899: */
59900: SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, u32 addr, int val){
59901: assert( p!=0 );
59902: if( ((u32)p->nOp)>addr ){
59903: p->aOp[addr].p1 = val;
59904: }
59905: }
59906:
59907: /*
59908: ** Change the value of the P2 operand for a specific instruction.
59909: ** This routine is useful for setting a jump destination.
59910: */
59911: SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, u32 addr, int val){
59912: assert( p!=0 );
59913: if( ((u32)p->nOp)>addr ){
59914: p->aOp[addr].p2 = val;
59915: }
59916: }
59917:
59918: /*
59919: ** Change the value of the P3 operand for a specific instruction.
59920: */
59921: SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, u32 addr, int val){
59922: assert( p!=0 );
59923: if( ((u32)p->nOp)>addr ){
59924: p->aOp[addr].p3 = val;
59925: }
59926: }
59927:
59928: /*
59929: ** Change the value of the P5 operand for the most recently
59930: ** added operation.
59931: */
59932: SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 val){
59933: assert( p!=0 );
59934: if( p->aOp ){
59935: assert( p->nOp>0 );
59936: p->aOp[p->nOp-1].p5 = val;
59937: }
59938: }
59939:
59940: /*
59941: ** Change the P2 operand of instruction addr so that it points to
59942: ** the address of the next instruction to be coded.
59943: */
59944: SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe *p, int addr){
59945: assert( addr>=0 || p->db->mallocFailed );
59946: if( addr>=0 ) sqlite3VdbeChangeP2(p, addr, p->nOp);
59947: }
59948:
59949:
59950: /*
59951: ** If the input FuncDef structure is ephemeral, then free it. If
59952: ** the FuncDef is not ephermal, then do nothing.
59953: */
59954: static void freeEphemeralFunction(sqlite3 *db, FuncDef *pDef){
59955: if( ALWAYS(pDef) && (pDef->flags & SQLITE_FUNC_EPHEM)!=0 ){
59956: sqlite3DbFree(db, pDef);
59957: }
59958: }
59959:
59960: static void vdbeFreeOpArray(sqlite3 *, Op *, int);
59961:
59962: /*
59963: ** Delete a P4 value if necessary.
59964: */
59965: static void freeP4(sqlite3 *db, int p4type, void *p4){
59966: if( p4 ){
59967: assert( db );
59968: switch( p4type ){
59969: case P4_REAL:
59970: case P4_INT64:
59971: case P4_DYNAMIC:
59972: case P4_KEYINFO:
59973: case P4_INTARRAY:
59974: case P4_KEYINFO_HANDOFF: {
59975: sqlite3DbFree(db, p4);
59976: break;
59977: }
59978: case P4_MPRINTF: {
59979: if( db->pnBytesFreed==0 ) sqlite3_free(p4);
59980: break;
59981: }
59982: case P4_VDBEFUNC: {
59983: VdbeFunc *pVdbeFunc = (VdbeFunc *)p4;
59984: freeEphemeralFunction(db, pVdbeFunc->pFunc);
59985: if( db->pnBytesFreed==0 ) sqlite3VdbeDeleteAuxData(pVdbeFunc, 0);
59986: sqlite3DbFree(db, pVdbeFunc);
59987: break;
59988: }
59989: case P4_FUNCDEF: {
59990: freeEphemeralFunction(db, (FuncDef*)p4);
59991: break;
59992: }
59993: case P4_MEM: {
59994: if( db->pnBytesFreed==0 ){
59995: sqlite3ValueFree((sqlite3_value*)p4);
59996: }else{
59997: Mem *p = (Mem*)p4;
59998: sqlite3DbFree(db, p->zMalloc);
59999: sqlite3DbFree(db, p);
60000: }
60001: break;
60002: }
60003: case P4_VTAB : {
60004: if( db->pnBytesFreed==0 ) sqlite3VtabUnlock((VTable *)p4);
60005: break;
60006: }
60007: }
60008: }
60009: }
60010:
60011: /*
60012: ** Free the space allocated for aOp and any p4 values allocated for the
60013: ** opcodes contained within. If aOp is not NULL it is assumed to contain
60014: ** nOp entries.
60015: */
60016: static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
60017: if( aOp ){
60018: Op *pOp;
60019: for(pOp=aOp; pOp<&aOp[nOp]; pOp++){
60020: freeP4(db, pOp->p4type, pOp->p4.p);
60021: #ifdef SQLITE_DEBUG
60022: sqlite3DbFree(db, pOp->zComment);
60023: #endif
60024: }
60025: }
60026: sqlite3DbFree(db, aOp);
60027: }
60028:
60029: /*
60030: ** Link the SubProgram object passed as the second argument into the linked
60031: ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
60032: ** objects when the VM is no longer required.
60033: */
60034: SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){
60035: p->pNext = pVdbe->pProgram;
60036: pVdbe->pProgram = p;
60037: }
60038:
60039: /*
60040: ** Change the opcode at addr into OP_Noop
60041: */
60042: SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
60043: if( p->aOp ){
60044: VdbeOp *pOp = &p->aOp[addr];
60045: sqlite3 *db = p->db;
60046: freeP4(db, pOp->p4type, pOp->p4.p);
60047: memset(pOp, 0, sizeof(pOp[0]));
60048: pOp->opcode = OP_Noop;
60049: }
60050: }
60051:
60052: /*
60053: ** Change the value of the P4 operand for a specific instruction.
60054: ** This routine is useful when a large program is loaded from a
60055: ** static array using sqlite3VdbeAddOpList but we want to make a
60056: ** few minor changes to the program.
60057: **
60058: ** If n>=0 then the P4 operand is dynamic, meaning that a copy of
60059: ** the string is made into memory obtained from sqlite3_malloc().
60060: ** A value of n==0 means copy bytes of zP4 up to and including the
60061: ** first null byte. If n>0 then copy n+1 bytes of zP4.
60062: **
60063: ** If n==P4_KEYINFO it means that zP4 is a pointer to a KeyInfo structure.
60064: ** A copy is made of the KeyInfo structure into memory obtained from
60065: ** sqlite3_malloc, to be freed when the Vdbe is finalized.
60066: ** n==P4_KEYINFO_HANDOFF indicates that zP4 points to a KeyInfo structure
60067: ** stored in memory that the caller has obtained from sqlite3_malloc. The
60068: ** caller should not free the allocation, it will be freed when the Vdbe is
60069: ** finalized.
60070: **
60071: ** Other values of n (P4_STATIC, P4_COLLSEQ etc.) indicate that zP4 points
60072: ** to a string or structure that is guaranteed to exist for the lifetime of
60073: ** the Vdbe. In these cases we can just copy the pointer.
60074: **
60075: ** If addr<0 then change P4 on the most recently inserted instruction.
60076: */
60077: SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
60078: Op *pOp;
60079: sqlite3 *db;
60080: assert( p!=0 );
60081: db = p->db;
60082: assert( p->magic==VDBE_MAGIC_INIT );
60083: if( p->aOp==0 || db->mallocFailed ){
60084: if ( n!=P4_KEYINFO && n!=P4_VTAB ) {
60085: freeP4(db, n, (void*)*(char**)&zP4);
60086: }
60087: return;
60088: }
60089: assert( p->nOp>0 );
60090: assert( addr<p->nOp );
60091: if( addr<0 ){
60092: addr = p->nOp - 1;
60093: }
60094: pOp = &p->aOp[addr];
60095: freeP4(db, pOp->p4type, pOp->p4.p);
60096: pOp->p4.p = 0;
60097: if( n==P4_INT32 ){
60098: /* Note: this cast is safe, because the origin data point was an int
60099: ** that was cast to a (const char *). */
60100: pOp->p4.i = SQLITE_PTR_TO_INT(zP4);
60101: pOp->p4type = P4_INT32;
60102: }else if( zP4==0 ){
60103: pOp->p4.p = 0;
60104: pOp->p4type = P4_NOTUSED;
60105: }else if( n==P4_KEYINFO ){
60106: KeyInfo *pKeyInfo;
60107: int nField, nByte;
60108:
60109: nField = ((KeyInfo*)zP4)->nField;
60110: nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField;
60111: pKeyInfo = sqlite3DbMallocRaw(0, nByte);
60112: pOp->p4.pKeyInfo = pKeyInfo;
60113: if( pKeyInfo ){
60114: u8 *aSortOrder;
60115: memcpy((char*)pKeyInfo, zP4, nByte - nField);
60116: aSortOrder = pKeyInfo->aSortOrder;
60117: if( aSortOrder ){
60118: pKeyInfo->aSortOrder = (unsigned char*)&pKeyInfo->aColl[nField];
60119: memcpy(pKeyInfo->aSortOrder, aSortOrder, nField);
60120: }
60121: pOp->p4type = P4_KEYINFO;
60122: }else{
60123: p->db->mallocFailed = 1;
60124: pOp->p4type = P4_NOTUSED;
60125: }
60126: }else if( n==P4_KEYINFO_HANDOFF ){
60127: pOp->p4.p = (void*)zP4;
60128: pOp->p4type = P4_KEYINFO;
60129: }else if( n==P4_VTAB ){
60130: pOp->p4.p = (void*)zP4;
60131: pOp->p4type = P4_VTAB;
60132: sqlite3VtabLock((VTable *)zP4);
60133: assert( ((VTable *)zP4)->db==p->db );
60134: }else if( n<0 ){
60135: pOp->p4.p = (void*)zP4;
60136: pOp->p4type = (signed char)n;
60137: }else{
60138: if( n==0 ) n = sqlite3Strlen30(zP4);
60139: pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
60140: pOp->p4type = P4_DYNAMIC;
60141: }
60142: }
60143:
60144: #ifndef NDEBUG
60145: /*
60146: ** Change the comment on the the most recently coded instruction. Or
60147: ** insert a No-op and add the comment to that new instruction. This
60148: ** makes the code easier to read during debugging. None of this happens
60149: ** in a production build.
60150: */
60151: static void vdbeVComment(Vdbe *p, const char *zFormat, va_list ap){
60152: assert( p->nOp>0 || p->aOp==0 );
60153: assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->db->mallocFailed );
60154: if( p->nOp ){
60155: assert( p->aOp );
60156: sqlite3DbFree(p->db, p->aOp[p->nOp-1].zComment);
60157: p->aOp[p->nOp-1].zComment = sqlite3VMPrintf(p->db, zFormat, ap);
60158: }
60159: }
60160: SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
60161: va_list ap;
60162: if( p ){
60163: va_start(ap, zFormat);
60164: vdbeVComment(p, zFormat, ap);
60165: va_end(ap);
60166: }
60167: }
60168: SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){
60169: va_list ap;
60170: if( p ){
60171: sqlite3VdbeAddOp0(p, OP_Noop);
60172: va_start(ap, zFormat);
60173: vdbeVComment(p, zFormat, ap);
60174: va_end(ap);
60175: }
60176: }
60177: #endif /* NDEBUG */
60178:
60179: /*
60180: ** Return the opcode for a given address. If the address is -1, then
60181: ** return the most recently inserted opcode.
60182: **
60183: ** If a memory allocation error has occurred prior to the calling of this
60184: ** routine, then a pointer to a dummy VdbeOp will be returned. That opcode
60185: ** is readable but not writable, though it is cast to a writable value.
60186: ** The return of a dummy opcode allows the call to continue functioning
60187: ** after a OOM fault without having to check to see if the return from
60188: ** this routine is a valid pointer. But because the dummy.opcode is 0,
60189: ** dummy will never be written to. This is verified by code inspection and
60190: ** by running with Valgrind.
60191: **
60192: ** About the #ifdef SQLITE_OMIT_TRACE: Normally, this routine is never called
60193: ** unless p->nOp>0. This is because in the absense of SQLITE_OMIT_TRACE,
60194: ** an OP_Trace instruction is always inserted by sqlite3VdbeGet() as soon as
60195: ** a new VDBE is created. So we are free to set addr to p->nOp-1 without
60196: ** having to double-check to make sure that the result is non-negative. But
60197: ** if SQLITE_OMIT_TRACE is defined, the OP_Trace is omitted and we do need to
60198: ** check the value of p->nOp-1 before continuing.
60199: */
60200: SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
60201: /* C89 specifies that the constant "dummy" will be initialized to all
60202: ** zeros, which is correct. MSVC generates a warning, nevertheless. */
60203: static VdbeOp dummy; /* Ignore the MSVC warning about no initializer */
60204: assert( p->magic==VDBE_MAGIC_INIT );
60205: if( addr<0 ){
60206: #ifdef SQLITE_OMIT_TRACE
60207: if( p->nOp==0 ) return (VdbeOp*)&dummy;
60208: #endif
60209: addr = p->nOp - 1;
60210: }
60211: assert( (addr>=0 && addr<p->nOp) || p->db->mallocFailed );
60212: if( p->db->mallocFailed ){
60213: return (VdbeOp*)&dummy;
60214: }else{
60215: return &p->aOp[addr];
60216: }
60217: }
60218:
60219: #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \
60220: || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
60221: /*
60222: ** Compute a string that describes the P4 parameter for an opcode.
60223: ** Use zTemp for any required temporary buffer space.
60224: */
60225: static char *displayP4(Op *pOp, char *zTemp, int nTemp){
60226: char *zP4 = zTemp;
60227: assert( nTemp>=20 );
60228: switch( pOp->p4type ){
60229: case P4_KEYINFO_STATIC:
60230: case P4_KEYINFO: {
60231: int i, j;
60232: KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
60233: sqlite3_snprintf(nTemp, zTemp, "keyinfo(%d", pKeyInfo->nField);
60234: i = sqlite3Strlen30(zTemp);
60235: for(j=0; j<pKeyInfo->nField; j++){
60236: CollSeq *pColl = pKeyInfo->aColl[j];
60237: if( pColl ){
60238: int n = sqlite3Strlen30(pColl->zName);
60239: if( i+n>nTemp-6 ){
60240: memcpy(&zTemp[i],",...",4);
60241: break;
60242: }
60243: zTemp[i++] = ',';
60244: if( pKeyInfo->aSortOrder && pKeyInfo->aSortOrder[j] ){
60245: zTemp[i++] = '-';
60246: }
60247: memcpy(&zTemp[i], pColl->zName,n+1);
60248: i += n;
60249: }else if( i+4<nTemp-6 ){
60250: memcpy(&zTemp[i],",nil",4);
60251: i += 4;
60252: }
60253: }
60254: zTemp[i++] = ')';
60255: zTemp[i] = 0;
60256: assert( i<nTemp );
60257: break;
60258: }
60259: case P4_COLLSEQ: {
60260: CollSeq *pColl = pOp->p4.pColl;
60261: sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
60262: break;
60263: }
60264: case P4_FUNCDEF: {
60265: FuncDef *pDef = pOp->p4.pFunc;
60266: sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
60267: break;
60268: }
60269: case P4_INT64: {
60270: sqlite3_snprintf(nTemp, zTemp, "%lld", *pOp->p4.pI64);
60271: break;
60272: }
60273: case P4_INT32: {
60274: sqlite3_snprintf(nTemp, zTemp, "%d", pOp->p4.i);
60275: break;
60276: }
60277: case P4_REAL: {
60278: sqlite3_snprintf(nTemp, zTemp, "%.16g", *pOp->p4.pReal);
60279: break;
60280: }
60281: case P4_MEM: {
60282: Mem *pMem = pOp->p4.pMem;
60283: if( pMem->flags & MEM_Str ){
60284: zP4 = pMem->z;
60285: }else if( pMem->flags & MEM_Int ){
60286: sqlite3_snprintf(nTemp, zTemp, "%lld", pMem->u.i);
60287: }else if( pMem->flags & MEM_Real ){
60288: sqlite3_snprintf(nTemp, zTemp, "%.16g", pMem->r);
60289: }else if( pMem->flags & MEM_Null ){
60290: sqlite3_snprintf(nTemp, zTemp, "NULL");
60291: }else{
60292: assert( pMem->flags & MEM_Blob );
60293: zP4 = "(blob)";
60294: }
60295: break;
60296: }
60297: #ifndef SQLITE_OMIT_VIRTUALTABLE
60298: case P4_VTAB: {
60299: sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab;
60300: sqlite3_snprintf(nTemp, zTemp, "vtab:%p:%p", pVtab, pVtab->pModule);
60301: break;
60302: }
60303: #endif
60304: case P4_INTARRAY: {
60305: sqlite3_snprintf(nTemp, zTemp, "intarray");
60306: break;
60307: }
60308: case P4_SUBPROGRAM: {
60309: sqlite3_snprintf(nTemp, zTemp, "program");
60310: break;
60311: }
60312: case P4_ADVANCE: {
60313: zTemp[0] = 0;
60314: break;
60315: }
60316: default: {
60317: zP4 = pOp->p4.z;
60318: if( zP4==0 ){
60319: zP4 = zTemp;
60320: zTemp[0] = 0;
60321: }
60322: }
60323: }
60324: assert( zP4!=0 );
60325: return zP4;
60326: }
60327: #endif
60328:
60329: /*
60330: ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
60331: **
60332: ** The prepared statements need to know in advance the complete set of
60333: ** attached databases that will be use. A mask of these databases
60334: ** is maintained in p->btreeMask. The p->lockMask value is the subset of
60335: ** p->btreeMask of databases that will require a lock.
60336: */
60337: SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){
60338: assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
60339: assert( i<(int)sizeof(p->btreeMask)*8 );
60340: p->btreeMask |= ((yDbMask)1)<<i;
60341: if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
60342: p->lockMask |= ((yDbMask)1)<<i;
60343: }
60344: }
60345:
60346: #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
60347: /*
60348: ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
60349: ** this routine obtains the mutex associated with each BtShared structure
60350: ** that may be accessed by the VM passed as an argument. In doing so it also
60351: ** sets the BtShared.db member of each of the BtShared structures, ensuring
60352: ** that the correct busy-handler callback is invoked if required.
60353: **
60354: ** If SQLite is not threadsafe but does support shared-cache mode, then
60355: ** sqlite3BtreeEnter() is invoked to set the BtShared.db variables
60356: ** of all of BtShared structures accessible via the database handle
60357: ** associated with the VM.
60358: **
60359: ** If SQLite is not threadsafe and does not support shared-cache mode, this
60360: ** function is a no-op.
60361: **
60362: ** The p->btreeMask field is a bitmask of all btrees that the prepared
60363: ** statement p will ever use. Let N be the number of bits in p->btreeMask
60364: ** corresponding to btrees that use shared cache. Then the runtime of
60365: ** this routine is N*N. But as N is rarely more than 1, this should not
60366: ** be a problem.
60367: */
60368: SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){
60369: int i;
60370: yDbMask mask;
60371: sqlite3 *db;
60372: Db *aDb;
60373: int nDb;
60374: if( p->lockMask==0 ) return; /* The common case */
60375: db = p->db;
60376: aDb = db->aDb;
60377: nDb = db->nDb;
60378: for(i=0, mask=1; i<nDb; i++, mask += mask){
60379: if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
60380: sqlite3BtreeEnter(aDb[i].pBt);
60381: }
60382: }
60383: }
60384: #endif
60385:
60386: #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
60387: /*
60388: ** Unlock all of the btrees previously locked by a call to sqlite3VdbeEnter().
60389: */
60390: SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){
60391: int i;
60392: yDbMask mask;
60393: sqlite3 *db;
60394: Db *aDb;
60395: int nDb;
60396: if( p->lockMask==0 ) return; /* The common case */
60397: db = p->db;
60398: aDb = db->aDb;
60399: nDb = db->nDb;
60400: for(i=0, mask=1; i<nDb; i++, mask += mask){
60401: if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
60402: sqlite3BtreeLeave(aDb[i].pBt);
60403: }
60404: }
60405: }
60406: #endif
60407:
60408: #if defined(VDBE_PROFILE) || defined(SQLITE_DEBUG)
60409: /*
60410: ** Print a single opcode. This routine is used for debugging only.
60411: */
60412: SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){
60413: char *zP4;
60414: char zPtr[50];
60415: static const char *zFormat1 = "%4d %-13s %4d %4d %4d %-4s %.2X %s\n";
60416: if( pOut==0 ) pOut = stdout;
60417: zP4 = displayP4(pOp, zPtr, sizeof(zPtr));
60418: fprintf(pOut, zFormat1, pc,
60419: sqlite3OpcodeName(pOp->opcode), pOp->p1, pOp->p2, pOp->p3, zP4, pOp->p5,
60420: #ifdef SQLITE_DEBUG
60421: pOp->zComment ? pOp->zComment : ""
60422: #else
60423: ""
60424: #endif
60425: );
60426: fflush(pOut);
60427: }
60428: #endif
60429:
60430: /*
60431: ** Release an array of N Mem elements
60432: */
60433: static void releaseMemArray(Mem *p, int N){
60434: if( p && N ){
60435: Mem *pEnd;
60436: sqlite3 *db = p->db;
60437: u8 malloc_failed = db->mallocFailed;
60438: if( db->pnBytesFreed ){
60439: for(pEnd=&p[N]; p<pEnd; p++){
60440: sqlite3DbFree(db, p->zMalloc);
60441: }
60442: return;
60443: }
60444: for(pEnd=&p[N]; p<pEnd; p++){
60445: assert( (&p[1])==pEnd || p[0].db==p[1].db );
60446:
60447: /* This block is really an inlined version of sqlite3VdbeMemRelease()
60448: ** that takes advantage of the fact that the memory cell value is
60449: ** being set to NULL after releasing any dynamic resources.
60450: **
60451: ** The justification for duplicating code is that according to
60452: ** callgrind, this causes a certain test case to hit the CPU 4.7
60453: ** percent less (x86 linux, gcc version 4.1.2, -O6) than if
60454: ** sqlite3MemRelease() were called from here. With -O2, this jumps
60455: ** to 6.6 percent. The test case is inserting 1000 rows into a table
60456: ** with no indexes using a single prepared INSERT statement, bind()
60457: ** and reset(). Inserts are grouped into a transaction.
60458: */
60459: if( p->flags&(MEM_Agg|MEM_Dyn|MEM_Frame|MEM_RowSet) ){
60460: sqlite3VdbeMemRelease(p);
60461: }else if( p->zMalloc ){
60462: sqlite3DbFree(db, p->zMalloc);
60463: p->zMalloc = 0;
60464: }
60465:
60466: p->flags = MEM_Invalid;
60467: }
60468: db->mallocFailed = malloc_failed;
60469: }
60470: }
60471:
60472: /*
60473: ** Delete a VdbeFrame object and its contents. VdbeFrame objects are
60474: ** allocated by the OP_Program opcode in sqlite3VdbeExec().
60475: */
60476: SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame *p){
60477: int i;
60478: Mem *aMem = VdbeFrameMem(p);
60479: VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem];
60480: for(i=0; i<p->nChildCsr; i++){
60481: sqlite3VdbeFreeCursor(p->v, apCsr[i]);
60482: }
60483: releaseMemArray(aMem, p->nChildMem);
60484: sqlite3DbFree(p->v->db, p);
60485: }
60486:
60487: #ifndef SQLITE_OMIT_EXPLAIN
60488: /*
60489: ** Give a listing of the program in the virtual machine.
60490: **
60491: ** The interface is the same as sqlite3VdbeExec(). But instead of
60492: ** running the code, it invokes the callback once for each instruction.
60493: ** This feature is used to implement "EXPLAIN".
60494: **
60495: ** When p->explain==1, each instruction is listed. When
60496: ** p->explain==2, only OP_Explain instructions are listed and these
60497: ** are shown in a different format. p->explain==2 is used to implement
60498: ** EXPLAIN QUERY PLAN.
60499: **
60500: ** When p->explain==1, first the main program is listed, then each of
60501: ** the trigger subprograms are listed one by one.
60502: */
60503: SQLITE_PRIVATE int sqlite3VdbeList(
60504: Vdbe *p /* The VDBE */
60505: ){
60506: int nRow; /* Stop when row count reaches this */
60507: int nSub = 0; /* Number of sub-vdbes seen so far */
60508: SubProgram **apSub = 0; /* Array of sub-vdbes */
60509: Mem *pSub = 0; /* Memory cell hold array of subprogs */
60510: sqlite3 *db = p->db; /* The database connection */
60511: int i; /* Loop counter */
60512: int rc = SQLITE_OK; /* Return code */
60513: Mem *pMem = &p->aMem[1]; /* First Mem of result set */
60514:
60515: assert( p->explain );
60516: assert( p->magic==VDBE_MAGIC_RUN );
60517: assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
60518:
60519: /* Even though this opcode does not use dynamic strings for
60520: ** the result, result columns may become dynamic if the user calls
60521: ** sqlite3_column_text16(), causing a translation to UTF-16 encoding.
60522: */
60523: releaseMemArray(pMem, 8);
60524: p->pResultSet = 0;
60525:
60526: if( p->rc==SQLITE_NOMEM ){
60527: /* This happens if a malloc() inside a call to sqlite3_column_text() or
60528: ** sqlite3_column_text16() failed. */
60529: db->mallocFailed = 1;
60530: return SQLITE_ERROR;
60531: }
60532:
60533: /* When the number of output rows reaches nRow, that means the
60534: ** listing has finished and sqlite3_step() should return SQLITE_DONE.
60535: ** nRow is the sum of the number of rows in the main program, plus
60536: ** the sum of the number of rows in all trigger subprograms encountered
60537: ** so far. The nRow value will increase as new trigger subprograms are
60538: ** encountered, but p->pc will eventually catch up to nRow.
60539: */
60540: nRow = p->nOp;
60541: if( p->explain==1 ){
60542: /* The first 8 memory cells are used for the result set. So we will
60543: ** commandeer the 9th cell to use as storage for an array of pointers
60544: ** to trigger subprograms. The VDBE is guaranteed to have at least 9
60545: ** cells. */
60546: assert( p->nMem>9 );
60547: pSub = &p->aMem[9];
60548: if( pSub->flags&MEM_Blob ){
60549: /* On the first call to sqlite3_step(), pSub will hold a NULL. It is
60550: ** initialized to a BLOB by the P4_SUBPROGRAM processing logic below */
60551: nSub = pSub->n/sizeof(Vdbe*);
60552: apSub = (SubProgram **)pSub->z;
60553: }
60554: for(i=0; i<nSub; i++){
60555: nRow += apSub[i]->nOp;
60556: }
60557: }
60558:
60559: do{
60560: i = p->pc++;
60561: }while( i<nRow && p->explain==2 && p->aOp[i].opcode!=OP_Explain );
60562: if( i>=nRow ){
60563: p->rc = SQLITE_OK;
60564: rc = SQLITE_DONE;
60565: }else if( db->u1.isInterrupted ){
60566: p->rc = SQLITE_INTERRUPT;
60567: rc = SQLITE_ERROR;
60568: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(p->rc));
60569: }else{
60570: char *z;
60571: Op *pOp;
60572: if( i<p->nOp ){
60573: /* The output line number is small enough that we are still in the
60574: ** main program. */
60575: pOp = &p->aOp[i];
60576: }else{
60577: /* We are currently listing subprograms. Figure out which one and
60578: ** pick up the appropriate opcode. */
60579: int j;
60580: i -= p->nOp;
60581: for(j=0; i>=apSub[j]->nOp; j++){
60582: i -= apSub[j]->nOp;
60583: }
60584: pOp = &apSub[j]->aOp[i];
60585: }
60586: if( p->explain==1 ){
60587: pMem->flags = MEM_Int;
60588: pMem->type = SQLITE_INTEGER;
60589: pMem->u.i = i; /* Program counter */
60590: pMem++;
60591:
60592: pMem->flags = MEM_Static|MEM_Str|MEM_Term;
60593: pMem->z = (char*)sqlite3OpcodeName(pOp->opcode); /* Opcode */
60594: assert( pMem->z!=0 );
60595: pMem->n = sqlite3Strlen30(pMem->z);
60596: pMem->type = SQLITE_TEXT;
60597: pMem->enc = SQLITE_UTF8;
60598: pMem++;
60599:
60600: /* When an OP_Program opcode is encounter (the only opcode that has
60601: ** a P4_SUBPROGRAM argument), expand the size of the array of subprograms
60602: ** kept in p->aMem[9].z to hold the new program - assuming this subprogram
60603: ** has not already been seen.
60604: */
60605: if( pOp->p4type==P4_SUBPROGRAM ){
60606: int nByte = (nSub+1)*sizeof(SubProgram*);
60607: int j;
60608: for(j=0; j<nSub; j++){
60609: if( apSub[j]==pOp->p4.pProgram ) break;
60610: }
60611: if( j==nSub && SQLITE_OK==sqlite3VdbeMemGrow(pSub, nByte, 1) ){
60612: apSub = (SubProgram **)pSub->z;
60613: apSub[nSub++] = pOp->p4.pProgram;
60614: pSub->flags |= MEM_Blob;
60615: pSub->n = nSub*sizeof(SubProgram*);
60616: }
60617: }
60618: }
60619:
60620: pMem->flags = MEM_Int;
60621: pMem->u.i = pOp->p1; /* P1 */
60622: pMem->type = SQLITE_INTEGER;
60623: pMem++;
60624:
60625: pMem->flags = MEM_Int;
60626: pMem->u.i = pOp->p2; /* P2 */
60627: pMem->type = SQLITE_INTEGER;
60628: pMem++;
60629:
60630: pMem->flags = MEM_Int;
60631: pMem->u.i = pOp->p3; /* P3 */
60632: pMem->type = SQLITE_INTEGER;
60633: pMem++;
60634:
60635: if( sqlite3VdbeMemGrow(pMem, 32, 0) ){ /* P4 */
60636: assert( p->db->mallocFailed );
60637: return SQLITE_ERROR;
60638: }
60639: pMem->flags = MEM_Dyn|MEM_Str|MEM_Term;
60640: z = displayP4(pOp, pMem->z, 32);
60641: if( z!=pMem->z ){
60642: sqlite3VdbeMemSetStr(pMem, z, -1, SQLITE_UTF8, 0);
60643: }else{
60644: assert( pMem->z!=0 );
60645: pMem->n = sqlite3Strlen30(pMem->z);
60646: pMem->enc = SQLITE_UTF8;
60647: }
60648: pMem->type = SQLITE_TEXT;
60649: pMem++;
60650:
60651: if( p->explain==1 ){
60652: if( sqlite3VdbeMemGrow(pMem, 4, 0) ){
60653: assert( p->db->mallocFailed );
60654: return SQLITE_ERROR;
60655: }
60656: pMem->flags = MEM_Dyn|MEM_Str|MEM_Term;
60657: pMem->n = 2;
60658: sqlite3_snprintf(3, pMem->z, "%.2x", pOp->p5); /* P5 */
60659: pMem->type = SQLITE_TEXT;
60660: pMem->enc = SQLITE_UTF8;
60661: pMem++;
60662:
60663: #ifdef SQLITE_DEBUG
60664: if( pOp->zComment ){
60665: pMem->flags = MEM_Str|MEM_Term;
60666: pMem->z = pOp->zComment;
60667: pMem->n = sqlite3Strlen30(pMem->z);
60668: pMem->enc = SQLITE_UTF8;
60669: pMem->type = SQLITE_TEXT;
60670: }else
60671: #endif
60672: {
60673: pMem->flags = MEM_Null; /* Comment */
60674: pMem->type = SQLITE_NULL;
60675: }
60676: }
60677:
60678: p->nResColumn = 8 - 4*(p->explain-1);
60679: p->pResultSet = &p->aMem[1];
60680: p->rc = SQLITE_OK;
60681: rc = SQLITE_ROW;
60682: }
60683: return rc;
60684: }
60685: #endif /* SQLITE_OMIT_EXPLAIN */
60686:
60687: #ifdef SQLITE_DEBUG
60688: /*
60689: ** Print the SQL that was used to generate a VDBE program.
60690: */
60691: SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe *p){
60692: int nOp = p->nOp;
60693: VdbeOp *pOp;
60694: if( nOp<1 ) return;
60695: pOp = &p->aOp[0];
60696: if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){
60697: const char *z = pOp->p4.z;
60698: while( sqlite3Isspace(*z) ) z++;
60699: printf("SQL: [%s]\n", z);
60700: }
60701: }
60702: #endif
60703:
60704: #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
60705: /*
60706: ** Print an IOTRACE message showing SQL content.
60707: */
60708: SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){
60709: int nOp = p->nOp;
60710: VdbeOp *pOp;
60711: if( sqlite3IoTrace==0 ) return;
60712: if( nOp<1 ) return;
60713: pOp = &p->aOp[0];
60714: if( pOp->opcode==OP_Trace && pOp->p4.z!=0 ){
60715: int i, j;
60716: char z[1000];
60717: sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
60718: for(i=0; sqlite3Isspace(z[i]); i++){}
60719: for(j=0; z[i]; i++){
60720: if( sqlite3Isspace(z[i]) ){
60721: if( z[i-1]!=' ' ){
60722: z[j++] = ' ';
60723: }
60724: }else{
60725: z[j++] = z[i];
60726: }
60727: }
60728: z[j] = 0;
60729: sqlite3IoTrace("SQL %s\n", z);
60730: }
60731: }
60732: #endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */
60733:
60734: /*
60735: ** Allocate space from a fixed size buffer and return a pointer to
60736: ** that space. If insufficient space is available, return NULL.
60737: **
60738: ** The pBuf parameter is the initial value of a pointer which will
60739: ** receive the new memory. pBuf is normally NULL. If pBuf is not
60740: ** NULL, it means that memory space has already been allocated and that
60741: ** this routine should not allocate any new memory. When pBuf is not
60742: ** NULL simply return pBuf. Only allocate new memory space when pBuf
60743: ** is NULL.
60744: **
60745: ** nByte is the number of bytes of space needed.
60746: **
60747: ** *ppFrom points to available space and pEnd points to the end of the
60748: ** available space. When space is allocated, *ppFrom is advanced past
60749: ** the end of the allocated space.
60750: **
60751: ** *pnByte is a counter of the number of bytes of space that have failed
60752: ** to allocate. If there is insufficient space in *ppFrom to satisfy the
60753: ** request, then increment *pnByte by the amount of the request.
60754: */
60755: static void *allocSpace(
60756: void *pBuf, /* Where return pointer will be stored */
60757: int nByte, /* Number of bytes to allocate */
60758: u8 **ppFrom, /* IN/OUT: Allocate from *ppFrom */
60759: u8 *pEnd, /* Pointer to 1 byte past the end of *ppFrom buffer */
60760: int *pnByte /* If allocation cannot be made, increment *pnByte */
60761: ){
60762: assert( EIGHT_BYTE_ALIGNMENT(*ppFrom) );
60763: if( pBuf ) return pBuf;
60764: nByte = ROUND8(nByte);
60765: if( &(*ppFrom)[nByte] <= pEnd ){
60766: pBuf = (void*)*ppFrom;
60767: *ppFrom += nByte;
60768: }else{
60769: *pnByte += nByte;
60770: }
60771: return pBuf;
60772: }
60773:
60774: /*
60775: ** Rewind the VDBE back to the beginning in preparation for
60776: ** running it.
60777: */
60778: SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){
60779: #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
60780: int i;
60781: #endif
60782: assert( p!=0 );
60783: assert( p->magic==VDBE_MAGIC_INIT );
60784:
60785: /* There should be at least one opcode.
60786: */
60787: assert( p->nOp>0 );
60788:
60789: /* Set the magic to VDBE_MAGIC_RUN sooner rather than later. */
60790: p->magic = VDBE_MAGIC_RUN;
60791:
60792: #ifdef SQLITE_DEBUG
60793: for(i=1; i<p->nMem; i++){
60794: assert( p->aMem[i].db==p->db );
60795: }
60796: #endif
60797: p->pc = -1;
60798: p->rc = SQLITE_OK;
60799: p->errorAction = OE_Abort;
60800: p->magic = VDBE_MAGIC_RUN;
60801: p->nChange = 0;
60802: p->cacheCtr = 1;
60803: p->minWriteFileFormat = 255;
60804: p->iStatement = 0;
60805: p->nFkConstraint = 0;
60806: #ifdef VDBE_PROFILE
60807: for(i=0; i<p->nOp; i++){
60808: p->aOp[i].cnt = 0;
60809: p->aOp[i].cycles = 0;
60810: }
60811: #endif
60812: }
60813:
60814: /*
60815: ** Prepare a virtual machine for execution for the first time after
60816: ** creating the virtual machine. This involves things such
60817: ** as allocating stack space and initializing the program counter.
60818: ** After the VDBE has be prepped, it can be executed by one or more
60819: ** calls to sqlite3VdbeExec().
60820: **
60821: ** This function may be called exact once on a each virtual machine.
60822: ** After this routine is called the VM has been "packaged" and is ready
60823: ** to run. After this routine is called, futher calls to
60824: ** sqlite3VdbeAddOp() functions are prohibited. This routine disconnects
60825: ** the Vdbe from the Parse object that helped generate it so that the
60826: ** the Vdbe becomes an independent entity and the Parse object can be
60827: ** destroyed.
60828: **
60829: ** Use the sqlite3VdbeRewind() procedure to restore a virtual machine back
60830: ** to its initial state after it has been run.
60831: */
60832: SQLITE_PRIVATE void sqlite3VdbeMakeReady(
60833: Vdbe *p, /* The VDBE */
60834: Parse *pParse /* Parsing context */
60835: ){
60836: sqlite3 *db; /* The database connection */
60837: int nVar; /* Number of parameters */
60838: int nMem; /* Number of VM memory registers */
60839: int nCursor; /* Number of cursors required */
60840: int nArg; /* Number of arguments in subprograms */
60841: int nOnce; /* Number of OP_Once instructions */
60842: int n; /* Loop counter */
60843: u8 *zCsr; /* Memory available for allocation */
60844: u8 *zEnd; /* First byte past allocated memory */
60845: int nByte; /* How much extra memory is needed */
60846:
60847: assert( p!=0 );
60848: assert( p->nOp>0 );
60849: assert( pParse!=0 );
60850: assert( p->magic==VDBE_MAGIC_INIT );
60851: db = p->db;
60852: assert( db->mallocFailed==0 );
60853: nVar = pParse->nVar;
60854: nMem = pParse->nMem;
60855: nCursor = pParse->nTab;
60856: nArg = pParse->nMaxArg;
60857: nOnce = pParse->nOnce;
60858: if( nOnce==0 ) nOnce = 1; /* Ensure at least one byte in p->aOnceFlag[] */
60859:
60860: /* For each cursor required, also allocate a memory cell. Memory
60861: ** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by
60862: ** the vdbe program. Instead they are used to allocate space for
60863: ** VdbeCursor/BtCursor structures. The blob of memory associated with
60864: ** cursor 0 is stored in memory cell nMem. Memory cell (nMem-1)
60865: ** stores the blob of memory associated with cursor 1, etc.
60866: **
60867: ** See also: allocateCursor().
60868: */
60869: nMem += nCursor;
60870:
60871: /* Allocate space for memory registers, SQL variables, VDBE cursors and
60872: ** an array to marshal SQL function arguments in.
60873: */
60874: zCsr = (u8*)&p->aOp[p->nOp]; /* Memory avaliable for allocation */
60875: zEnd = (u8*)&p->aOp[p->nOpAlloc]; /* First byte past end of zCsr[] */
60876:
60877: resolveP2Values(p, &nArg);
60878: p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
60879: if( pParse->explain && nMem<10 ){
60880: nMem = 10;
60881: }
60882: memset(zCsr, 0, zEnd-zCsr);
60883: zCsr += (zCsr - (u8*)0)&7;
60884: assert( EIGHT_BYTE_ALIGNMENT(zCsr) );
60885: p->expired = 0;
60886:
60887: /* Memory for registers, parameters, cursor, etc, is allocated in two
60888: ** passes. On the first pass, we try to reuse unused space at the
60889: ** end of the opcode array. If we are unable to satisfy all memory
60890: ** requirements by reusing the opcode array tail, then the second
60891: ** pass will fill in the rest using a fresh allocation.
60892: **
60893: ** This two-pass approach that reuses as much memory as possible from
60894: ** the leftover space at the end of the opcode array can significantly
60895: ** reduce the amount of memory held by a prepared statement.
60896: */
60897: do {
60898: nByte = 0;
60899: p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
60900: p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
60901: p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
60902: p->azVar = allocSpace(p->azVar, nVar*sizeof(char*), &zCsr, zEnd, &nByte);
60903: p->apCsr = allocSpace(p->apCsr, nCursor*sizeof(VdbeCursor*),
60904: &zCsr, zEnd, &nByte);
60905: p->aOnceFlag = allocSpace(p->aOnceFlag, nOnce, &zCsr, zEnd, &nByte);
60906: if( nByte ){
60907: p->pFree = sqlite3DbMallocZero(db, nByte);
60908: }
60909: zCsr = p->pFree;
60910: zEnd = &zCsr[nByte];
60911: }while( nByte && !db->mallocFailed );
60912:
60913: p->nCursor = (u16)nCursor;
60914: p->nOnceFlag = nOnce;
60915: if( p->aVar ){
60916: p->nVar = (ynVar)nVar;
60917: for(n=0; n<nVar; n++){
60918: p->aVar[n].flags = MEM_Null;
60919: p->aVar[n].db = db;
60920: }
60921: }
60922: if( p->azVar ){
60923: p->nzVar = pParse->nzVar;
60924: memcpy(p->azVar, pParse->azVar, p->nzVar*sizeof(p->azVar[0]));
60925: memset(pParse->azVar, 0, pParse->nzVar*sizeof(pParse->azVar[0]));
60926: }
60927: if( p->aMem ){
60928: p->aMem--; /* aMem[] goes from 1..nMem */
60929: p->nMem = nMem; /* not from 0..nMem-1 */
60930: for(n=1; n<=nMem; n++){
60931: p->aMem[n].flags = MEM_Invalid;
60932: p->aMem[n].db = db;
60933: }
60934: }
60935: p->explain = pParse->explain;
60936: sqlite3VdbeRewind(p);
60937: }
60938:
60939: /*
60940: ** Close a VDBE cursor and release all the resources that cursor
60941: ** happens to hold.
60942: */
60943: SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
60944: if( pCx==0 ){
60945: return;
60946: }
60947: sqlite3VdbeSorterClose(p->db, pCx);
60948: if( pCx->pBt ){
60949: sqlite3BtreeClose(pCx->pBt);
60950: /* The pCx->pCursor will be close automatically, if it exists, by
60951: ** the call above. */
60952: }else if( pCx->pCursor ){
60953: sqlite3BtreeCloseCursor(pCx->pCursor);
60954: }
60955: #ifndef SQLITE_OMIT_VIRTUALTABLE
60956: if( pCx->pVtabCursor ){
60957: sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor;
60958: const sqlite3_module *pModule = pCx->pModule;
60959: p->inVtabMethod = 1;
60960: pModule->xClose(pVtabCursor);
60961: p->inVtabMethod = 0;
60962: }
60963: #endif
60964: }
60965:
60966: /*
60967: ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
60968: ** is used, for example, when a trigger sub-program is halted to restore
60969: ** control to the main program.
60970: */
60971: SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *pFrame){
60972: Vdbe *v = pFrame->v;
60973: v->aOnceFlag = pFrame->aOnceFlag;
60974: v->nOnceFlag = pFrame->nOnceFlag;
60975: v->aOp = pFrame->aOp;
60976: v->nOp = pFrame->nOp;
60977: v->aMem = pFrame->aMem;
60978: v->nMem = pFrame->nMem;
60979: v->apCsr = pFrame->apCsr;
60980: v->nCursor = pFrame->nCursor;
60981: v->db->lastRowid = pFrame->lastRowid;
60982: v->nChange = pFrame->nChange;
60983: return pFrame->pc;
60984: }
60985:
60986: /*
60987: ** Close all cursors.
60988: **
60989: ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory
60990: ** cell array. This is necessary as the memory cell array may contain
60991: ** pointers to VdbeFrame objects, which may in turn contain pointers to
60992: ** open cursors.
60993: */
60994: static void closeAllCursors(Vdbe *p){
60995: if( p->pFrame ){
60996: VdbeFrame *pFrame;
60997: for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
60998: sqlite3VdbeFrameRestore(pFrame);
60999: }
61000: p->pFrame = 0;
61001: p->nFrame = 0;
61002:
61003: if( p->apCsr ){
61004: int i;
61005: for(i=0; i<p->nCursor; i++){
61006: VdbeCursor *pC = p->apCsr[i];
61007: if( pC ){
61008: sqlite3VdbeFreeCursor(p, pC);
61009: p->apCsr[i] = 0;
61010: }
61011: }
61012: }
61013: if( p->aMem ){
61014: releaseMemArray(&p->aMem[1], p->nMem);
61015: }
61016: while( p->pDelFrame ){
61017: VdbeFrame *pDel = p->pDelFrame;
61018: p->pDelFrame = pDel->pParent;
61019: sqlite3VdbeFrameDelete(pDel);
61020: }
61021: }
61022:
61023: /*
61024: ** Clean up the VM after execution.
61025: **
61026: ** This routine will automatically close any cursors, lists, and/or
61027: ** sorters that were left open. It also deletes the values of
61028: ** variables in the aVar[] array.
61029: */
61030: static void Cleanup(Vdbe *p){
61031: sqlite3 *db = p->db;
61032:
61033: #ifdef SQLITE_DEBUG
61034: /* Execute assert() statements to ensure that the Vdbe.apCsr[] and
61035: ** Vdbe.aMem[] arrays have already been cleaned up. */
61036: int i;
61037: if( p->apCsr ) for(i=0; i<p->nCursor; i++) assert( p->apCsr[i]==0 );
61038: if( p->aMem ){
61039: for(i=1; i<=p->nMem; i++) assert( p->aMem[i].flags==MEM_Invalid );
61040: }
61041: #endif
61042:
61043: sqlite3DbFree(db, p->zErrMsg);
61044: p->zErrMsg = 0;
61045: p->pResultSet = 0;
61046: }
61047:
61048: /*
61049: ** Set the number of result columns that will be returned by this SQL
61050: ** statement. This is now set at compile time, rather than during
61051: ** execution of the vdbe program so that sqlite3_column_count() can
61052: ** be called on an SQL statement before sqlite3_step().
61053: */
61054: SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
61055: Mem *pColName;
61056: int n;
61057: sqlite3 *db = p->db;
61058:
61059: releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
61060: sqlite3DbFree(db, p->aColName);
61061: n = nResColumn*COLNAME_N;
61062: p->nResColumn = (u16)nResColumn;
61063: p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
61064: if( p->aColName==0 ) return;
61065: while( n-- > 0 ){
61066: pColName->flags = MEM_Null;
61067: pColName->db = p->db;
61068: pColName++;
61069: }
61070: }
61071:
61072: /*
61073: ** Set the name of the idx'th column to be returned by the SQL statement.
61074: ** zName must be a pointer to a nul terminated string.
61075: **
61076: ** This call must be made after a call to sqlite3VdbeSetNumCols().
61077: **
61078: ** The final parameter, xDel, must be one of SQLITE_DYNAMIC, SQLITE_STATIC
61079: ** or SQLITE_TRANSIENT. If it is SQLITE_DYNAMIC, then the buffer pointed
61080: ** to by zName will be freed by sqlite3DbFree() when the vdbe is destroyed.
61081: */
61082: SQLITE_PRIVATE int sqlite3VdbeSetColName(
61083: Vdbe *p, /* Vdbe being configured */
61084: int idx, /* Index of column zName applies to */
61085: int var, /* One of the COLNAME_* constants */
61086: const char *zName, /* Pointer to buffer containing name */
61087: void (*xDel)(void*) /* Memory management strategy for zName */
61088: ){
61089: int rc;
61090: Mem *pColName;
61091: assert( idx<p->nResColumn );
61092: assert( var<COLNAME_N );
61093: if( p->db->mallocFailed ){
61094: assert( !zName || xDel!=SQLITE_DYNAMIC );
61095: return SQLITE_NOMEM;
61096: }
61097: assert( p->aColName!=0 );
61098: pColName = &(p->aColName[idx+var*p->nResColumn]);
61099: rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, xDel);
61100: assert( rc!=0 || !zName || (pColName->flags&MEM_Term)!=0 );
61101: return rc;
61102: }
61103:
61104: /*
61105: ** A read or write transaction may or may not be active on database handle
61106: ** db. If a transaction is active, commit it. If there is a
61107: ** write-transaction spanning more than one database file, this routine
61108: ** takes care of the master journal trickery.
61109: */
61110: static int vdbeCommit(sqlite3 *db, Vdbe *p){
61111: int i;
61112: int nTrans = 0; /* Number of databases with an active write-transaction */
61113: int rc = SQLITE_OK;
61114: int needXcommit = 0;
61115:
61116: #ifdef SQLITE_OMIT_VIRTUALTABLE
61117: /* With this option, sqlite3VtabSync() is defined to be simply
61118: ** SQLITE_OK so p is not used.
61119: */
61120: UNUSED_PARAMETER(p);
61121: #endif
61122:
61123: /* Before doing anything else, call the xSync() callback for any
61124: ** virtual module tables written in this transaction. This has to
61125: ** be done before determining whether a master journal file is
61126: ** required, as an xSync() callback may add an attached database
61127: ** to the transaction.
61128: */
61129: rc = sqlite3VtabSync(db, &p->zErrMsg);
61130:
61131: /* This loop determines (a) if the commit hook should be invoked and
61132: ** (b) how many database files have open write transactions, not
61133: ** including the temp database. (b) is important because if more than
61134: ** one database file has an open write transaction, a master journal
61135: ** file is required for an atomic commit.
61136: */
61137: for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
61138: Btree *pBt = db->aDb[i].pBt;
61139: if( sqlite3BtreeIsInTrans(pBt) ){
61140: needXcommit = 1;
61141: if( i!=1 ) nTrans++;
61142: rc = sqlite3PagerExclusiveLock(sqlite3BtreePager(pBt));
61143: }
61144: }
61145: if( rc!=SQLITE_OK ){
61146: return rc;
61147: }
61148:
61149: /* If there are any write-transactions at all, invoke the commit hook */
61150: if( needXcommit && db->xCommitCallback ){
61151: rc = db->xCommitCallback(db->pCommitArg);
61152: if( rc ){
61153: return SQLITE_CONSTRAINT;
61154: }
61155: }
61156:
61157: /* The simple case - no more than one database file (not counting the
61158: ** TEMP database) has a transaction active. There is no need for the
61159: ** master-journal.
61160: **
61161: ** If the return value of sqlite3BtreeGetFilename() is a zero length
61162: ** string, it means the main database is :memory: or a temp file. In
61163: ** that case we do not support atomic multi-file commits, so use the
61164: ** simple case then too.
61165: */
61166: if( 0==sqlite3Strlen30(sqlite3BtreeGetFilename(db->aDb[0].pBt))
61167: || nTrans<=1
61168: ){
61169: for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
61170: Btree *pBt = db->aDb[i].pBt;
61171: if( pBt ){
61172: rc = sqlite3BtreeCommitPhaseOne(pBt, 0);
61173: }
61174: }
61175:
61176: /* Do the commit only if all databases successfully complete phase 1.
61177: ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
61178: ** IO error while deleting or truncating a journal file. It is unlikely,
61179: ** but could happen. In this case abandon processing and return the error.
61180: */
61181: for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
61182: Btree *pBt = db->aDb[i].pBt;
61183: if( pBt ){
61184: rc = sqlite3BtreeCommitPhaseTwo(pBt, 0);
61185: }
61186: }
61187: if( rc==SQLITE_OK ){
61188: sqlite3VtabCommit(db);
61189: }
61190: }
61191:
61192: /* The complex case - There is a multi-file write-transaction active.
61193: ** This requires a master journal file to ensure the transaction is
61194: ** committed atomicly.
61195: */
61196: #ifndef SQLITE_OMIT_DISKIO
61197: else{
61198: sqlite3_vfs *pVfs = db->pVfs;
61199: int needSync = 0;
61200: char *zMaster = 0; /* File-name for the master journal */
61201: char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt);
61202: sqlite3_file *pMaster = 0;
61203: i64 offset = 0;
61204: int res;
61205: int retryCount = 0;
61206: int nMainFile;
61207:
61208: /* Select a master journal file name */
61209: nMainFile = sqlite3Strlen30(zMainFile);
61210: zMaster = sqlite3MPrintf(db, "%s-mjXXXXXX9XXz", zMainFile);
61211: if( zMaster==0 ) return SQLITE_NOMEM;
61212: do {
61213: u32 iRandom;
61214: if( retryCount ){
61215: if( retryCount>100 ){
61216: sqlite3_log(SQLITE_FULL, "MJ delete: %s", zMaster);
61217: sqlite3OsDelete(pVfs, zMaster, 0);
61218: break;
61219: }else if( retryCount==1 ){
61220: sqlite3_log(SQLITE_FULL, "MJ collide: %s", zMaster);
61221: }
61222: }
61223: retryCount++;
61224: sqlite3_randomness(sizeof(iRandom), &iRandom);
61225: sqlite3_snprintf(13, &zMaster[nMainFile], "-mj%06X9%02X",
61226: (iRandom>>8)&0xffffff, iRandom&0xff);
61227: /* The antipenultimate character of the master journal name must
61228: ** be "9" to avoid name collisions when using 8+3 filenames. */
61229: assert( zMaster[sqlite3Strlen30(zMaster)-3]=='9' );
61230: sqlite3FileSuffix3(zMainFile, zMaster);
61231: rc = sqlite3OsAccess(pVfs, zMaster, SQLITE_ACCESS_EXISTS, &res);
61232: }while( rc==SQLITE_OK && res );
61233: if( rc==SQLITE_OK ){
61234: /* Open the master journal. */
61235: rc = sqlite3OsOpenMalloc(pVfs, zMaster, &pMaster,
61236: SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE|
61237: SQLITE_OPEN_EXCLUSIVE|SQLITE_OPEN_MASTER_JOURNAL, 0
61238: );
61239: }
61240: if( rc!=SQLITE_OK ){
61241: sqlite3DbFree(db, zMaster);
61242: return rc;
61243: }
61244:
61245: /* Write the name of each database file in the transaction into the new
61246: ** master journal file. If an error occurs at this point close
61247: ** and delete the master journal file. All the individual journal files
61248: ** still have 'null' as the master journal pointer, so they will roll
61249: ** back independently if a failure occurs.
61250: */
61251: for(i=0; i<db->nDb; i++){
61252: Btree *pBt = db->aDb[i].pBt;
61253: if( sqlite3BtreeIsInTrans(pBt) ){
61254: char const *zFile = sqlite3BtreeGetJournalname(pBt);
61255: if( zFile==0 ){
61256: continue; /* Ignore TEMP and :memory: databases */
61257: }
61258: assert( zFile[0]!=0 );
61259: if( !needSync && !sqlite3BtreeSyncDisabled(pBt) ){
61260: needSync = 1;
61261: }
61262: rc = sqlite3OsWrite(pMaster, zFile, sqlite3Strlen30(zFile)+1, offset);
61263: offset += sqlite3Strlen30(zFile)+1;
61264: if( rc!=SQLITE_OK ){
61265: sqlite3OsCloseFree(pMaster);
61266: sqlite3OsDelete(pVfs, zMaster, 0);
61267: sqlite3DbFree(db, zMaster);
61268: return rc;
61269: }
61270: }
61271: }
61272:
61273: /* Sync the master journal file. If the IOCAP_SEQUENTIAL device
61274: ** flag is set this is not required.
61275: */
61276: if( needSync
61277: && 0==(sqlite3OsDeviceCharacteristics(pMaster)&SQLITE_IOCAP_SEQUENTIAL)
61278: && SQLITE_OK!=(rc = sqlite3OsSync(pMaster, SQLITE_SYNC_NORMAL))
61279: ){
61280: sqlite3OsCloseFree(pMaster);
61281: sqlite3OsDelete(pVfs, zMaster, 0);
61282: sqlite3DbFree(db, zMaster);
61283: return rc;
61284: }
61285:
61286: /* Sync all the db files involved in the transaction. The same call
61287: ** sets the master journal pointer in each individual journal. If
61288: ** an error occurs here, do not delete the master journal file.
61289: **
61290: ** If the error occurs during the first call to
61291: ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
61292: ** master journal file will be orphaned. But we cannot delete it,
61293: ** in case the master journal file name was written into the journal
61294: ** file before the failure occurred.
61295: */
61296: for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
61297: Btree *pBt = db->aDb[i].pBt;
61298: if( pBt ){
61299: rc = sqlite3BtreeCommitPhaseOne(pBt, zMaster);
61300: }
61301: }
61302: sqlite3OsCloseFree(pMaster);
61303: assert( rc!=SQLITE_BUSY );
61304: if( rc!=SQLITE_OK ){
61305: sqlite3DbFree(db, zMaster);
61306: return rc;
61307: }
61308:
61309: /* Delete the master journal file. This commits the transaction. After
61310: ** doing this the directory is synced again before any individual
61311: ** transaction files are deleted.
61312: */
61313: rc = sqlite3OsDelete(pVfs, zMaster, 1);
61314: sqlite3DbFree(db, zMaster);
61315: zMaster = 0;
61316: if( rc ){
61317: return rc;
61318: }
61319:
61320: /* All files and directories have already been synced, so the following
61321: ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
61322: ** deleting or truncating journals. If something goes wrong while
61323: ** this is happening we don't really care. The integrity of the
61324: ** transaction is already guaranteed, but some stray 'cold' journals
61325: ** may be lying around. Returning an error code won't help matters.
61326: */
61327: disable_simulated_io_errors();
61328: sqlite3BeginBenignMalloc();
61329: for(i=0; i<db->nDb; i++){
61330: Btree *pBt = db->aDb[i].pBt;
61331: if( pBt ){
61332: sqlite3BtreeCommitPhaseTwo(pBt, 1);
61333: }
61334: }
61335: sqlite3EndBenignMalloc();
61336: enable_simulated_io_errors();
61337:
61338: sqlite3VtabCommit(db);
61339: }
61340: #endif
61341:
61342: return rc;
61343: }
61344:
61345: /*
61346: ** This routine checks that the sqlite3.activeVdbeCnt count variable
61347: ** matches the number of vdbe's in the list sqlite3.pVdbe that are
61348: ** currently active. An assertion fails if the two counts do not match.
61349: ** This is an internal self-check only - it is not an essential processing
61350: ** step.
61351: **
61352: ** This is a no-op if NDEBUG is defined.
61353: */
61354: #ifndef NDEBUG
61355: static void checkActiveVdbeCnt(sqlite3 *db){
61356: Vdbe *p;
61357: int cnt = 0;
61358: int nWrite = 0;
61359: p = db->pVdbe;
61360: while( p ){
61361: if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){
61362: cnt++;
61363: if( p->readOnly==0 ) nWrite++;
61364: }
61365: p = p->pNext;
61366: }
61367: assert( cnt==db->activeVdbeCnt );
61368: assert( nWrite==db->writeVdbeCnt );
61369: }
61370: #else
61371: #define checkActiveVdbeCnt(x)
61372: #endif
61373:
61374: /*
61375: ** For every Btree that in database connection db which
61376: ** has been modified, "trip" or invalidate each cursor in
61377: ** that Btree might have been modified so that the cursor
61378: ** can never be used again. This happens when a rollback
61379: *** occurs. We have to trip all the other cursors, even
61380: ** cursor from other VMs in different database connections,
61381: ** so that none of them try to use the data at which they
61382: ** were pointing and which now may have been changed due
61383: ** to the rollback.
61384: **
61385: ** Remember that a rollback can delete tables complete and
61386: ** reorder rootpages. So it is not sufficient just to save
61387: ** the state of the cursor. We have to invalidate the cursor
61388: ** so that it is never used again.
61389: */
61390: static void invalidateCursorsOnModifiedBtrees(sqlite3 *db){
61391: int i;
61392: for(i=0; i<db->nDb; i++){
61393: Btree *p = db->aDb[i].pBt;
61394: if( p && sqlite3BtreeIsInTrans(p) ){
61395: sqlite3BtreeTripAllCursors(p, SQLITE_ABORT);
61396: }
61397: }
61398: }
61399:
61400: /*
61401: ** If the Vdbe passed as the first argument opened a statement-transaction,
61402: ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
61403: ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement
61404: ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the
61405: ** statement transaction is commtted.
61406: **
61407: ** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned.
61408: ** Otherwise SQLITE_OK.
61409: */
61410: SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){
61411: sqlite3 *const db = p->db;
61412: int rc = SQLITE_OK;
61413:
61414: /* If p->iStatement is greater than zero, then this Vdbe opened a
61415: ** statement transaction that should be closed here. The only exception
61416: ** is that an IO error may have occured, causing an emergency rollback.
61417: ** In this case (db->nStatement==0), and there is nothing to do.
61418: */
61419: if( db->nStatement && p->iStatement ){
61420: int i;
61421: const int iSavepoint = p->iStatement-1;
61422:
61423: assert( eOp==SAVEPOINT_ROLLBACK || eOp==SAVEPOINT_RELEASE);
61424: assert( db->nStatement>0 );
61425: assert( p->iStatement==(db->nStatement+db->nSavepoint) );
61426:
61427: for(i=0; i<db->nDb; i++){
61428: int rc2 = SQLITE_OK;
61429: Btree *pBt = db->aDb[i].pBt;
61430: if( pBt ){
61431: if( eOp==SAVEPOINT_ROLLBACK ){
61432: rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_ROLLBACK, iSavepoint);
61433: }
61434: if( rc2==SQLITE_OK ){
61435: rc2 = sqlite3BtreeSavepoint(pBt, SAVEPOINT_RELEASE, iSavepoint);
61436: }
61437: if( rc==SQLITE_OK ){
61438: rc = rc2;
61439: }
61440: }
61441: }
61442: db->nStatement--;
61443: p->iStatement = 0;
61444:
61445: if( rc==SQLITE_OK ){
61446: if( eOp==SAVEPOINT_ROLLBACK ){
61447: rc = sqlite3VtabSavepoint(db, SAVEPOINT_ROLLBACK, iSavepoint);
61448: }
61449: if( rc==SQLITE_OK ){
61450: rc = sqlite3VtabSavepoint(db, SAVEPOINT_RELEASE, iSavepoint);
61451: }
61452: }
61453:
61454: /* If the statement transaction is being rolled back, also restore the
61455: ** database handles deferred constraint counter to the value it had when
61456: ** the statement transaction was opened. */
61457: if( eOp==SAVEPOINT_ROLLBACK ){
61458: db->nDeferredCons = p->nStmtDefCons;
61459: }
61460: }
61461: return rc;
61462: }
61463:
61464: /*
61465: ** This function is called when a transaction opened by the database
61466: ** handle associated with the VM passed as an argument is about to be
61467: ** committed. If there are outstanding deferred foreign key constraint
61468: ** violations, return SQLITE_ERROR. Otherwise, SQLITE_OK.
61469: **
61470: ** If there are outstanding FK violations and this function returns
61471: ** SQLITE_ERROR, set the result of the VM to SQLITE_CONSTRAINT and write
61472: ** an error message to it. Then return SQLITE_ERROR.
61473: */
61474: #ifndef SQLITE_OMIT_FOREIGN_KEY
61475: SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
61476: sqlite3 *db = p->db;
61477: if( (deferred && db->nDeferredCons>0) || (!deferred && p->nFkConstraint>0) ){
61478: p->rc = SQLITE_CONSTRAINT;
61479: p->errorAction = OE_Abort;
61480: sqlite3SetString(&p->zErrMsg, db, "foreign key constraint failed");
61481: return SQLITE_ERROR;
61482: }
61483: return SQLITE_OK;
61484: }
61485: #endif
61486:
61487: /*
61488: ** This routine is called the when a VDBE tries to halt. If the VDBE
61489: ** has made changes and is in autocommit mode, then commit those
61490: ** changes. If a rollback is needed, then do the rollback.
61491: **
61492: ** This routine is the only way to move the state of a VM from
61493: ** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. It is harmless to
61494: ** call this on a VM that is in the SQLITE_MAGIC_HALT state.
61495: **
61496: ** Return an error code. If the commit could not complete because of
61497: ** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it
61498: ** means the close did not happen and needs to be repeated.
61499: */
61500: SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
61501: int rc; /* Used to store transient return codes */
61502: sqlite3 *db = p->db;
61503:
61504: /* This function contains the logic that determines if a statement or
61505: ** transaction will be committed or rolled back as a result of the
61506: ** execution of this virtual machine.
61507: **
61508: ** If any of the following errors occur:
61509: **
61510: ** SQLITE_NOMEM
61511: ** SQLITE_IOERR
61512: ** SQLITE_FULL
61513: ** SQLITE_INTERRUPT
61514: **
61515: ** Then the internal cache might have been left in an inconsistent
61516: ** state. We need to rollback the statement transaction, if there is
61517: ** one, or the complete transaction if there is no statement transaction.
61518: */
61519:
61520: if( p->db->mallocFailed ){
61521: p->rc = SQLITE_NOMEM;
61522: }
61523: if( p->aOnceFlag ) memset(p->aOnceFlag, 0, p->nOnceFlag);
61524: closeAllCursors(p);
61525: if( p->magic!=VDBE_MAGIC_RUN ){
61526: return SQLITE_OK;
61527: }
61528: checkActiveVdbeCnt(db);
61529:
61530: /* No commit or rollback needed if the program never started */
61531: if( p->pc>=0 ){
61532: int mrc; /* Primary error code from p->rc */
61533: int eStatementOp = 0;
61534: int isSpecialError; /* Set to true if a 'special' error */
61535:
61536: /* Lock all btrees used by the statement */
61537: sqlite3VdbeEnter(p);
61538:
61539: /* Check for one of the special errors */
61540: mrc = p->rc & 0xff;
61541: assert( p->rc!=SQLITE_IOERR_BLOCKED ); /* This error no longer exists */
61542: isSpecialError = mrc==SQLITE_NOMEM || mrc==SQLITE_IOERR
61543: || mrc==SQLITE_INTERRUPT || mrc==SQLITE_FULL;
61544: if( isSpecialError ){
61545: /* If the query was read-only and the error code is SQLITE_INTERRUPT,
61546: ** no rollback is necessary. Otherwise, at least a savepoint
61547: ** transaction must be rolled back to restore the database to a
61548: ** consistent state.
61549: **
61550: ** Even if the statement is read-only, it is important to perform
61551: ** a statement or transaction rollback operation. If the error
61552: ** occured while writing to the journal, sub-journal or database
61553: ** file as part of an effort to free up cache space (see function
61554: ** pagerStress() in pager.c), the rollback is required to restore
61555: ** the pager to a consistent state.
61556: */
61557: if( !p->readOnly || mrc!=SQLITE_INTERRUPT ){
61558: if( (mrc==SQLITE_NOMEM || mrc==SQLITE_FULL) && p->usesStmtJournal ){
61559: eStatementOp = SAVEPOINT_ROLLBACK;
61560: }else{
61561: /* We are forced to roll back the active transaction. Before doing
61562: ** so, abort any other statements this handle currently has active.
61563: */
61564: invalidateCursorsOnModifiedBtrees(db);
61565: sqlite3RollbackAll(db);
61566: sqlite3CloseSavepoints(db);
61567: db->autoCommit = 1;
61568: }
61569: }
61570: }
61571:
61572: /* Check for immediate foreign key violations. */
61573: if( p->rc==SQLITE_OK ){
61574: sqlite3VdbeCheckFk(p, 0);
61575: }
61576:
61577: /* If the auto-commit flag is set and this is the only active writer
61578: ** VM, then we do either a commit or rollback of the current transaction.
61579: **
61580: ** Note: This block also runs if one of the special errors handled
61581: ** above has occurred.
61582: */
61583: if( !sqlite3VtabInSync(db)
61584: && db->autoCommit
61585: && db->writeVdbeCnt==(p->readOnly==0)
61586: ){
61587: if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
61588: rc = sqlite3VdbeCheckFk(p, 1);
61589: if( rc!=SQLITE_OK ){
61590: if( NEVER(p->readOnly) ){
61591: sqlite3VdbeLeave(p);
61592: return SQLITE_ERROR;
61593: }
61594: rc = SQLITE_CONSTRAINT;
61595: }else{
61596: /* The auto-commit flag is true, the vdbe program was successful
61597: ** or hit an 'OR FAIL' constraint and there are no deferred foreign
61598: ** key constraints to hold up the transaction. This means a commit
61599: ** is required. */
61600: rc = vdbeCommit(db, p);
61601: }
61602: if( rc==SQLITE_BUSY && p->readOnly ){
61603: sqlite3VdbeLeave(p);
61604: return SQLITE_BUSY;
61605: }else if( rc!=SQLITE_OK ){
61606: p->rc = rc;
61607: sqlite3RollbackAll(db);
61608: }else{
61609: db->nDeferredCons = 0;
61610: sqlite3CommitInternalChanges(db);
61611: }
61612: }else{
61613: sqlite3RollbackAll(db);
61614: }
61615: db->nStatement = 0;
61616: }else if( eStatementOp==0 ){
61617: if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){
61618: eStatementOp = SAVEPOINT_RELEASE;
61619: }else if( p->errorAction==OE_Abort ){
61620: eStatementOp = SAVEPOINT_ROLLBACK;
61621: }else{
61622: invalidateCursorsOnModifiedBtrees(db);
61623: sqlite3RollbackAll(db);
61624: sqlite3CloseSavepoints(db);
61625: db->autoCommit = 1;
61626: }
61627: }
61628:
61629: /* If eStatementOp is non-zero, then a statement transaction needs to
61630: ** be committed or rolled back. Call sqlite3VdbeCloseStatement() to
61631: ** do so. If this operation returns an error, and the current statement
61632: ** error code is SQLITE_OK or SQLITE_CONSTRAINT, then promote the
61633: ** current statement error code.
61634: */
61635: if( eStatementOp ){
61636: rc = sqlite3VdbeCloseStatement(p, eStatementOp);
61637: if( rc ){
61638: if( p->rc==SQLITE_OK || p->rc==SQLITE_CONSTRAINT ){
61639: p->rc = rc;
61640: sqlite3DbFree(db, p->zErrMsg);
61641: p->zErrMsg = 0;
61642: }
61643: invalidateCursorsOnModifiedBtrees(db);
61644: sqlite3RollbackAll(db);
61645: sqlite3CloseSavepoints(db);
61646: db->autoCommit = 1;
61647: }
61648: }
61649:
61650: /* If this was an INSERT, UPDATE or DELETE and no statement transaction
61651: ** has been rolled back, update the database connection change-counter.
61652: */
61653: if( p->changeCntOn ){
61654: if( eStatementOp!=SAVEPOINT_ROLLBACK ){
61655: sqlite3VdbeSetChanges(db, p->nChange);
61656: }else{
61657: sqlite3VdbeSetChanges(db, 0);
61658: }
61659: p->nChange = 0;
61660: }
61661:
61662: /* Rollback or commit any schema changes that occurred. */
61663: if( p->rc!=SQLITE_OK && db->flags&SQLITE_InternChanges ){
61664: sqlite3ResetInternalSchema(db, -1);
61665: db->flags = (db->flags | SQLITE_InternChanges);
61666: }
61667:
61668: /* Release the locks */
61669: sqlite3VdbeLeave(p);
61670: }
61671:
61672: /* We have successfully halted and closed the VM. Record this fact. */
61673: if( p->pc>=0 ){
61674: db->activeVdbeCnt--;
61675: if( !p->readOnly ){
61676: db->writeVdbeCnt--;
61677: }
61678: assert( db->activeVdbeCnt>=db->writeVdbeCnt );
61679: }
61680: p->magic = VDBE_MAGIC_HALT;
61681: checkActiveVdbeCnt(db);
61682: if( p->db->mallocFailed ){
61683: p->rc = SQLITE_NOMEM;
61684: }
61685:
61686: /* If the auto-commit flag is set to true, then any locks that were held
61687: ** by connection db have now been released. Call sqlite3ConnectionUnlocked()
61688: ** to invoke any required unlock-notify callbacks.
61689: */
61690: if( db->autoCommit ){
61691: sqlite3ConnectionUnlocked(db);
61692: }
61693:
61694: assert( db->activeVdbeCnt>0 || db->autoCommit==0 || db->nStatement==0 );
61695: return (p->rc==SQLITE_BUSY ? SQLITE_BUSY : SQLITE_OK);
61696: }
61697:
61698:
61699: /*
61700: ** Each VDBE holds the result of the most recent sqlite3_step() call
61701: ** in p->rc. This routine sets that result back to SQLITE_OK.
61702: */
61703: SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe *p){
61704: p->rc = SQLITE_OK;
61705: }
61706:
61707: /*
61708: ** Copy the error code and error message belonging to the VDBE passed
61709: ** as the first argument to its database handle (so that they will be
61710: ** returned by calls to sqlite3_errcode() and sqlite3_errmsg()).
61711: **
61712: ** This function does not clear the VDBE error code or message, just
61713: ** copies them to the database handle.
61714: */
61715: SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){
61716: sqlite3 *db = p->db;
61717: int rc = p->rc;
61718: if( p->zErrMsg ){
61719: u8 mallocFailed = db->mallocFailed;
61720: sqlite3BeginBenignMalloc();
61721: sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
61722: sqlite3EndBenignMalloc();
61723: db->mallocFailed = mallocFailed;
61724: db->errCode = rc;
61725: }else{
61726: sqlite3Error(db, rc, 0);
61727: }
61728: return rc;
61729: }
61730:
61731: /*
61732: ** Clean up a VDBE after execution but do not delete the VDBE just yet.
61733: ** Write any error messages into *pzErrMsg. Return the result code.
61734: **
61735: ** After this routine is run, the VDBE should be ready to be executed
61736: ** again.
61737: **
61738: ** To look at it another way, this routine resets the state of the
61739: ** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to
61740: ** VDBE_MAGIC_INIT.
61741: */
61742: SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){
61743: sqlite3 *db;
61744: db = p->db;
61745:
61746: /* If the VM did not run to completion or if it encountered an
61747: ** error, then it might not have been halted properly. So halt
61748: ** it now.
61749: */
61750: sqlite3VdbeHalt(p);
61751:
61752: /* If the VDBE has be run even partially, then transfer the error code
61753: ** and error message from the VDBE into the main database structure. But
61754: ** if the VDBE has just been set to run but has not actually executed any
61755: ** instructions yet, leave the main database error information unchanged.
61756: */
61757: if( p->pc>=0 ){
61758: sqlite3VdbeTransferError(p);
61759: sqlite3DbFree(db, p->zErrMsg);
61760: p->zErrMsg = 0;
61761: if( p->runOnlyOnce ) p->expired = 1;
61762: }else if( p->rc && p->expired ){
61763: /* The expired flag was set on the VDBE before the first call
61764: ** to sqlite3_step(). For consistency (since sqlite3_step() was
61765: ** called), set the database error in this case as well.
61766: */
61767: sqlite3Error(db, p->rc, 0);
61768: sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
61769: sqlite3DbFree(db, p->zErrMsg);
61770: p->zErrMsg = 0;
61771: }
61772:
61773: /* Reclaim all memory used by the VDBE
61774: */
61775: Cleanup(p);
61776:
61777: /* Save profiling information from this VDBE run.
61778: */
61779: #ifdef VDBE_PROFILE
61780: {
61781: FILE *out = fopen("vdbe_profile.out", "a");
61782: if( out ){
61783: int i;
61784: fprintf(out, "---- ");
61785: for(i=0; i<p->nOp; i++){
61786: fprintf(out, "%02x", p->aOp[i].opcode);
61787: }
61788: fprintf(out, "\n");
61789: for(i=0; i<p->nOp; i++){
61790: fprintf(out, "%6d %10lld %8lld ",
61791: p->aOp[i].cnt,
61792: p->aOp[i].cycles,
61793: p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
61794: );
61795: sqlite3VdbePrintOp(out, i, &p->aOp[i]);
61796: }
61797: fclose(out);
61798: }
61799: }
61800: #endif
61801: p->magic = VDBE_MAGIC_INIT;
61802: return p->rc & db->errMask;
61803: }
61804:
61805: /*
61806: ** Clean up and delete a VDBE after execution. Return an integer which is
61807: ** the result code. Write any error message text into *pzErrMsg.
61808: */
61809: SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe *p){
61810: int rc = SQLITE_OK;
61811: if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){
61812: rc = sqlite3VdbeReset(p);
61813: assert( (rc & p->db->errMask)==rc );
61814: }
61815: sqlite3VdbeDelete(p);
61816: return rc;
61817: }
61818:
61819: /*
61820: ** Call the destructor for each auxdata entry in pVdbeFunc for which
61821: ** the corresponding bit in mask is clear. Auxdata entries beyond 31
61822: ** are always destroyed. To destroy all auxdata entries, call this
61823: ** routine with mask==0.
61824: */
61825: SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(VdbeFunc *pVdbeFunc, int mask){
61826: int i;
61827: for(i=0; i<pVdbeFunc->nAux; i++){
61828: struct AuxData *pAux = &pVdbeFunc->apAux[i];
61829: if( (i>31 || !(mask&(((u32)1)<<i))) && pAux->pAux ){
61830: if( pAux->xDelete ){
61831: pAux->xDelete(pAux->pAux);
61832: }
61833: pAux->pAux = 0;
61834: }
61835: }
61836: }
61837:
61838: /*
61839: ** Free all memory associated with the Vdbe passed as the second argument.
61840: ** The difference between this function and sqlite3VdbeDelete() is that
61841: ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
61842: ** the database connection.
61843: */
61844: SQLITE_PRIVATE void sqlite3VdbeDeleteObject(sqlite3 *db, Vdbe *p){
61845: SubProgram *pSub, *pNext;
61846: int i;
61847: assert( p->db==0 || p->db==db );
61848: releaseMemArray(p->aVar, p->nVar);
61849: releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
61850: for(pSub=p->pProgram; pSub; pSub=pNext){
61851: pNext = pSub->pNext;
61852: vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
61853: sqlite3DbFree(db, pSub);
61854: }
61855: for(i=p->nzVar-1; i>=0; i--) sqlite3DbFree(db, p->azVar[i]);
61856: vdbeFreeOpArray(db, p->aOp, p->nOp);
61857: sqlite3DbFree(db, p->aLabel);
61858: sqlite3DbFree(db, p->aColName);
61859: sqlite3DbFree(db, p->zSql);
61860: sqlite3DbFree(db, p->pFree);
61861: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
61862: sqlite3DbFree(db, p->zExplain);
61863: sqlite3DbFree(db, p->pExplain);
61864: #endif
61865: sqlite3DbFree(db, p);
61866: }
61867:
61868: /*
61869: ** Delete an entire VDBE.
61870: */
61871: SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){
61872: sqlite3 *db;
61873:
61874: if( NEVER(p==0) ) return;
61875: db = p->db;
61876: if( p->pPrev ){
61877: p->pPrev->pNext = p->pNext;
61878: }else{
61879: assert( db->pVdbe==p );
61880: db->pVdbe = p->pNext;
61881: }
61882: if( p->pNext ){
61883: p->pNext->pPrev = p->pPrev;
61884: }
61885: p->magic = VDBE_MAGIC_DEAD;
61886: p->db = 0;
61887: sqlite3VdbeDeleteObject(db, p);
61888: }
61889:
61890: /*
61891: ** Make sure the cursor p is ready to read or write the row to which it
61892: ** was last positioned. Return an error code if an OOM fault or I/O error
61893: ** prevents us from positioning the cursor to its correct position.
61894: **
61895: ** If a MoveTo operation is pending on the given cursor, then do that
61896: ** MoveTo now. If no move is pending, check to see if the row has been
61897: ** deleted out from under the cursor and if it has, mark the row as
61898: ** a NULL row.
61899: **
61900: ** If the cursor is already pointing to the correct row and that row has
61901: ** not been deleted out from under the cursor, then this routine is a no-op.
61902: */
61903: SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor *p){
61904: if( p->deferredMoveto ){
61905: int res, rc;
61906: #ifdef SQLITE_TEST
61907: extern int sqlite3_search_count;
61908: #endif
61909: assert( p->isTable );
61910: rc = sqlite3BtreeMovetoUnpacked(p->pCursor, 0, p->movetoTarget, 0, &res);
61911: if( rc ) return rc;
61912: p->lastRowid = p->movetoTarget;
61913: if( res!=0 ) return SQLITE_CORRUPT_BKPT;
61914: p->rowidIsValid = 1;
61915: #ifdef SQLITE_TEST
61916: sqlite3_search_count++;
61917: #endif
61918: p->deferredMoveto = 0;
61919: p->cacheStatus = CACHE_STALE;
61920: }else if( ALWAYS(p->pCursor) ){
61921: int hasMoved;
61922: int rc = sqlite3BtreeCursorHasMoved(p->pCursor, &hasMoved);
61923: if( rc ) return rc;
61924: if( hasMoved ){
61925: p->cacheStatus = CACHE_STALE;
61926: p->nullRow = 1;
61927: }
61928: }
61929: return SQLITE_OK;
61930: }
61931:
61932: /*
61933: ** The following functions:
61934: **
61935: ** sqlite3VdbeSerialType()
61936: ** sqlite3VdbeSerialTypeLen()
61937: ** sqlite3VdbeSerialLen()
61938: ** sqlite3VdbeSerialPut()
61939: ** sqlite3VdbeSerialGet()
61940: **
61941: ** encapsulate the code that serializes values for storage in SQLite
61942: ** data and index records. Each serialized value consists of a
61943: ** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned
61944: ** integer, stored as a varint.
61945: **
61946: ** In an SQLite index record, the serial type is stored directly before
61947: ** the blob of data that it corresponds to. In a table record, all serial
61948: ** types are stored at the start of the record, and the blobs of data at
61949: ** the end. Hence these functions allow the caller to handle the
61950: ** serial-type and data blob seperately.
61951: **
61952: ** The following table describes the various storage classes for data:
61953: **
61954: ** serial type bytes of data type
61955: ** -------------- --------------- ---------------
61956: ** 0 0 NULL
61957: ** 1 1 signed integer
61958: ** 2 2 signed integer
61959: ** 3 3 signed integer
61960: ** 4 4 signed integer
61961: ** 5 6 signed integer
61962: ** 6 8 signed integer
61963: ** 7 8 IEEE float
61964: ** 8 0 Integer constant 0
61965: ** 9 0 Integer constant 1
61966: ** 10,11 reserved for expansion
61967: ** N>=12 and even (N-12)/2 BLOB
61968: ** N>=13 and odd (N-13)/2 text
61969: **
61970: ** The 8 and 9 types were added in 3.3.0, file format 4. Prior versions
61971: ** of SQLite will not understand those serial types.
61972: */
61973:
61974: /*
61975: ** Return the serial-type for the value stored in pMem.
61976: */
61977: SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
61978: int flags = pMem->flags;
61979: int n;
61980:
61981: if( flags&MEM_Null ){
61982: return 0;
61983: }
61984: if( flags&MEM_Int ){
61985: /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
61986: # define MAX_6BYTE ((((i64)0x00008000)<<32)-1)
61987: i64 i = pMem->u.i;
61988: u64 u;
61989: if( file_format>=4 && (i&1)==i ){
61990: return 8+(u32)i;
61991: }
61992: if( i<0 ){
61993: if( i<(-MAX_6BYTE) ) return 6;
61994: /* Previous test prevents: u = -(-9223372036854775808) */
61995: u = -i;
61996: }else{
61997: u = i;
61998: }
61999: if( u<=127 ) return 1;
62000: if( u<=32767 ) return 2;
62001: if( u<=8388607 ) return 3;
62002: if( u<=2147483647 ) return 4;
62003: if( u<=MAX_6BYTE ) return 5;
62004: return 6;
62005: }
62006: if( flags&MEM_Real ){
62007: return 7;
62008: }
62009: assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
62010: n = pMem->n;
62011: if( flags & MEM_Zero ){
62012: n += pMem->u.nZero;
62013: }
62014: assert( n>=0 );
62015: return ((n*2) + 12 + ((flags&MEM_Str)!=0));
62016: }
62017:
62018: /*
62019: ** Return the length of the data corresponding to the supplied serial-type.
62020: */
62021: SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32 serial_type){
62022: if( serial_type>=12 ){
62023: return (serial_type-12)/2;
62024: }else{
62025: static const u8 aSize[] = { 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0 };
62026: return aSize[serial_type];
62027: }
62028: }
62029:
62030: /*
62031: ** If we are on an architecture with mixed-endian floating
62032: ** points (ex: ARM7) then swap the lower 4 bytes with the
62033: ** upper 4 bytes. Return the result.
62034: **
62035: ** For most architectures, this is a no-op.
62036: **
62037: ** (later): It is reported to me that the mixed-endian problem
62038: ** on ARM7 is an issue with GCC, not with the ARM7 chip. It seems
62039: ** that early versions of GCC stored the two words of a 64-bit
62040: ** float in the wrong order. And that error has been propagated
62041: ** ever since. The blame is not necessarily with GCC, though.
62042: ** GCC might have just copying the problem from a prior compiler.
62043: ** I am also told that newer versions of GCC that follow a different
62044: ** ABI get the byte order right.
62045: **
62046: ** Developers using SQLite on an ARM7 should compile and run their
62047: ** application using -DSQLITE_DEBUG=1 at least once. With DEBUG
62048: ** enabled, some asserts below will ensure that the byte order of
62049: ** floating point values is correct.
62050: **
62051: ** (2007-08-30) Frank van Vugt has studied this problem closely
62052: ** and has send his findings to the SQLite developers. Frank
62053: ** writes that some Linux kernels offer floating point hardware
62054: ** emulation that uses only 32-bit mantissas instead of a full
62055: ** 48-bits as required by the IEEE standard. (This is the
62056: ** CONFIG_FPE_FASTFPE option.) On such systems, floating point
62057: ** byte swapping becomes very complicated. To avoid problems,
62058: ** the necessary byte swapping is carried out using a 64-bit integer
62059: ** rather than a 64-bit float. Frank assures us that the code here
62060: ** works for him. We, the developers, have no way to independently
62061: ** verify this, but Frank seems to know what he is talking about
62062: ** so we trust him.
62063: */
62064: #ifdef SQLITE_MIXED_ENDIAN_64BIT_FLOAT
62065: static u64 floatSwap(u64 in){
62066: union {
62067: u64 r;
62068: u32 i[2];
62069: } u;
62070: u32 t;
62071:
62072: u.r = in;
62073: t = u.i[0];
62074: u.i[0] = u.i[1];
62075: u.i[1] = t;
62076: return u.r;
62077: }
62078: # define swapMixedEndianFloat(X) X = floatSwap(X)
62079: #else
62080: # define swapMixedEndianFloat(X)
62081: #endif
62082:
62083: /*
62084: ** Write the serialized data blob for the value stored in pMem into
62085: ** buf. It is assumed that the caller has allocated sufficient space.
62086: ** Return the number of bytes written.
62087: **
62088: ** nBuf is the amount of space left in buf[]. nBuf must always be
62089: ** large enough to hold the entire field. Except, if the field is
62090: ** a blob with a zero-filled tail, then buf[] might be just the right
62091: ** size to hold everything except for the zero-filled tail. If buf[]
62092: ** is only big enough to hold the non-zero prefix, then only write that
62093: ** prefix into buf[]. But if buf[] is large enough to hold both the
62094: ** prefix and the tail then write the prefix and set the tail to all
62095: ** zeros.
62096: **
62097: ** Return the number of bytes actually written into buf[]. The number
62098: ** of bytes in the zero-filled tail is included in the return value only
62099: ** if those bytes were zeroed in buf[].
62100: */
62101: SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
62102: u32 serial_type = sqlite3VdbeSerialType(pMem, file_format);
62103: u32 len;
62104:
62105: /* Integer and Real */
62106: if( serial_type<=7 && serial_type>0 ){
62107: u64 v;
62108: u32 i;
62109: if( serial_type==7 ){
62110: assert( sizeof(v)==sizeof(pMem->r) );
62111: memcpy(&v, &pMem->r, sizeof(v));
62112: swapMixedEndianFloat(v);
62113: }else{
62114: v = pMem->u.i;
62115: }
62116: len = i = sqlite3VdbeSerialTypeLen(serial_type);
62117: assert( len<=(u32)nBuf );
62118: while( i-- ){
62119: buf[i] = (u8)(v&0xFF);
62120: v >>= 8;
62121: }
62122: return len;
62123: }
62124:
62125: /* String or blob */
62126: if( serial_type>=12 ){
62127: assert( pMem->n + ((pMem->flags & MEM_Zero)?pMem->u.nZero:0)
62128: == (int)sqlite3VdbeSerialTypeLen(serial_type) );
62129: assert( pMem->n<=nBuf );
62130: len = pMem->n;
62131: memcpy(buf, pMem->z, len);
62132: if( pMem->flags & MEM_Zero ){
62133: len += pMem->u.nZero;
62134: assert( nBuf>=0 );
62135: if( len > (u32)nBuf ){
62136: len = (u32)nBuf;
62137: }
62138: memset(&buf[pMem->n], 0, len-pMem->n);
62139: }
62140: return len;
62141: }
62142:
62143: /* NULL or constants 0 or 1 */
62144: return 0;
62145: }
62146:
62147: /*
62148: ** Deserialize the data blob pointed to by buf as serial type serial_type
62149: ** and store the result in pMem. Return the number of bytes read.
62150: */
62151: SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(
62152: const unsigned char *buf, /* Buffer to deserialize from */
62153: u32 serial_type, /* Serial type to deserialize */
62154: Mem *pMem /* Memory cell to write value into */
62155: ){
62156: switch( serial_type ){
62157: case 10: /* Reserved for future use */
62158: case 11: /* Reserved for future use */
62159: case 0: { /* NULL */
62160: pMem->flags = MEM_Null;
62161: break;
62162: }
62163: case 1: { /* 1-byte signed integer */
62164: pMem->u.i = (signed char)buf[0];
62165: pMem->flags = MEM_Int;
62166: return 1;
62167: }
62168: case 2: { /* 2-byte signed integer */
62169: pMem->u.i = (((signed char)buf[0])<<8) | buf[1];
62170: pMem->flags = MEM_Int;
62171: return 2;
62172: }
62173: case 3: { /* 3-byte signed integer */
62174: pMem->u.i = (((signed char)buf[0])<<16) | (buf[1]<<8) | buf[2];
62175: pMem->flags = MEM_Int;
62176: return 3;
62177: }
62178: case 4: { /* 4-byte signed integer */
62179: pMem->u.i = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
62180: pMem->flags = MEM_Int;
62181: return 4;
62182: }
62183: case 5: { /* 6-byte signed integer */
62184: u64 x = (((signed char)buf[0])<<8) | buf[1];
62185: u32 y = (buf[2]<<24) | (buf[3]<<16) | (buf[4]<<8) | buf[5];
62186: x = (x<<32) | y;
62187: pMem->u.i = *(i64*)&x;
62188: pMem->flags = MEM_Int;
62189: return 6;
62190: }
62191: case 6: /* 8-byte signed integer */
62192: case 7: { /* IEEE floating point */
62193: u64 x;
62194: u32 y;
62195: #if !defined(NDEBUG) && !defined(SQLITE_OMIT_FLOATING_POINT)
62196: /* Verify that integers and floating point values use the same
62197: ** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is
62198: ** defined that 64-bit floating point values really are mixed
62199: ** endian.
62200: */
62201: static const u64 t1 = ((u64)0x3ff00000)<<32;
62202: static const double r1 = 1.0;
62203: u64 t2 = t1;
62204: swapMixedEndianFloat(t2);
62205: assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, &t2, sizeof(r1))==0 );
62206: #endif
62207:
62208: x = (buf[0]<<24) | (buf[1]<<16) | (buf[2]<<8) | buf[3];
62209: y = (buf[4]<<24) | (buf[5]<<16) | (buf[6]<<8) | buf[7];
62210: x = (x<<32) | y;
62211: if( serial_type==6 ){
62212: pMem->u.i = *(i64*)&x;
62213: pMem->flags = MEM_Int;
62214: }else{
62215: assert( sizeof(x)==8 && sizeof(pMem->r)==8 );
62216: swapMixedEndianFloat(x);
62217: memcpy(&pMem->r, &x, sizeof(x));
62218: pMem->flags = sqlite3IsNaN(pMem->r) ? MEM_Null : MEM_Real;
62219: }
62220: return 8;
62221: }
62222: case 8: /* Integer 0 */
62223: case 9: { /* Integer 1 */
62224: pMem->u.i = serial_type-8;
62225: pMem->flags = MEM_Int;
62226: return 0;
62227: }
62228: default: {
62229: u32 len = (serial_type-12)/2;
62230: pMem->z = (char *)buf;
62231: pMem->n = len;
62232: pMem->xDel = 0;
62233: if( serial_type&0x01 ){
62234: pMem->flags = MEM_Str | MEM_Ephem;
62235: }else{
62236: pMem->flags = MEM_Blob | MEM_Ephem;
62237: }
62238: return len;
62239: }
62240: }
62241: return 0;
62242: }
62243:
62244: /*
62245: ** This routine is used to allocate sufficient space for an UnpackedRecord
62246: ** structure large enough to be used with sqlite3VdbeRecordUnpack() if
62247: ** the first argument is a pointer to KeyInfo structure pKeyInfo.
62248: **
62249: ** The space is either allocated using sqlite3DbMallocRaw() or from within
62250: ** the unaligned buffer passed via the second and third arguments (presumably
62251: ** stack space). If the former, then *ppFree is set to a pointer that should
62252: ** be eventually freed by the caller using sqlite3DbFree(). Or, if the
62253: ** allocation comes from the pSpace/szSpace buffer, *ppFree is set to NULL
62254: ** before returning.
62255: **
62256: ** If an OOM error occurs, NULL is returned.
62257: */
62258: SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(
62259: KeyInfo *pKeyInfo, /* Description of the record */
62260: char *pSpace, /* Unaligned space available */
62261: int szSpace, /* Size of pSpace[] in bytes */
62262: char **ppFree /* OUT: Caller should free this pointer */
62263: ){
62264: UnpackedRecord *p; /* Unpacked record to return */
62265: int nOff; /* Increment pSpace by nOff to align it */
62266: int nByte; /* Number of bytes required for *p */
62267:
62268: /* We want to shift the pointer pSpace up such that it is 8-byte aligned.
62269: ** Thus, we need to calculate a value, nOff, between 0 and 7, to shift
62270: ** it by. If pSpace is already 8-byte aligned, nOff should be zero.
62271: */
62272: nOff = (8 - (SQLITE_PTR_TO_INT(pSpace) & 7)) & 7;
62273: nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
62274: if( nByte>szSpace+nOff ){
62275: p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
62276: *ppFree = (char *)p;
62277: if( !p ) return 0;
62278: }else{
62279: p = (UnpackedRecord*)&pSpace[nOff];
62280: *ppFree = 0;
62281: }
62282:
62283: p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
62284: p->pKeyInfo = pKeyInfo;
62285: p->nField = pKeyInfo->nField + 1;
62286: return p;
62287: }
62288:
62289: /*
62290: ** Given the nKey-byte encoding of a record in pKey[], populate the
62291: ** UnpackedRecord structure indicated by the fourth argument with the
62292: ** contents of the decoded record.
62293: */
62294: SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(
62295: KeyInfo *pKeyInfo, /* Information about the record format */
62296: int nKey, /* Size of the binary record */
62297: const void *pKey, /* The binary record */
62298: UnpackedRecord *p /* Populate this structure before returning. */
62299: ){
62300: const unsigned char *aKey = (const unsigned char *)pKey;
62301: int d;
62302: u32 idx; /* Offset in aKey[] to read from */
62303: u16 u; /* Unsigned loop counter */
62304: u32 szHdr;
62305: Mem *pMem = p->aMem;
62306:
62307: p->flags = 0;
62308: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
62309: idx = getVarint32(aKey, szHdr);
62310: d = szHdr;
62311: u = 0;
62312: while( idx<szHdr && u<p->nField && d<=nKey ){
62313: u32 serial_type;
62314:
62315: idx += getVarint32(&aKey[idx], serial_type);
62316: pMem->enc = pKeyInfo->enc;
62317: pMem->db = pKeyInfo->db;
62318: /* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */
62319: pMem->zMalloc = 0;
62320: d += sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem);
62321: pMem++;
62322: u++;
62323: }
62324: assert( u<=pKeyInfo->nField + 1 );
62325: p->nField = u;
62326: }
62327:
62328: /*
62329: ** This function compares the two table rows or index records
62330: ** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero
62331: ** or positive integer if key1 is less than, equal to or
62332: ** greater than key2. The {nKey1, pKey1} key must be a blob
62333: ** created by th OP_MakeRecord opcode of the VDBE. The pPKey2
62334: ** key must be a parsed key such as obtained from
62335: ** sqlite3VdbeParseRecord.
62336: **
62337: ** Key1 and Key2 do not have to contain the same number of fields.
62338: ** The key with fewer fields is usually compares less than the
62339: ** longer key. However if the UNPACKED_INCRKEY flags in pPKey2 is set
62340: ** and the common prefixes are equal, then key1 is less than key2.
62341: ** Or if the UNPACKED_MATCH_PREFIX flag is set and the prefixes are
62342: ** equal, then the keys are considered to be equal and
62343: ** the parts beyond the common prefix are ignored.
62344: */
62345: SQLITE_PRIVATE int sqlite3VdbeRecordCompare(
62346: int nKey1, const void *pKey1, /* Left key */
62347: UnpackedRecord *pPKey2 /* Right key */
62348: ){
62349: int d1; /* Offset into aKey[] of next data element */
62350: u32 idx1; /* Offset into aKey[] of next header element */
62351: u32 szHdr1; /* Number of bytes in header */
62352: int i = 0;
62353: int nField;
62354: int rc = 0;
62355: const unsigned char *aKey1 = (const unsigned char *)pKey1;
62356: KeyInfo *pKeyInfo;
62357: Mem mem1;
62358:
62359: pKeyInfo = pPKey2->pKeyInfo;
62360: mem1.enc = pKeyInfo->enc;
62361: mem1.db = pKeyInfo->db;
62362: /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */
62363: VVA_ONLY( mem1.zMalloc = 0; ) /* Only needed by assert() statements */
62364:
62365: /* Compilers may complain that mem1.u.i is potentially uninitialized.
62366: ** We could initialize it, as shown here, to silence those complaints.
62367: ** But in fact, mem1.u.i will never actually be used uninitialized, and doing
62368: ** the unnecessary initialization has a measurable negative performance
62369: ** impact, since this routine is a very high runner. And so, we choose
62370: ** to ignore the compiler warnings and leave this variable uninitialized.
62371: */
62372: /* mem1.u.i = 0; // not needed, here to silence compiler warning */
62373:
62374: idx1 = getVarint32(aKey1, szHdr1);
62375: d1 = szHdr1;
62376: nField = pKeyInfo->nField;
62377: while( idx1<szHdr1 && i<pPKey2->nField ){
62378: u32 serial_type1;
62379:
62380: /* Read the serial types for the next element in each key. */
62381: idx1 += getVarint32( aKey1+idx1, serial_type1 );
62382: if( d1>=nKey1 && sqlite3VdbeSerialTypeLen(serial_type1)>0 ) break;
62383:
62384: /* Extract the values to be compared.
62385: */
62386: d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1);
62387:
62388: /* Do the comparison
62389: */
62390: rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i],
62391: i<nField ? pKeyInfo->aColl[i] : 0);
62392: if( rc!=0 ){
62393: assert( mem1.zMalloc==0 ); /* See comment below */
62394:
62395: /* Invert the result if we are using DESC sort order. */
62396: if( pKeyInfo->aSortOrder && i<nField && pKeyInfo->aSortOrder[i] ){
62397: rc = -rc;
62398: }
62399:
62400: /* If the PREFIX_SEARCH flag is set and all fields except the final
62401: ** rowid field were equal, then clear the PREFIX_SEARCH flag and set
62402: ** pPKey2->rowid to the value of the rowid field in (pKey1, nKey1).
62403: ** This is used by the OP_IsUnique opcode.
62404: */
62405: if( (pPKey2->flags & UNPACKED_PREFIX_SEARCH) && i==(pPKey2->nField-1) ){
62406: assert( idx1==szHdr1 && rc );
62407: assert( mem1.flags & MEM_Int );
62408: pPKey2->flags &= ~UNPACKED_PREFIX_SEARCH;
62409: pPKey2->rowid = mem1.u.i;
62410: }
62411:
62412: return rc;
62413: }
62414: i++;
62415: }
62416:
62417: /* No memory allocation is ever used on mem1. Prove this using
62418: ** the following assert(). If the assert() fails, it indicates a
62419: ** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).
62420: */
62421: assert( mem1.zMalloc==0 );
62422:
62423: /* rc==0 here means that one of the keys ran out of fields and
62424: ** all the fields up to that point were equal. If the UNPACKED_INCRKEY
62425: ** flag is set, then break the tie by treating key2 as larger.
62426: ** If the UPACKED_PREFIX_MATCH flag is set, then keys with common prefixes
62427: ** are considered to be equal. Otherwise, the longer key is the
62428: ** larger. As it happens, the pPKey2 will always be the longer
62429: ** if there is a difference.
62430: */
62431: assert( rc==0 );
62432: if( pPKey2->flags & UNPACKED_INCRKEY ){
62433: rc = -1;
62434: }else if( pPKey2->flags & UNPACKED_PREFIX_MATCH ){
62435: /* Leave rc==0 */
62436: }else if( idx1<szHdr1 ){
62437: rc = 1;
62438: }
62439: return rc;
62440: }
62441:
62442:
62443: /*
62444: ** pCur points at an index entry created using the OP_MakeRecord opcode.
62445: ** Read the rowid (the last field in the record) and store it in *rowid.
62446: ** Return SQLITE_OK if everything works, or an error code otherwise.
62447: **
62448: ** pCur might be pointing to text obtained from a corrupt database file.
62449: ** So the content cannot be trusted. Do appropriate checks on the content.
62450: */
62451: SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
62452: i64 nCellKey = 0;
62453: int rc;
62454: u32 szHdr; /* Size of the header */
62455: u32 typeRowid; /* Serial type of the rowid */
62456: u32 lenRowid; /* Size of the rowid */
62457: Mem m, v;
62458:
62459: UNUSED_PARAMETER(db);
62460:
62461: /* Get the size of the index entry. Only indices entries of less
62462: ** than 2GiB are support - anything large must be database corruption.
62463: ** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so
62464: ** this code can safely assume that nCellKey is 32-bits
62465: */
62466: assert( sqlite3BtreeCursorIsValid(pCur) );
62467: VVA_ONLY(rc =) sqlite3BtreeKeySize(pCur, &nCellKey);
62468: assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
62469: assert( (nCellKey & SQLITE_MAX_U32)==(u64)nCellKey );
62470:
62471: /* Read in the complete content of the index entry */
62472: memset(&m, 0, sizeof(m));
62473: rc = sqlite3VdbeMemFromBtree(pCur, 0, (int)nCellKey, 1, &m);
62474: if( rc ){
62475: return rc;
62476: }
62477:
62478: /* The index entry must begin with a header size */
62479: (void)getVarint32((u8*)m.z, szHdr);
62480: testcase( szHdr==3 );
62481: testcase( szHdr==m.n );
62482: if( unlikely(szHdr<3 || (int)szHdr>m.n) ){
62483: goto idx_rowid_corruption;
62484: }
62485:
62486: /* The last field of the index should be an integer - the ROWID.
62487: ** Verify that the last entry really is an integer. */
62488: (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid);
62489: testcase( typeRowid==1 );
62490: testcase( typeRowid==2 );
62491: testcase( typeRowid==3 );
62492: testcase( typeRowid==4 );
62493: testcase( typeRowid==5 );
62494: testcase( typeRowid==6 );
62495: testcase( typeRowid==8 );
62496: testcase( typeRowid==9 );
62497: if( unlikely(typeRowid<1 || typeRowid>9 || typeRowid==7) ){
62498: goto idx_rowid_corruption;
62499: }
62500: lenRowid = sqlite3VdbeSerialTypeLen(typeRowid);
62501: testcase( (u32)m.n==szHdr+lenRowid );
62502: if( unlikely((u32)m.n<szHdr+lenRowid) ){
62503: goto idx_rowid_corruption;
62504: }
62505:
62506: /* Fetch the integer off the end of the index record */
62507: sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
62508: *rowid = v.u.i;
62509: sqlite3VdbeMemRelease(&m);
62510: return SQLITE_OK;
62511:
62512: /* Jump here if database corruption is detected after m has been
62513: ** allocated. Free the m object and return SQLITE_CORRUPT. */
62514: idx_rowid_corruption:
62515: testcase( m.zMalloc!=0 );
62516: sqlite3VdbeMemRelease(&m);
62517: return SQLITE_CORRUPT_BKPT;
62518: }
62519:
62520: /*
62521: ** Compare the key of the index entry that cursor pC is pointing to against
62522: ** the key string in pUnpacked. Write into *pRes a number
62523: ** that is negative, zero, or positive if pC is less than, equal to,
62524: ** or greater than pUnpacked. Return SQLITE_OK on success.
62525: **
62526: ** pUnpacked is either created without a rowid or is truncated so that it
62527: ** omits the rowid at the end. The rowid at the end of the index entry
62528: ** is ignored as well. Hence, this routine only compares the prefixes
62529: ** of the keys prior to the final rowid, not the entire key.
62530: */
62531: SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(
62532: VdbeCursor *pC, /* The cursor to compare against */
62533: UnpackedRecord *pUnpacked, /* Unpacked version of key to compare against */
62534: int *res /* Write the comparison result here */
62535: ){
62536: i64 nCellKey = 0;
62537: int rc;
62538: BtCursor *pCur = pC->pCursor;
62539: Mem m;
62540:
62541: assert( sqlite3BtreeCursorIsValid(pCur) );
62542: VVA_ONLY(rc =) sqlite3BtreeKeySize(pCur, &nCellKey);
62543: assert( rc==SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */
62544: /* nCellKey will always be between 0 and 0xffffffff because of the say
62545: ** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
62546: if( nCellKey<=0 || nCellKey>0x7fffffff ){
62547: *res = 0;
62548: return SQLITE_CORRUPT_BKPT;
62549: }
62550: memset(&m, 0, sizeof(m));
62551: rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (int)nCellKey, 1, &m);
62552: if( rc ){
62553: return rc;
62554: }
62555: assert( pUnpacked->flags & UNPACKED_PREFIX_MATCH );
62556: *res = sqlite3VdbeRecordCompare(m.n, m.z, pUnpacked);
62557: sqlite3VdbeMemRelease(&m);
62558: return SQLITE_OK;
62559: }
62560:
62561: /*
62562: ** This routine sets the value to be returned by subsequent calls to
62563: ** sqlite3_changes() on the database handle 'db'.
62564: */
62565: SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){
62566: assert( sqlite3_mutex_held(db->mutex) );
62567: db->nChange = nChange;
62568: db->nTotalChange += nChange;
62569: }
62570:
62571: /*
62572: ** Set a flag in the vdbe to update the change counter when it is finalised
62573: ** or reset.
62574: */
62575: SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){
62576: v->changeCntOn = 1;
62577: }
62578:
62579: /*
62580: ** Mark every prepared statement associated with a database connection
62581: ** as expired.
62582: **
62583: ** An expired statement means that recompilation of the statement is
62584: ** recommend. Statements expire when things happen that make their
62585: ** programs obsolete. Removing user-defined functions or collating
62586: ** sequences, or changing an authorization function are the types of
62587: ** things that make prepared statements obsolete.
62588: */
62589: SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3 *db){
62590: Vdbe *p;
62591: for(p = db->pVdbe; p; p=p->pNext){
62592: p->expired = 1;
62593: }
62594: }
62595:
62596: /*
62597: ** Return the database associated with the Vdbe.
62598: */
62599: SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe *v){
62600: return v->db;
62601: }
62602:
62603: /*
62604: ** Return a pointer to an sqlite3_value structure containing the value bound
62605: ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
62606: ** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_*
62607: ** constants) to the value before returning it.
62608: **
62609: ** The returned value must be freed by the caller using sqlite3ValueFree().
62610: */
62611: SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe *v, int iVar, u8 aff){
62612: assert( iVar>0 );
62613: if( v ){
62614: Mem *pMem = &v->aVar[iVar-1];
62615: if( 0==(pMem->flags & MEM_Null) ){
62616: sqlite3_value *pRet = sqlite3ValueNew(v->db);
62617: if( pRet ){
62618: sqlite3VdbeMemCopy((Mem *)pRet, pMem);
62619: sqlite3ValueApplyAffinity(pRet, aff, SQLITE_UTF8);
62620: sqlite3VdbeMemStoreType((Mem *)pRet);
62621: }
62622: return pRet;
62623: }
62624: }
62625: return 0;
62626: }
62627:
62628: /*
62629: ** Configure SQL variable iVar so that binding a new value to it signals
62630: ** to sqlite3_reoptimize() that re-preparing the statement may result
62631: ** in a better query plan.
62632: */
62633: SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
62634: assert( iVar>0 );
62635: if( iVar>32 ){
62636: v->expmask = 0xffffffff;
62637: }else{
62638: v->expmask |= ((u32)1 << (iVar-1));
62639: }
62640: }
62641:
62642: /************** End of vdbeaux.c *********************************************/
62643: /************** Begin file vdbeapi.c *****************************************/
62644: /*
62645: ** 2004 May 26
62646: **
62647: ** The author disclaims copyright to this source code. In place of
62648: ** a legal notice, here is a blessing:
62649: **
62650: ** May you do good and not evil.
62651: ** May you find forgiveness for yourself and forgive others.
62652: ** May you share freely, never taking more than you give.
62653: **
62654: *************************************************************************
62655: **
62656: ** This file contains code use to implement APIs that are part of the
62657: ** VDBE.
62658: */
62659:
62660: #ifndef SQLITE_OMIT_DEPRECATED
62661: /*
62662: ** Return TRUE (non-zero) of the statement supplied as an argument needs
62663: ** to be recompiled. A statement needs to be recompiled whenever the
62664: ** execution environment changes in a way that would alter the program
62665: ** that sqlite3_prepare() generates. For example, if new functions or
62666: ** collating sequences are registered or if an authorizer function is
62667: ** added or changed.
62668: */
62669: SQLITE_API int sqlite3_expired(sqlite3_stmt *pStmt){
62670: Vdbe *p = (Vdbe*)pStmt;
62671: return p==0 || p->expired;
62672: }
62673: #endif
62674:
62675: /*
62676: ** Check on a Vdbe to make sure it has not been finalized. Log
62677: ** an error and return true if it has been finalized (or is otherwise
62678: ** invalid). Return false if it is ok.
62679: */
62680: static int vdbeSafety(Vdbe *p){
62681: if( p->db==0 ){
62682: sqlite3_log(SQLITE_MISUSE, "API called with finalized prepared statement");
62683: return 1;
62684: }else{
62685: return 0;
62686: }
62687: }
62688: static int vdbeSafetyNotNull(Vdbe *p){
62689: if( p==0 ){
62690: sqlite3_log(SQLITE_MISUSE, "API called with NULL prepared statement");
62691: return 1;
62692: }else{
62693: return vdbeSafety(p);
62694: }
62695: }
62696:
62697: /*
62698: ** The following routine destroys a virtual machine that is created by
62699: ** the sqlite3_compile() routine. The integer returned is an SQLITE_
62700: ** success/failure code that describes the result of executing the virtual
62701: ** machine.
62702: **
62703: ** This routine sets the error code and string returned by
62704: ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
62705: */
62706: SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt){
62707: int rc;
62708: if( pStmt==0 ){
62709: /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
62710: ** pointer is a harmless no-op. */
62711: rc = SQLITE_OK;
62712: }else{
62713: Vdbe *v = (Vdbe*)pStmt;
62714: sqlite3 *db = v->db;
62715: #if SQLITE_THREADSAFE
62716: sqlite3_mutex *mutex;
62717: #endif
62718: if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
62719: #if SQLITE_THREADSAFE
62720: mutex = v->db->mutex;
62721: #endif
62722: sqlite3_mutex_enter(mutex);
62723: rc = sqlite3VdbeFinalize(v);
62724: rc = sqlite3ApiExit(db, rc);
62725: sqlite3_mutex_leave(mutex);
62726: }
62727: return rc;
62728: }
62729:
62730: /*
62731: ** Terminate the current execution of an SQL statement and reset it
62732: ** back to its starting state so that it can be reused. A success code from
62733: ** the prior execution is returned.
62734: **
62735: ** This routine sets the error code and string returned by
62736: ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
62737: */
62738: SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){
62739: int rc;
62740: if( pStmt==0 ){
62741: rc = SQLITE_OK;
62742: }else{
62743: Vdbe *v = (Vdbe*)pStmt;
62744: sqlite3_mutex_enter(v->db->mutex);
62745: rc = sqlite3VdbeReset(v);
62746: sqlite3VdbeRewind(v);
62747: assert( (rc & (v->db->errMask))==rc );
62748: rc = sqlite3ApiExit(v->db, rc);
62749: sqlite3_mutex_leave(v->db->mutex);
62750: }
62751: return rc;
62752: }
62753:
62754: /*
62755: ** Set all the parameters in the compiled SQL statement to NULL.
62756: */
62757: SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
62758: int i;
62759: int rc = SQLITE_OK;
62760: Vdbe *p = (Vdbe*)pStmt;
62761: #if SQLITE_THREADSAFE
62762: sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
62763: #endif
62764: sqlite3_mutex_enter(mutex);
62765: for(i=0; i<p->nVar; i++){
62766: sqlite3VdbeMemRelease(&p->aVar[i]);
62767: p->aVar[i].flags = MEM_Null;
62768: }
62769: if( p->isPrepareV2 && p->expmask ){
62770: p->expired = 1;
62771: }
62772: sqlite3_mutex_leave(mutex);
62773: return rc;
62774: }
62775:
62776:
62777: /**************************** sqlite3_value_ *******************************
62778: ** The following routines extract information from a Mem or sqlite3_value
62779: ** structure.
62780: */
62781: SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
62782: Mem *p = (Mem*)pVal;
62783: if( p->flags & (MEM_Blob|MEM_Str) ){
62784: sqlite3VdbeMemExpandBlob(p);
62785: p->flags &= ~MEM_Str;
62786: p->flags |= MEM_Blob;
62787: return p->n ? p->z : 0;
62788: }else{
62789: return sqlite3_value_text(pVal);
62790: }
62791: }
62792: SQLITE_API int sqlite3_value_bytes(sqlite3_value *pVal){
62793: return sqlite3ValueBytes(pVal, SQLITE_UTF8);
62794: }
62795: SQLITE_API int sqlite3_value_bytes16(sqlite3_value *pVal){
62796: return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
62797: }
62798: SQLITE_API double sqlite3_value_double(sqlite3_value *pVal){
62799: return sqlite3VdbeRealValue((Mem*)pVal);
62800: }
62801: SQLITE_API int sqlite3_value_int(sqlite3_value *pVal){
62802: return (int)sqlite3VdbeIntValue((Mem*)pVal);
62803: }
62804: SQLITE_API sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
62805: return sqlite3VdbeIntValue((Mem*)pVal);
62806: }
62807: SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
62808: return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
62809: }
62810: #ifndef SQLITE_OMIT_UTF16
62811: SQLITE_API const void *sqlite3_value_text16(sqlite3_value* pVal){
62812: return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
62813: }
62814: SQLITE_API const void *sqlite3_value_text16be(sqlite3_value *pVal){
62815: return sqlite3ValueText(pVal, SQLITE_UTF16BE);
62816: }
62817: SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){
62818: return sqlite3ValueText(pVal, SQLITE_UTF16LE);
62819: }
62820: #endif /* SQLITE_OMIT_UTF16 */
62821: SQLITE_API int sqlite3_value_type(sqlite3_value* pVal){
62822: return pVal->type;
62823: }
62824:
62825: /**************************** sqlite3_result_ *******************************
62826: ** The following routines are used by user-defined functions to specify
62827: ** the function result.
62828: **
62829: ** The setStrOrError() funtion calls sqlite3VdbeMemSetStr() to store the
62830: ** result as a string or blob but if the string or blob is too large, it
62831: ** then sets the error code to SQLITE_TOOBIG
62832: */
62833: static void setResultStrOrError(
62834: sqlite3_context *pCtx, /* Function context */
62835: const char *z, /* String pointer */
62836: int n, /* Bytes in string, or negative */
62837: u8 enc, /* Encoding of z. 0 for BLOBs */
62838: void (*xDel)(void*) /* Destructor function */
62839: ){
62840: if( sqlite3VdbeMemSetStr(&pCtx->s, z, n, enc, xDel)==SQLITE_TOOBIG ){
62841: sqlite3_result_error_toobig(pCtx);
62842: }
62843: }
62844: SQLITE_API void sqlite3_result_blob(
62845: sqlite3_context *pCtx,
62846: const void *z,
62847: int n,
62848: void (*xDel)(void *)
62849: ){
62850: assert( n>=0 );
62851: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62852: setResultStrOrError(pCtx, z, n, 0, xDel);
62853: }
62854: SQLITE_API void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
62855: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62856: sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
62857: }
62858: SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
62859: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62860: pCtx->isError = SQLITE_ERROR;
62861: sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
62862: }
62863: #ifndef SQLITE_OMIT_UTF16
62864: SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
62865: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62866: pCtx->isError = SQLITE_ERROR;
62867: sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
62868: }
62869: #endif
62870: SQLITE_API void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
62871: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62872: sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
62873: }
62874: SQLITE_API void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
62875: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62876: sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
62877: }
62878: SQLITE_API void sqlite3_result_null(sqlite3_context *pCtx){
62879: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62880: sqlite3VdbeMemSetNull(&pCtx->s);
62881: }
62882: SQLITE_API void sqlite3_result_text(
62883: sqlite3_context *pCtx,
62884: const char *z,
62885: int n,
62886: void (*xDel)(void *)
62887: ){
62888: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62889: setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
62890: }
62891: #ifndef SQLITE_OMIT_UTF16
62892: SQLITE_API void sqlite3_result_text16(
62893: sqlite3_context *pCtx,
62894: const void *z,
62895: int n,
62896: void (*xDel)(void *)
62897: ){
62898: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62899: setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
62900: }
62901: SQLITE_API void sqlite3_result_text16be(
62902: sqlite3_context *pCtx,
62903: const void *z,
62904: int n,
62905: void (*xDel)(void *)
62906: ){
62907: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62908: setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
62909: }
62910: SQLITE_API void sqlite3_result_text16le(
62911: sqlite3_context *pCtx,
62912: const void *z,
62913: int n,
62914: void (*xDel)(void *)
62915: ){
62916: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62917: setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
62918: }
62919: #endif /* SQLITE_OMIT_UTF16 */
62920: SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
62921: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62922: sqlite3VdbeMemCopy(&pCtx->s, pValue);
62923: }
62924: SQLITE_API void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
62925: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62926: sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
62927: }
62928: SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
62929: pCtx->isError = errCode;
62930: if( pCtx->s.flags & MEM_Null ){
62931: sqlite3VdbeMemSetStr(&pCtx->s, sqlite3ErrStr(errCode), -1,
62932: SQLITE_UTF8, SQLITE_STATIC);
62933: }
62934: }
62935:
62936: /* Force an SQLITE_TOOBIG error. */
62937: SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){
62938: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62939: pCtx->isError = SQLITE_TOOBIG;
62940: sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1,
62941: SQLITE_UTF8, SQLITE_STATIC);
62942: }
62943:
62944: /* An SQLITE_NOMEM error. */
62945: SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){
62946: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
62947: sqlite3VdbeMemSetNull(&pCtx->s);
62948: pCtx->isError = SQLITE_NOMEM;
62949: pCtx->s.db->mallocFailed = 1;
62950: }
62951:
62952: /*
62953: ** This function is called after a transaction has been committed. It
62954: ** invokes callbacks registered with sqlite3_wal_hook() as required.
62955: */
62956: static int doWalCallbacks(sqlite3 *db){
62957: int rc = SQLITE_OK;
62958: #ifndef SQLITE_OMIT_WAL
62959: int i;
62960: for(i=0; i<db->nDb; i++){
62961: Btree *pBt = db->aDb[i].pBt;
62962: if( pBt ){
62963: int nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));
62964: if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){
62965: rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry);
62966: }
62967: }
62968: }
62969: #endif
62970: return rc;
62971: }
62972:
62973: /*
62974: ** Execute the statement pStmt, either until a row of data is ready, the
62975: ** statement is completely executed or an error occurs.
62976: **
62977: ** This routine implements the bulk of the logic behind the sqlite_step()
62978: ** API. The only thing omitted is the automatic recompile if a
62979: ** schema change has occurred. That detail is handled by the
62980: ** outer sqlite3_step() wrapper procedure.
62981: */
62982: static int sqlite3Step(Vdbe *p){
62983: sqlite3 *db;
62984: int rc;
62985:
62986: assert(p);
62987: if( p->magic!=VDBE_MAGIC_RUN ){
62988: /* We used to require that sqlite3_reset() be called before retrying
62989: ** sqlite3_step() after any error or after SQLITE_DONE. But beginning
62990: ** with version 3.7.0, we changed this so that sqlite3_reset() would
62991: ** be called automatically instead of throwing the SQLITE_MISUSE error.
62992: ** This "automatic-reset" change is not technically an incompatibility,
62993: ** since any application that receives an SQLITE_MISUSE is broken by
62994: ** definition.
62995: **
62996: ** Nevertheless, some published applications that were originally written
62997: ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
62998: ** returns, and those were broken by the automatic-reset change. As a
62999: ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
63000: ** legacy behavior of returning SQLITE_MISUSE for cases where the
63001: ** previous sqlite3_step() returned something other than a SQLITE_LOCKED
63002: ** or SQLITE_BUSY error.
63003: */
63004: #ifdef SQLITE_OMIT_AUTORESET
63005: if( p->rc==SQLITE_BUSY || p->rc==SQLITE_LOCKED ){
63006: sqlite3_reset((sqlite3_stmt*)p);
63007: }else{
63008: return SQLITE_MISUSE_BKPT;
63009: }
63010: #else
63011: sqlite3_reset((sqlite3_stmt*)p);
63012: #endif
63013: }
63014:
63015: /* Check that malloc() has not failed. If it has, return early. */
63016: db = p->db;
63017: if( db->mallocFailed ){
63018: p->rc = SQLITE_NOMEM;
63019: return SQLITE_NOMEM;
63020: }
63021:
63022: if( p->pc<=0 && p->expired ){
63023: p->rc = SQLITE_SCHEMA;
63024: rc = SQLITE_ERROR;
63025: goto end_of_step;
63026: }
63027: if( p->pc<0 ){
63028: /* If there are no other statements currently running, then
63029: ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
63030: ** from interrupting a statement that has not yet started.
63031: */
63032: if( db->activeVdbeCnt==0 ){
63033: db->u1.isInterrupted = 0;
63034: }
63035:
63036: assert( db->writeVdbeCnt>0 || db->autoCommit==0 || db->nDeferredCons==0 );
63037:
63038: #ifndef SQLITE_OMIT_TRACE
63039: if( db->xProfile && !db->init.busy ){
63040: sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
63041: }
63042: #endif
63043:
63044: db->activeVdbeCnt++;
63045: if( p->readOnly==0 ) db->writeVdbeCnt++;
63046: p->pc = 0;
63047: }
63048: #ifndef SQLITE_OMIT_EXPLAIN
63049: if( p->explain ){
63050: rc = sqlite3VdbeList(p);
63051: }else
63052: #endif /* SQLITE_OMIT_EXPLAIN */
63053: {
63054: db->vdbeExecCnt++;
63055: rc = sqlite3VdbeExec(p);
63056: db->vdbeExecCnt--;
63057: }
63058:
63059: #ifndef SQLITE_OMIT_TRACE
63060: /* Invoke the profile callback if there is one
63061: */
63062: if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->zSql ){
63063: sqlite3_int64 iNow;
63064: sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
63065: db->xProfile(db->pProfileArg, p->zSql, (iNow - p->startTime)*1000000);
63066: }
63067: #endif
63068:
63069: if( rc==SQLITE_DONE ){
63070: assert( p->rc==SQLITE_OK );
63071: p->rc = doWalCallbacks(db);
63072: if( p->rc!=SQLITE_OK ){
63073: rc = SQLITE_ERROR;
63074: }
63075: }
63076:
63077: db->errCode = rc;
63078: if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
63079: p->rc = SQLITE_NOMEM;
63080: }
63081: end_of_step:
63082: /* At this point local variable rc holds the value that should be
63083: ** returned if this statement was compiled using the legacy
63084: ** sqlite3_prepare() interface. According to the docs, this can only
63085: ** be one of the values in the first assert() below. Variable p->rc
63086: ** contains the value that would be returned if sqlite3_finalize()
63087: ** were called on statement p.
63088: */
63089: assert( rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR
63090: || rc==SQLITE_BUSY || rc==SQLITE_MISUSE
63091: );
63092: assert( p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE );
63093: if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
63094: /* If this statement was prepared using sqlite3_prepare_v2(), and an
63095: ** error has occured, then return the error code in p->rc to the
63096: ** caller. Set the error code in the database handle to the same value.
63097: */
63098: rc = sqlite3VdbeTransferError(p);
63099: }
63100: return (rc&db->errMask);
63101: }
63102:
63103: /*
63104: ** The maximum number of times that a statement will try to reparse
63105: ** itself before giving up and returning SQLITE_SCHEMA.
63106: */
63107: #ifndef SQLITE_MAX_SCHEMA_RETRY
63108: # define SQLITE_MAX_SCHEMA_RETRY 5
63109: #endif
63110:
63111: /*
63112: ** This is the top-level implementation of sqlite3_step(). Call
63113: ** sqlite3Step() to do most of the work. If a schema error occurs,
63114: ** call sqlite3Reprepare() and try again.
63115: */
63116: SQLITE_API int sqlite3_step(sqlite3_stmt *pStmt){
63117: int rc = SQLITE_OK; /* Result from sqlite3Step() */
63118: int rc2 = SQLITE_OK; /* Result from sqlite3Reprepare() */
63119: Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */
63120: int cnt = 0; /* Counter to prevent infinite loop of reprepares */
63121: sqlite3 *db; /* The database connection */
63122:
63123: if( vdbeSafetyNotNull(v) ){
63124: return SQLITE_MISUSE_BKPT;
63125: }
63126: db = v->db;
63127: sqlite3_mutex_enter(db->mutex);
63128: while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
63129: && cnt++ < SQLITE_MAX_SCHEMA_RETRY
63130: && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){
63131: sqlite3_reset(pStmt);
63132: assert( v->expired==0 );
63133: }
63134: if( rc2!=SQLITE_OK && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
63135: /* This case occurs after failing to recompile an sql statement.
63136: ** The error message from the SQL compiler has already been loaded
63137: ** into the database handle. This block copies the error message
63138: ** from the database handle into the statement and sets the statement
63139: ** program counter to 0 to ensure that when the statement is
63140: ** finalized or reset the parser error message is available via
63141: ** sqlite3_errmsg() and sqlite3_errcode().
63142: */
63143: const char *zErr = (const char *)sqlite3_value_text(db->pErr);
63144: sqlite3DbFree(db, v->zErrMsg);
63145: if( !db->mallocFailed ){
63146: v->zErrMsg = sqlite3DbStrDup(db, zErr);
63147: v->rc = rc2;
63148: } else {
63149: v->zErrMsg = 0;
63150: v->rc = rc = SQLITE_NOMEM;
63151: }
63152: }
63153: rc = sqlite3ApiExit(db, rc);
63154: sqlite3_mutex_leave(db->mutex);
63155: return rc;
63156: }
63157:
63158: /*
63159: ** Extract the user data from a sqlite3_context structure and return a
63160: ** pointer to it.
63161: */
63162: SQLITE_API void *sqlite3_user_data(sqlite3_context *p){
63163: assert( p && p->pFunc );
63164: return p->pFunc->pUserData;
63165: }
63166:
63167: /*
63168: ** Extract the user data from a sqlite3_context structure and return a
63169: ** pointer to it.
63170: **
63171: ** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface
63172: ** returns a copy of the pointer to the database connection (the 1st
63173: ** parameter) of the sqlite3_create_function() and
63174: ** sqlite3_create_function16() routines that originally registered the
63175: ** application defined function.
63176: */
63177: SQLITE_API sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
63178: assert( p && p->pFunc );
63179: return p->s.db;
63180: }
63181:
63182: /*
63183: ** The following is the implementation of an SQL function that always
63184: ** fails with an error message stating that the function is used in the
63185: ** wrong context. The sqlite3_overload_function() API might construct
63186: ** SQL function that use this routine so that the functions will exist
63187: ** for name resolution but are actually overloaded by the xFindFunction
63188: ** method of virtual tables.
63189: */
63190: SQLITE_PRIVATE void sqlite3InvalidFunction(
63191: sqlite3_context *context, /* The function calling context */
63192: int NotUsed, /* Number of arguments to the function */
63193: sqlite3_value **NotUsed2 /* Value of each argument */
63194: ){
63195: const char *zName = context->pFunc->zName;
63196: char *zErr;
63197: UNUSED_PARAMETER2(NotUsed, NotUsed2);
63198: zErr = sqlite3_mprintf(
63199: "unable to use function %s in the requested context", zName);
63200: sqlite3_result_error(context, zErr, -1);
63201: sqlite3_free(zErr);
63202: }
63203:
63204: /*
63205: ** Allocate or return the aggregate context for a user function. A new
63206: ** context is allocated on the first call. Subsequent calls return the
63207: ** same context that was returned on prior calls.
63208: */
63209: SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
63210: Mem *pMem;
63211: assert( p && p->pFunc && p->pFunc->xStep );
63212: assert( sqlite3_mutex_held(p->s.db->mutex) );
63213: pMem = p->pMem;
63214: testcase( nByte<0 );
63215: if( (pMem->flags & MEM_Agg)==0 ){
63216: if( nByte<=0 ){
63217: sqlite3VdbeMemReleaseExternal(pMem);
63218: pMem->flags = MEM_Null;
63219: pMem->z = 0;
63220: }else{
63221: sqlite3VdbeMemGrow(pMem, nByte, 0);
63222: pMem->flags = MEM_Agg;
63223: pMem->u.pDef = p->pFunc;
63224: if( pMem->z ){
63225: memset(pMem->z, 0, nByte);
63226: }
63227: }
63228: }
63229: return (void*)pMem->z;
63230: }
63231:
63232: /*
63233: ** Return the auxilary data pointer, if any, for the iArg'th argument to
63234: ** the user-function defined by pCtx.
63235: */
63236: SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
63237: VdbeFunc *pVdbeFunc;
63238:
63239: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
63240: pVdbeFunc = pCtx->pVdbeFunc;
63241: if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
63242: return 0;
63243: }
63244: return pVdbeFunc->apAux[iArg].pAux;
63245: }
63246:
63247: /*
63248: ** Set the auxilary data pointer and delete function, for the iArg'th
63249: ** argument to the user-function defined by pCtx. Any previous value is
63250: ** deleted by calling the delete function specified when it was set.
63251: */
63252: SQLITE_API void sqlite3_set_auxdata(
63253: sqlite3_context *pCtx,
63254: int iArg,
63255: void *pAux,
63256: void (*xDelete)(void*)
63257: ){
63258: struct AuxData *pAuxData;
63259: VdbeFunc *pVdbeFunc;
63260: if( iArg<0 ) goto failed;
63261:
63262: assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
63263: pVdbeFunc = pCtx->pVdbeFunc;
63264: if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
63265: int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
63266: int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
63267: pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
63268: if( !pVdbeFunc ){
63269: goto failed;
63270: }
63271: pCtx->pVdbeFunc = pVdbeFunc;
63272: memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
63273: pVdbeFunc->nAux = iArg+1;
63274: pVdbeFunc->pFunc = pCtx->pFunc;
63275: }
63276:
63277: pAuxData = &pVdbeFunc->apAux[iArg];
63278: if( pAuxData->pAux && pAuxData->xDelete ){
63279: pAuxData->xDelete(pAuxData->pAux);
63280: }
63281: pAuxData->pAux = pAux;
63282: pAuxData->xDelete = xDelete;
63283: return;
63284:
63285: failed:
63286: if( xDelete ){
63287: xDelete(pAux);
63288: }
63289: }
63290:
63291: #ifndef SQLITE_OMIT_DEPRECATED
63292: /*
63293: ** Return the number of times the Step function of a aggregate has been
63294: ** called.
63295: **
63296: ** This function is deprecated. Do not use it for new code. It is
63297: ** provide only to avoid breaking legacy code. New aggregate function
63298: ** implementations should keep their own counts within their aggregate
63299: ** context.
63300: */
63301: SQLITE_API int sqlite3_aggregate_count(sqlite3_context *p){
63302: assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
63303: return p->pMem->n;
63304: }
63305: #endif
63306:
63307: /*
63308: ** Return the number of columns in the result set for the statement pStmt.
63309: */
63310: SQLITE_API int sqlite3_column_count(sqlite3_stmt *pStmt){
63311: Vdbe *pVm = (Vdbe *)pStmt;
63312: return pVm ? pVm->nResColumn : 0;
63313: }
63314:
63315: /*
63316: ** Return the number of values available from the current row of the
63317: ** currently executing statement pStmt.
63318: */
63319: SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt){
63320: Vdbe *pVm = (Vdbe *)pStmt;
63321: if( pVm==0 || pVm->pResultSet==0 ) return 0;
63322: return pVm->nResColumn;
63323: }
63324:
63325:
63326: /*
63327: ** Check to see if column iCol of the given statement is valid. If
63328: ** it is, return a pointer to the Mem for the value of that column.
63329: ** If iCol is not valid, return a pointer to a Mem which has a value
63330: ** of NULL.
63331: */
63332: static Mem *columnMem(sqlite3_stmt *pStmt, int i){
63333: Vdbe *pVm;
63334: Mem *pOut;
63335:
63336: pVm = (Vdbe *)pStmt;
63337: if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
63338: sqlite3_mutex_enter(pVm->db->mutex);
63339: pOut = &pVm->pResultSet[i];
63340: }else{
63341: /* If the value passed as the second argument is out of range, return
63342: ** a pointer to the following static Mem object which contains the
63343: ** value SQL NULL. Even though the Mem structure contains an element
63344: ** of type i64, on certain architectures (x86) with certain compiler
63345: ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
63346: ** instead of an 8-byte one. This all works fine, except that when
63347: ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
63348: ** that a Mem structure is located on an 8-byte boundary. To prevent
63349: ** these assert()s from failing, when building with SQLITE_DEBUG defined
63350: ** using gcc, we force nullMem to be 8-byte aligned using the magical
63351: ** __attribute__((aligned(8))) macro. */
63352: static const Mem nullMem
63353: #if defined(SQLITE_DEBUG) && defined(__GNUC__)
63354: __attribute__((aligned(8)))
63355: #endif
63356: = {0, "", (double)0, {0}, 0, MEM_Null, SQLITE_NULL, 0,
63357: #ifdef SQLITE_DEBUG
63358: 0, 0, /* pScopyFrom, pFiller */
63359: #endif
63360: 0, 0 };
63361:
63362: if( pVm && ALWAYS(pVm->db) ){
63363: sqlite3_mutex_enter(pVm->db->mutex);
63364: sqlite3Error(pVm->db, SQLITE_RANGE, 0);
63365: }
63366: pOut = (Mem*)&nullMem;
63367: }
63368: return pOut;
63369: }
63370:
63371: /*
63372: ** This function is called after invoking an sqlite3_value_XXX function on a
63373: ** column value (i.e. a value returned by evaluating an SQL expression in the
63374: ** select list of a SELECT statement) that may cause a malloc() failure. If
63375: ** malloc() has failed, the threads mallocFailed flag is cleared and the result
63376: ** code of statement pStmt set to SQLITE_NOMEM.
63377: **
63378: ** Specifically, this is called from within:
63379: **
63380: ** sqlite3_column_int()
63381: ** sqlite3_column_int64()
63382: ** sqlite3_column_text()
63383: ** sqlite3_column_text16()
63384: ** sqlite3_column_real()
63385: ** sqlite3_column_bytes()
63386: ** sqlite3_column_bytes16()
63387: ** sqiite3_column_blob()
63388: */
63389: static void columnMallocFailure(sqlite3_stmt *pStmt)
63390: {
63391: /* If malloc() failed during an encoding conversion within an
63392: ** sqlite3_column_XXX API, then set the return code of the statement to
63393: ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
63394: ** and _finalize() will return NOMEM.
63395: */
63396: Vdbe *p = (Vdbe *)pStmt;
63397: if( p ){
63398: p->rc = sqlite3ApiExit(p->db, p->rc);
63399: sqlite3_mutex_leave(p->db->mutex);
63400: }
63401: }
63402:
63403: /**************************** sqlite3_column_ *******************************
63404: ** The following routines are used to access elements of the current row
63405: ** in the result set.
63406: */
63407: SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
63408: const void *val;
63409: val = sqlite3_value_blob( columnMem(pStmt,i) );
63410: /* Even though there is no encoding conversion, value_blob() might
63411: ** need to call malloc() to expand the result of a zeroblob()
63412: ** expression.
63413: */
63414: columnMallocFailure(pStmt);
63415: return val;
63416: }
63417: SQLITE_API int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
63418: int val = sqlite3_value_bytes( columnMem(pStmt,i) );
63419: columnMallocFailure(pStmt);
63420: return val;
63421: }
63422: SQLITE_API int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
63423: int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
63424: columnMallocFailure(pStmt);
63425: return val;
63426: }
63427: SQLITE_API double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
63428: double val = sqlite3_value_double( columnMem(pStmt,i) );
63429: columnMallocFailure(pStmt);
63430: return val;
63431: }
63432: SQLITE_API int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
63433: int val = sqlite3_value_int( columnMem(pStmt,i) );
63434: columnMallocFailure(pStmt);
63435: return val;
63436: }
63437: SQLITE_API sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
63438: sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
63439: columnMallocFailure(pStmt);
63440: return val;
63441: }
63442: SQLITE_API const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
63443: const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
63444: columnMallocFailure(pStmt);
63445: return val;
63446: }
63447: SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
63448: Mem *pOut = columnMem(pStmt, i);
63449: if( pOut->flags&MEM_Static ){
63450: pOut->flags &= ~MEM_Static;
63451: pOut->flags |= MEM_Ephem;
63452: }
63453: columnMallocFailure(pStmt);
63454: return (sqlite3_value *)pOut;
63455: }
63456: #ifndef SQLITE_OMIT_UTF16
63457: SQLITE_API const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
63458: const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
63459: columnMallocFailure(pStmt);
63460: return val;
63461: }
63462: #endif /* SQLITE_OMIT_UTF16 */
63463: SQLITE_API int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
63464: int iType = sqlite3_value_type( columnMem(pStmt,i) );
63465: columnMallocFailure(pStmt);
63466: return iType;
63467: }
63468:
63469: /* The following function is experimental and subject to change or
63470: ** removal */
63471: /*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){
63472: ** return sqlite3_value_numeric_type( columnMem(pStmt,i) );
63473: **}
63474: */
63475:
63476: /*
63477: ** Convert the N-th element of pStmt->pColName[] into a string using
63478: ** xFunc() then return that string. If N is out of range, return 0.
63479: **
63480: ** There are up to 5 names for each column. useType determines which
63481: ** name is returned. Here are the names:
63482: **
63483: ** 0 The column name as it should be displayed for output
63484: ** 1 The datatype name for the column
63485: ** 2 The name of the database that the column derives from
63486: ** 3 The name of the table that the column derives from
63487: ** 4 The name of the table column that the result column derives from
63488: **
63489: ** If the result is not a simple column reference (if it is an expression
63490: ** or a constant) then useTypes 2, 3, and 4 return NULL.
63491: */
63492: static const void *columnName(
63493: sqlite3_stmt *pStmt,
63494: int N,
63495: const void *(*xFunc)(Mem*),
63496: int useType
63497: ){
63498: const void *ret = 0;
63499: Vdbe *p = (Vdbe *)pStmt;
63500: int n;
63501: sqlite3 *db = p->db;
63502:
63503: assert( db!=0 );
63504: n = sqlite3_column_count(pStmt);
63505: if( N<n && N>=0 ){
63506: N += useType*n;
63507: sqlite3_mutex_enter(db->mutex);
63508: assert( db->mallocFailed==0 );
63509: ret = xFunc(&p->aColName[N]);
63510: /* A malloc may have failed inside of the xFunc() call. If this
63511: ** is the case, clear the mallocFailed flag and return NULL.
63512: */
63513: if( db->mallocFailed ){
63514: db->mallocFailed = 0;
63515: ret = 0;
63516: }
63517: sqlite3_mutex_leave(db->mutex);
63518: }
63519: return ret;
63520: }
63521:
63522: /*
63523: ** Return the name of the Nth column of the result set returned by SQL
63524: ** statement pStmt.
63525: */
63526: SQLITE_API const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
63527: return columnName(
63528: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
63529: }
63530: #ifndef SQLITE_OMIT_UTF16
63531: SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
63532: return columnName(
63533: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
63534: }
63535: #endif
63536:
63537: /*
63538: ** Constraint: If you have ENABLE_COLUMN_METADATA then you must
63539: ** not define OMIT_DECLTYPE.
63540: */
63541: #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
63542: # error "Must not define both SQLITE_OMIT_DECLTYPE \
63543: and SQLITE_ENABLE_COLUMN_METADATA"
63544: #endif
63545:
63546: #ifndef SQLITE_OMIT_DECLTYPE
63547: /*
63548: ** Return the column declaration type (if applicable) of the 'i'th column
63549: ** of the result set of SQL statement pStmt.
63550: */
63551: SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
63552: return columnName(
63553: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
63554: }
63555: #ifndef SQLITE_OMIT_UTF16
63556: SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
63557: return columnName(
63558: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
63559: }
63560: #endif /* SQLITE_OMIT_UTF16 */
63561: #endif /* SQLITE_OMIT_DECLTYPE */
63562:
63563: #ifdef SQLITE_ENABLE_COLUMN_METADATA
63564: /*
63565: ** Return the name of the database from which a result column derives.
63566: ** NULL is returned if the result column is an expression or constant or
63567: ** anything else which is not an unabiguous reference to a database column.
63568: */
63569: SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
63570: return columnName(
63571: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
63572: }
63573: #ifndef SQLITE_OMIT_UTF16
63574: SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
63575: return columnName(
63576: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
63577: }
63578: #endif /* SQLITE_OMIT_UTF16 */
63579:
63580: /*
63581: ** Return the name of the table from which a result column derives.
63582: ** NULL is returned if the result column is an expression or constant or
63583: ** anything else which is not an unabiguous reference to a database column.
63584: */
63585: SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
63586: return columnName(
63587: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
63588: }
63589: #ifndef SQLITE_OMIT_UTF16
63590: SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
63591: return columnName(
63592: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
63593: }
63594: #endif /* SQLITE_OMIT_UTF16 */
63595:
63596: /*
63597: ** Return the name of the table column from which a result column derives.
63598: ** NULL is returned if the result column is an expression or constant or
63599: ** anything else which is not an unabiguous reference to a database column.
63600: */
63601: SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
63602: return columnName(
63603: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
63604: }
63605: #ifndef SQLITE_OMIT_UTF16
63606: SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
63607: return columnName(
63608: pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
63609: }
63610: #endif /* SQLITE_OMIT_UTF16 */
63611: #endif /* SQLITE_ENABLE_COLUMN_METADATA */
63612:
63613:
63614: /******************************* sqlite3_bind_ ***************************
63615: **
63616: ** Routines used to attach values to wildcards in a compiled SQL statement.
63617: */
63618: /*
63619: ** Unbind the value bound to variable i in virtual machine p. This is the
63620: ** the same as binding a NULL value to the column. If the "i" parameter is
63621: ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
63622: **
63623: ** A successful evaluation of this routine acquires the mutex on p.
63624: ** the mutex is released if any kind of error occurs.
63625: **
63626: ** The error code stored in database p->db is overwritten with the return
63627: ** value in any case.
63628: */
63629: static int vdbeUnbind(Vdbe *p, int i){
63630: Mem *pVar;
63631: if( vdbeSafetyNotNull(p) ){
63632: return SQLITE_MISUSE_BKPT;
63633: }
63634: sqlite3_mutex_enter(p->db->mutex);
63635: if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
63636: sqlite3Error(p->db, SQLITE_MISUSE, 0);
63637: sqlite3_mutex_leave(p->db->mutex);
63638: sqlite3_log(SQLITE_MISUSE,
63639: "bind on a busy prepared statement: [%s]", p->zSql);
63640: return SQLITE_MISUSE_BKPT;
63641: }
63642: if( i<1 || i>p->nVar ){
63643: sqlite3Error(p->db, SQLITE_RANGE, 0);
63644: sqlite3_mutex_leave(p->db->mutex);
63645: return SQLITE_RANGE;
63646: }
63647: i--;
63648: pVar = &p->aVar[i];
63649: sqlite3VdbeMemRelease(pVar);
63650: pVar->flags = MEM_Null;
63651: sqlite3Error(p->db, SQLITE_OK, 0);
63652:
63653: /* If the bit corresponding to this variable in Vdbe.expmask is set, then
63654: ** binding a new value to this variable invalidates the current query plan.
63655: **
63656: ** IMPLEMENTATION-OF: R-48440-37595 If the specific value bound to host
63657: ** parameter in the WHERE clause might influence the choice of query plan
63658: ** for a statement, then the statement will be automatically recompiled,
63659: ** as if there had been a schema change, on the first sqlite3_step() call
63660: ** following any change to the bindings of that parameter.
63661: */
63662: if( p->isPrepareV2 &&
63663: ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
63664: ){
63665: p->expired = 1;
63666: }
63667: return SQLITE_OK;
63668: }
63669:
63670: /*
63671: ** Bind a text or BLOB value.
63672: */
63673: static int bindText(
63674: sqlite3_stmt *pStmt, /* The statement to bind against */
63675: int i, /* Index of the parameter to bind */
63676: const void *zData, /* Pointer to the data to be bound */
63677: int nData, /* Number of bytes of data to be bound */
63678: void (*xDel)(void*), /* Destructor for the data */
63679: u8 encoding /* Encoding for the data */
63680: ){
63681: Vdbe *p = (Vdbe *)pStmt;
63682: Mem *pVar;
63683: int rc;
63684:
63685: rc = vdbeUnbind(p, i);
63686: if( rc==SQLITE_OK ){
63687: if( zData!=0 ){
63688: pVar = &p->aVar[i-1];
63689: rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
63690: if( rc==SQLITE_OK && encoding!=0 ){
63691: rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
63692: }
63693: sqlite3Error(p->db, rc, 0);
63694: rc = sqlite3ApiExit(p->db, rc);
63695: }
63696: sqlite3_mutex_leave(p->db->mutex);
63697: }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){
63698: xDel((void*)zData);
63699: }
63700: return rc;
63701: }
63702:
63703:
63704: /*
63705: ** Bind a blob value to an SQL statement variable.
63706: */
63707: SQLITE_API int sqlite3_bind_blob(
63708: sqlite3_stmt *pStmt,
63709: int i,
63710: const void *zData,
63711: int nData,
63712: void (*xDel)(void*)
63713: ){
63714: return bindText(pStmt, i, zData, nData, xDel, 0);
63715: }
63716: SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
63717: int rc;
63718: Vdbe *p = (Vdbe *)pStmt;
63719: rc = vdbeUnbind(p, i);
63720: if( rc==SQLITE_OK ){
63721: sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
63722: sqlite3_mutex_leave(p->db->mutex);
63723: }
63724: return rc;
63725: }
63726: SQLITE_API int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
63727: return sqlite3_bind_int64(p, i, (i64)iValue);
63728: }
63729: SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
63730: int rc;
63731: Vdbe *p = (Vdbe *)pStmt;
63732: rc = vdbeUnbind(p, i);
63733: if( rc==SQLITE_OK ){
63734: sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
63735: sqlite3_mutex_leave(p->db->mutex);
63736: }
63737: return rc;
63738: }
63739: SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
63740: int rc;
63741: Vdbe *p = (Vdbe*)pStmt;
63742: rc = vdbeUnbind(p, i);
63743: if( rc==SQLITE_OK ){
63744: sqlite3_mutex_leave(p->db->mutex);
63745: }
63746: return rc;
63747: }
63748: SQLITE_API int sqlite3_bind_text(
63749: sqlite3_stmt *pStmt,
63750: int i,
63751: const char *zData,
63752: int nData,
63753: void (*xDel)(void*)
63754: ){
63755: return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
63756: }
63757: #ifndef SQLITE_OMIT_UTF16
63758: SQLITE_API int sqlite3_bind_text16(
63759: sqlite3_stmt *pStmt,
63760: int i,
63761: const void *zData,
63762: int nData,
63763: void (*xDel)(void*)
63764: ){
63765: return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
63766: }
63767: #endif /* SQLITE_OMIT_UTF16 */
63768: SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
63769: int rc;
63770: switch( pValue->type ){
63771: case SQLITE_INTEGER: {
63772: rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
63773: break;
63774: }
63775: case SQLITE_FLOAT: {
63776: rc = sqlite3_bind_double(pStmt, i, pValue->r);
63777: break;
63778: }
63779: case SQLITE_BLOB: {
63780: if( pValue->flags & MEM_Zero ){
63781: rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
63782: }else{
63783: rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
63784: }
63785: break;
63786: }
63787: case SQLITE_TEXT: {
63788: rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT,
63789: pValue->enc);
63790: break;
63791: }
63792: default: {
63793: rc = sqlite3_bind_null(pStmt, i);
63794: break;
63795: }
63796: }
63797: return rc;
63798: }
63799: SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
63800: int rc;
63801: Vdbe *p = (Vdbe *)pStmt;
63802: rc = vdbeUnbind(p, i);
63803: if( rc==SQLITE_OK ){
63804: sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
63805: sqlite3_mutex_leave(p->db->mutex);
63806: }
63807: return rc;
63808: }
63809:
63810: /*
63811: ** Return the number of wildcards that can be potentially bound to.
63812: ** This routine is added to support DBD::SQLite.
63813: */
63814: SQLITE_API int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
63815: Vdbe *p = (Vdbe*)pStmt;
63816: return p ? p->nVar : 0;
63817: }
63818:
63819: /*
63820: ** Return the name of a wildcard parameter. Return NULL if the index
63821: ** is out of range or if the wildcard is unnamed.
63822: **
63823: ** The result is always UTF-8.
63824: */
63825: SQLITE_API const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
63826: Vdbe *p = (Vdbe*)pStmt;
63827: if( p==0 || i<1 || i>p->nzVar ){
63828: return 0;
63829: }
63830: return p->azVar[i-1];
63831: }
63832:
63833: /*
63834: ** Given a wildcard parameter name, return the index of the variable
63835: ** with that name. If there is no variable with the given name,
63836: ** return 0.
63837: */
63838: SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
63839: int i;
63840: if( p==0 ){
63841: return 0;
63842: }
63843: if( zName ){
63844: for(i=0; i<p->nzVar; i++){
63845: const char *z = p->azVar[i];
63846: if( z && memcmp(z,zName,nName)==0 && z[nName]==0 ){
63847: return i+1;
63848: }
63849: }
63850: }
63851: return 0;
63852: }
63853: SQLITE_API int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
63854: return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
63855: }
63856:
63857: /*
63858: ** Transfer all bindings from the first statement over to the second.
63859: */
63860: SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
63861: Vdbe *pFrom = (Vdbe*)pFromStmt;
63862: Vdbe *pTo = (Vdbe*)pToStmt;
63863: int i;
63864: assert( pTo->db==pFrom->db );
63865: assert( pTo->nVar==pFrom->nVar );
63866: sqlite3_mutex_enter(pTo->db->mutex);
63867: for(i=0; i<pFrom->nVar; i++){
63868: sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
63869: }
63870: sqlite3_mutex_leave(pTo->db->mutex);
63871: return SQLITE_OK;
63872: }
63873:
63874: #ifndef SQLITE_OMIT_DEPRECATED
63875: /*
63876: ** Deprecated external interface. Internal/core SQLite code
63877: ** should call sqlite3TransferBindings.
63878: **
63879: ** Is is misuse to call this routine with statements from different
63880: ** database connections. But as this is a deprecated interface, we
63881: ** will not bother to check for that condition.
63882: **
63883: ** If the two statements contain a different number of bindings, then
63884: ** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise
63885: ** SQLITE_OK is returned.
63886: */
63887: SQLITE_API int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
63888: Vdbe *pFrom = (Vdbe*)pFromStmt;
63889: Vdbe *pTo = (Vdbe*)pToStmt;
63890: if( pFrom->nVar!=pTo->nVar ){
63891: return SQLITE_ERROR;
63892: }
63893: if( pTo->isPrepareV2 && pTo->expmask ){
63894: pTo->expired = 1;
63895: }
63896: if( pFrom->isPrepareV2 && pFrom->expmask ){
63897: pFrom->expired = 1;
63898: }
63899: return sqlite3TransferBindings(pFromStmt, pToStmt);
63900: }
63901: #endif
63902:
63903: /*
63904: ** Return the sqlite3* database handle to which the prepared statement given
63905: ** in the argument belongs. This is the same database handle that was
63906: ** the first argument to the sqlite3_prepare() that was used to create
63907: ** the statement in the first place.
63908: */
63909: SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
63910: return pStmt ? ((Vdbe*)pStmt)->db : 0;
63911: }
63912:
63913: /*
63914: ** Return true if the prepared statement is guaranteed to not modify the
63915: ** database.
63916: */
63917: SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){
63918: return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
63919: }
63920:
63921: /*
63922: ** Return true if the prepared statement is in need of being reset.
63923: */
63924: SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){
63925: Vdbe *v = (Vdbe*)pStmt;
63926: return v!=0 && v->pc>0 && v->magic==VDBE_MAGIC_RUN;
63927: }
63928:
63929: /*
63930: ** Return a pointer to the next prepared statement after pStmt associated
63931: ** with database connection pDb. If pStmt is NULL, return the first
63932: ** prepared statement for the database connection. Return NULL if there
63933: ** are no more.
63934: */
63935: SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
63936: sqlite3_stmt *pNext;
63937: sqlite3_mutex_enter(pDb->mutex);
63938: if( pStmt==0 ){
63939: pNext = (sqlite3_stmt*)pDb->pVdbe;
63940: }else{
63941: pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
63942: }
63943: sqlite3_mutex_leave(pDb->mutex);
63944: return pNext;
63945: }
63946:
63947: /*
63948: ** Return the value of a status counter for a prepared statement
63949: */
63950: SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
63951: Vdbe *pVdbe = (Vdbe*)pStmt;
63952: int v = pVdbe->aCounter[op-1];
63953: if( resetFlag ) pVdbe->aCounter[op-1] = 0;
63954: return v;
63955: }
63956:
63957: /************** End of vdbeapi.c *********************************************/
63958: /************** Begin file vdbetrace.c ***************************************/
63959: /*
63960: ** 2009 November 25
63961: **
63962: ** The author disclaims copyright to this source code. In place of
63963: ** a legal notice, here is a blessing:
63964: **
63965: ** May you do good and not evil.
63966: ** May you find forgiveness for yourself and forgive others.
63967: ** May you share freely, never taking more than you give.
63968: **
63969: *************************************************************************
63970: **
63971: ** This file contains code used to insert the values of host parameters
63972: ** (aka "wildcards") into the SQL text output by sqlite3_trace().
63973: **
63974: ** The Vdbe parse-tree explainer is also found here.
63975: */
63976:
63977: #ifndef SQLITE_OMIT_TRACE
63978:
63979: /*
63980: ** zSql is a zero-terminated string of UTF-8 SQL text. Return the number of
63981: ** bytes in this text up to but excluding the first character in
63982: ** a host parameter. If the text contains no host parameters, return
63983: ** the total number of bytes in the text.
63984: */
63985: static int findNextHostParameter(const char *zSql, int *pnToken){
63986: int tokenType;
63987: int nTotal = 0;
63988: int n;
63989:
63990: *pnToken = 0;
63991: while( zSql[0] ){
63992: n = sqlite3GetToken((u8*)zSql, &tokenType);
63993: assert( n>0 && tokenType!=TK_ILLEGAL );
63994: if( tokenType==TK_VARIABLE ){
63995: *pnToken = n;
63996: break;
63997: }
63998: nTotal += n;
63999: zSql += n;
64000: }
64001: return nTotal;
64002: }
64003:
64004: /*
64005: ** This function returns a pointer to a nul-terminated string in memory
64006: ** obtained from sqlite3DbMalloc(). If sqlite3.vdbeExecCnt is 1, then the
64007: ** string contains a copy of zRawSql but with host parameters expanded to
64008: ** their current bindings. Or, if sqlite3.vdbeExecCnt is greater than 1,
64009: ** then the returned string holds a copy of zRawSql with "-- " prepended
64010: ** to each line of text.
64011: **
64012: ** The calling function is responsible for making sure the memory returned
64013: ** is eventually freed.
64014: **
64015: ** ALGORITHM: Scan the input string looking for host parameters in any of
64016: ** these forms: ?, ?N, $A, @A, :A. Take care to avoid text within
64017: ** string literals, quoted identifier names, and comments. For text forms,
64018: ** the host parameter index is found by scanning the perpared
64019: ** statement for the corresponding OP_Variable opcode. Once the host
64020: ** parameter index is known, locate the value in p->aVar[]. Then render
64021: ** the value as a literal in place of the host parameter name.
64022: */
64023: SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
64024: Vdbe *p, /* The prepared statement being evaluated */
64025: const char *zRawSql /* Raw text of the SQL statement */
64026: ){
64027: sqlite3 *db; /* The database connection */
64028: int idx = 0; /* Index of a host parameter */
64029: int nextIndex = 1; /* Index of next ? host parameter */
64030: int n; /* Length of a token prefix */
64031: int nToken; /* Length of the parameter token */
64032: int i; /* Loop counter */
64033: Mem *pVar; /* Value of a host parameter */
64034: StrAccum out; /* Accumulate the output here */
64035: char zBase[100]; /* Initial working space */
64036:
64037: db = p->db;
64038: sqlite3StrAccumInit(&out, zBase, sizeof(zBase),
64039: db->aLimit[SQLITE_LIMIT_LENGTH]);
64040: out.db = db;
64041: if( db->vdbeExecCnt>1 ){
64042: while( *zRawSql ){
64043: const char *zStart = zRawSql;
64044: while( *(zRawSql++)!='\n' && *zRawSql );
64045: sqlite3StrAccumAppend(&out, "-- ", 3);
64046: sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));
64047: }
64048: }else{
64049: while( zRawSql[0] ){
64050: n = findNextHostParameter(zRawSql, &nToken);
64051: assert( n>0 );
64052: sqlite3StrAccumAppend(&out, zRawSql, n);
64053: zRawSql += n;
64054: assert( zRawSql[0] || nToken==0 );
64055: if( nToken==0 ) break;
64056: if( zRawSql[0]=='?' ){
64057: if( nToken>1 ){
64058: assert( sqlite3Isdigit(zRawSql[1]) );
64059: sqlite3GetInt32(&zRawSql[1], &idx);
64060: }else{
64061: idx = nextIndex;
64062: }
64063: }else{
64064: assert( zRawSql[0]==':' || zRawSql[0]=='$' || zRawSql[0]=='@' );
64065: testcase( zRawSql[0]==':' );
64066: testcase( zRawSql[0]=='$' );
64067: testcase( zRawSql[0]=='@' );
64068: idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken);
64069: assert( idx>0 );
64070: }
64071: zRawSql += nToken;
64072: nextIndex = idx + 1;
64073: assert( idx>0 && idx<=p->nVar );
64074: pVar = &p->aVar[idx-1];
64075: if( pVar->flags & MEM_Null ){
64076: sqlite3StrAccumAppend(&out, "NULL", 4);
64077: }else if( pVar->flags & MEM_Int ){
64078: sqlite3XPrintf(&out, "%lld", pVar->u.i);
64079: }else if( pVar->flags & MEM_Real ){
64080: sqlite3XPrintf(&out, "%!.15g", pVar->r);
64081: }else if( pVar->flags & MEM_Str ){
64082: #ifndef SQLITE_OMIT_UTF16
64083: u8 enc = ENC(db);
64084: if( enc!=SQLITE_UTF8 ){
64085: Mem utf8;
64086: memset(&utf8, 0, sizeof(utf8));
64087: utf8.db = db;
64088: sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
64089: sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8);
64090: sqlite3XPrintf(&out, "'%.*q'", utf8.n, utf8.z);
64091: sqlite3VdbeMemRelease(&utf8);
64092: }else
64093: #endif
64094: {
64095: sqlite3XPrintf(&out, "'%.*q'", pVar->n, pVar->z);
64096: }
64097: }else if( pVar->flags & MEM_Zero ){
64098: sqlite3XPrintf(&out, "zeroblob(%d)", pVar->u.nZero);
64099: }else{
64100: assert( pVar->flags & MEM_Blob );
64101: sqlite3StrAccumAppend(&out, "x'", 2);
64102: for(i=0; i<pVar->n; i++){
64103: sqlite3XPrintf(&out, "%02x", pVar->z[i]&0xff);
64104: }
64105: sqlite3StrAccumAppend(&out, "'", 1);
64106: }
64107: }
64108: }
64109: return sqlite3StrAccumFinish(&out);
64110: }
64111:
64112: #endif /* #ifndef SQLITE_OMIT_TRACE */
64113:
64114: /*****************************************************************************
64115: ** The following code implements the data-structure explaining logic
64116: ** for the Vdbe.
64117: */
64118:
64119: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
64120:
64121: /*
64122: ** Allocate a new Explain object
64123: */
64124: SQLITE_PRIVATE void sqlite3ExplainBegin(Vdbe *pVdbe){
64125: if( pVdbe ){
64126: sqlite3BeginBenignMalloc();
64127: Explain *p = sqlite3_malloc( sizeof(Explain) );
64128: if( p ){
64129: memset(p, 0, sizeof(*p));
64130: p->pVdbe = pVdbe;
64131: sqlite3_free(pVdbe->pExplain);
64132: pVdbe->pExplain = p;
64133: sqlite3StrAccumInit(&p->str, p->zBase, sizeof(p->zBase),
64134: SQLITE_MAX_LENGTH);
64135: p->str.useMalloc = 2;
64136: }else{
64137: sqlite3EndBenignMalloc();
64138: }
64139: }
64140: }
64141:
64142: /*
64143: ** Return true if the Explain ends with a new-line.
64144: */
64145: static int endsWithNL(Explain *p){
64146: return p && p->str.zText && p->str.nChar
64147: && p->str.zText[p->str.nChar-1]=='\n';
64148: }
64149:
64150: /*
64151: ** Append text to the indentation
64152: */
64153: SQLITE_PRIVATE void sqlite3ExplainPrintf(Vdbe *pVdbe, const char *zFormat, ...){
64154: Explain *p;
64155: if( pVdbe && (p = pVdbe->pExplain)!=0 ){
64156: va_list ap;
64157: if( p->nIndent && endsWithNL(p) ){
64158: int n = p->nIndent;
64159: if( n>ArraySize(p->aIndent) ) n = ArraySize(p->aIndent);
64160: sqlite3AppendSpace(&p->str, p->aIndent[n-1]);
64161: }
64162: va_start(ap, zFormat);
64163: sqlite3VXPrintf(&p->str, 1, zFormat, ap);
64164: va_end(ap);
64165: }
64166: }
64167:
64168: /*
64169: ** Append a '\n' if there is not already one.
64170: */
64171: SQLITE_PRIVATE void sqlite3ExplainNL(Vdbe *pVdbe){
64172: Explain *p;
64173: if( pVdbe && (p = pVdbe->pExplain)!=0 && !endsWithNL(p) ){
64174: sqlite3StrAccumAppend(&p->str, "\n", 1);
64175: }
64176: }
64177:
64178: /*
64179: ** Push a new indentation level. Subsequent lines will be indented
64180: ** so that they begin at the current cursor position.
64181: */
64182: SQLITE_PRIVATE void sqlite3ExplainPush(Vdbe *pVdbe){
64183: Explain *p;
64184: if( pVdbe && (p = pVdbe->pExplain)!=0 ){
64185: if( p->str.zText && p->nIndent<ArraySize(p->aIndent) ){
64186: const char *z = p->str.zText;
64187: int i = p->str.nChar-1;
64188: int x;
64189: while( i>=0 && z[i]!='\n' ){ i--; }
64190: x = (p->str.nChar - 1) - i;
64191: if( p->nIndent && x<p->aIndent[p->nIndent-1] ){
64192: x = p->aIndent[p->nIndent-1];
64193: }
64194: p->aIndent[p->nIndent] = x;
64195: }
64196: p->nIndent++;
64197: }
64198: }
64199:
64200: /*
64201: ** Pop the indentation stack by one level.
64202: */
64203: SQLITE_PRIVATE void sqlite3ExplainPop(Vdbe *p){
64204: if( p && p->pExplain ) p->pExplain->nIndent--;
64205: }
64206:
64207: /*
64208: ** Free the indentation structure
64209: */
64210: SQLITE_PRIVATE void sqlite3ExplainFinish(Vdbe *pVdbe){
64211: if( pVdbe && pVdbe->pExplain ){
64212: sqlite3_free(pVdbe->zExplain);
64213: sqlite3ExplainNL(pVdbe);
64214: pVdbe->zExplain = sqlite3StrAccumFinish(&pVdbe->pExplain->str);
64215: sqlite3_free(pVdbe->pExplain);
64216: pVdbe->pExplain = 0;
64217: sqlite3EndBenignMalloc();
64218: }
64219: }
64220:
64221: /*
64222: ** Return the explanation of a virtual machine.
64223: */
64224: SQLITE_PRIVATE const char *sqlite3VdbeExplanation(Vdbe *pVdbe){
64225: return (pVdbe && pVdbe->zExplain) ? pVdbe->zExplain : 0;
64226: }
64227: #endif /* defined(SQLITE_DEBUG) */
64228:
64229: /************** End of vdbetrace.c *******************************************/
64230: /************** Begin file vdbe.c ********************************************/
64231: /*
64232: ** 2001 September 15
64233: **
64234: ** The author disclaims copyright to this source code. In place of
64235: ** a legal notice, here is a blessing:
64236: **
64237: ** May you do good and not evil.
64238: ** May you find forgiveness for yourself and forgive others.
64239: ** May you share freely, never taking more than you give.
64240: **
64241: *************************************************************************
64242: ** The code in this file implements execution method of the
64243: ** Virtual Database Engine (VDBE). A separate file ("vdbeaux.c")
64244: ** handles housekeeping details such as creating and deleting
64245: ** VDBE instances. This file is solely interested in executing
64246: ** the VDBE program.
64247: **
64248: ** In the external interface, an "sqlite3_stmt*" is an opaque pointer
64249: ** to a VDBE.
64250: **
64251: ** The SQL parser generates a program which is then executed by
64252: ** the VDBE to do the work of the SQL statement. VDBE programs are
64253: ** similar in form to assembly language. The program consists of
64254: ** a linear sequence of operations. Each operation has an opcode
64255: ** and 5 operands. Operands P1, P2, and P3 are integers. Operand P4
64256: ** is a null-terminated string. Operand P5 is an unsigned character.
64257: ** Few opcodes use all 5 operands.
64258: **
64259: ** Computation results are stored on a set of registers numbered beginning
64260: ** with 1 and going up to Vdbe.nMem. Each register can store
64261: ** either an integer, a null-terminated string, a floating point
64262: ** number, or the SQL "NULL" value. An implicit conversion from one
64263: ** type to the other occurs as necessary.
64264: **
64265: ** Most of the code in this file is taken up by the sqlite3VdbeExec()
64266: ** function which does the work of interpreting a VDBE program.
64267: ** But other routines are also provided to help in building up
64268: ** a program instruction by instruction.
64269: **
64270: ** Various scripts scan this source file in order to generate HTML
64271: ** documentation, headers files, or other derived files. The formatting
64272: ** of the code in this file is, therefore, important. See other comments
64273: ** in this file for details. If in doubt, do not deviate from existing
64274: ** commenting and indentation practices when changing or adding code.
64275: */
64276:
64277: /*
64278: ** Invoke this macro on memory cells just prior to changing the
64279: ** value of the cell. This macro verifies that shallow copies are
64280: ** not misused.
64281: */
64282: #ifdef SQLITE_DEBUG
64283: # define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M)
64284: #else
64285: # define memAboutToChange(P,M)
64286: #endif
64287:
64288: /*
64289: ** The following global variable is incremented every time a cursor
64290: ** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes. The test
64291: ** procedures use this information to make sure that indices are
64292: ** working correctly. This variable has no function other than to
64293: ** help verify the correct operation of the library.
64294: */
64295: #ifdef SQLITE_TEST
64296: SQLITE_API int sqlite3_search_count = 0;
64297: #endif
64298:
64299: /*
64300: ** When this global variable is positive, it gets decremented once before
64301: ** each instruction in the VDBE. When it reaches zero, the u1.isInterrupted
64302: ** field of the sqlite3 structure is set in order to simulate an interrupt.
64303: **
64304: ** This facility is used for testing purposes only. It does not function
64305: ** in an ordinary build.
64306: */
64307: #ifdef SQLITE_TEST
64308: SQLITE_API int sqlite3_interrupt_count = 0;
64309: #endif
64310:
64311: /*
64312: ** The next global variable is incremented each type the OP_Sort opcode
64313: ** is executed. The test procedures use this information to make sure that
64314: ** sorting is occurring or not occurring at appropriate times. This variable
64315: ** has no function other than to help verify the correct operation of the
64316: ** library.
64317: */
64318: #ifdef SQLITE_TEST
64319: SQLITE_API int sqlite3_sort_count = 0;
64320: #endif
64321:
64322: /*
64323: ** The next global variable records the size of the largest MEM_Blob
64324: ** or MEM_Str that has been used by a VDBE opcode. The test procedures
64325: ** use this information to make sure that the zero-blob functionality
64326: ** is working correctly. This variable has no function other than to
64327: ** help verify the correct operation of the library.
64328: */
64329: #ifdef SQLITE_TEST
64330: SQLITE_API int sqlite3_max_blobsize = 0;
64331: static void updateMaxBlobsize(Mem *p){
64332: if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
64333: sqlite3_max_blobsize = p->n;
64334: }
64335: }
64336: #endif
64337:
64338: /*
64339: ** The next global variable is incremented each type the OP_Found opcode
64340: ** is executed. This is used to test whether or not the foreign key
64341: ** operation implemented using OP_FkIsZero is working. This variable
64342: ** has no function other than to help verify the correct operation of the
64343: ** library.
64344: */
64345: #ifdef SQLITE_TEST
64346: SQLITE_API int sqlite3_found_count = 0;
64347: #endif
64348:
64349: /*
64350: ** Test a register to see if it exceeds the current maximum blob size.
64351: ** If it does, record the new maximum blob size.
64352: */
64353: #if defined(SQLITE_TEST) && !defined(SQLITE_OMIT_BUILTIN_TEST)
64354: # define UPDATE_MAX_BLOBSIZE(P) updateMaxBlobsize(P)
64355: #else
64356: # define UPDATE_MAX_BLOBSIZE(P)
64357: #endif
64358:
64359: /*
64360: ** Convert the given register into a string if it isn't one
64361: ** already. Return non-zero if a malloc() fails.
64362: */
64363: #define Stringify(P, enc) \
64364: if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc)) \
64365: { goto no_mem; }
64366:
64367: /*
64368: ** An ephemeral string value (signified by the MEM_Ephem flag) contains
64369: ** a pointer to a dynamically allocated string where some other entity
64370: ** is responsible for deallocating that string. Because the register
64371: ** does not control the string, it might be deleted without the register
64372: ** knowing it.
64373: **
64374: ** This routine converts an ephemeral string into a dynamically allocated
64375: ** string that the register itself controls. In other words, it
64376: ** converts an MEM_Ephem string into an MEM_Dyn string.
64377: */
64378: #define Deephemeralize(P) \
64379: if( ((P)->flags&MEM_Ephem)!=0 \
64380: && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
64381:
64382: /* Return true if the cursor was opened using the OP_OpenSorter opcode. */
64383: #ifdef SQLITE_OMIT_MERGE_SORT
64384: # define isSorter(x) 0
64385: #else
64386: # define isSorter(x) ((x)->pSorter!=0)
64387: #endif
64388:
64389: /*
64390: ** Argument pMem points at a register that will be passed to a
64391: ** user-defined function or returned to the user as the result of a query.
64392: ** This routine sets the pMem->type variable used by the sqlite3_value_*()
64393: ** routines.
64394: */
64395: SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem){
64396: int flags = pMem->flags;
64397: if( flags & MEM_Null ){
64398: pMem->type = SQLITE_NULL;
64399: }
64400: else if( flags & MEM_Int ){
64401: pMem->type = SQLITE_INTEGER;
64402: }
64403: else if( flags & MEM_Real ){
64404: pMem->type = SQLITE_FLOAT;
64405: }
64406: else if( flags & MEM_Str ){
64407: pMem->type = SQLITE_TEXT;
64408: }else{
64409: pMem->type = SQLITE_BLOB;
64410: }
64411: }
64412:
64413: /*
64414: ** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL
64415: ** if we run out of memory.
64416: */
64417: static VdbeCursor *allocateCursor(
64418: Vdbe *p, /* The virtual machine */
64419: int iCur, /* Index of the new VdbeCursor */
64420: int nField, /* Number of fields in the table or index */
64421: int iDb, /* Database the cursor belongs to, or -1 */
64422: int isBtreeCursor /* True for B-Tree. False for pseudo-table or vtab */
64423: ){
64424: /* Find the memory cell that will be used to store the blob of memory
64425: ** required for this VdbeCursor structure. It is convenient to use a
64426: ** vdbe memory cell to manage the memory allocation required for a
64427: ** VdbeCursor structure for the following reasons:
64428: **
64429: ** * Sometimes cursor numbers are used for a couple of different
64430: ** purposes in a vdbe program. The different uses might require
64431: ** different sized allocations. Memory cells provide growable
64432: ** allocations.
64433: **
64434: ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
64435: ** be freed lazily via the sqlite3_release_memory() API. This
64436: ** minimizes the number of malloc calls made by the system.
64437: **
64438: ** Memory cells for cursors are allocated at the top of the address
64439: ** space. Memory cell (p->nMem) corresponds to cursor 0. Space for
64440: ** cursor 1 is managed by memory cell (p->nMem-1), etc.
64441: */
64442: Mem *pMem = &p->aMem[p->nMem-iCur];
64443:
64444: int nByte;
64445: VdbeCursor *pCx = 0;
64446: nByte =
64447: ROUND8(sizeof(VdbeCursor)) +
64448: (isBtreeCursor?sqlite3BtreeCursorSize():0) +
64449: 2*nField*sizeof(u32);
64450:
64451: assert( iCur<p->nCursor );
64452: if( p->apCsr[iCur] ){
64453: sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
64454: p->apCsr[iCur] = 0;
64455: }
64456: if( SQLITE_OK==sqlite3VdbeMemGrow(pMem, nByte, 0) ){
64457: p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z;
64458: memset(pCx, 0, sizeof(VdbeCursor));
64459: pCx->iDb = iDb;
64460: pCx->nField = nField;
64461: if( nField ){
64462: pCx->aType = (u32 *)&pMem->z[ROUND8(sizeof(VdbeCursor))];
64463: }
64464: if( isBtreeCursor ){
64465: pCx->pCursor = (BtCursor*)
64466: &pMem->z[ROUND8(sizeof(VdbeCursor))+2*nField*sizeof(u32)];
64467: sqlite3BtreeCursorZero(pCx->pCursor);
64468: }
64469: }
64470: return pCx;
64471: }
64472:
64473: /*
64474: ** Try to convert a value into a numeric representation if we can
64475: ** do so without loss of information. In other words, if the string
64476: ** looks like a number, convert it into a number. If it does not
64477: ** look like a number, leave it alone.
64478: */
64479: static void applyNumericAffinity(Mem *pRec){
64480: if( (pRec->flags & (MEM_Real|MEM_Int))==0 ){
64481: double rValue;
64482: i64 iValue;
64483: u8 enc = pRec->enc;
64484: if( (pRec->flags&MEM_Str)==0 ) return;
64485: if( sqlite3AtoF(pRec->z, &rValue, pRec->n, enc)==0 ) return;
64486: if( 0==sqlite3Atoi64(pRec->z, &iValue, pRec->n, enc) ){
64487: pRec->u.i = iValue;
64488: pRec->flags |= MEM_Int;
64489: }else{
64490: pRec->r = rValue;
64491: pRec->flags |= MEM_Real;
64492: }
64493: }
64494: }
64495:
64496: /*
64497: ** Processing is determine by the affinity parameter:
64498: **
64499: ** SQLITE_AFF_INTEGER:
64500: ** SQLITE_AFF_REAL:
64501: ** SQLITE_AFF_NUMERIC:
64502: ** Try to convert pRec to an integer representation or a
64503: ** floating-point representation if an integer representation
64504: ** is not possible. Note that the integer representation is
64505: ** always preferred, even if the affinity is REAL, because
64506: ** an integer representation is more space efficient on disk.
64507: **
64508: ** SQLITE_AFF_TEXT:
64509: ** Convert pRec to a text representation.
64510: **
64511: ** SQLITE_AFF_NONE:
64512: ** No-op. pRec is unchanged.
64513: */
64514: static void applyAffinity(
64515: Mem *pRec, /* The value to apply affinity to */
64516: char affinity, /* The affinity to be applied */
64517: u8 enc /* Use this text encoding */
64518: ){
64519: if( affinity==SQLITE_AFF_TEXT ){
64520: /* Only attempt the conversion to TEXT if there is an integer or real
64521: ** representation (blob and NULL do not get converted) but no string
64522: ** representation.
64523: */
64524: if( 0==(pRec->flags&MEM_Str) && (pRec->flags&(MEM_Real|MEM_Int)) ){
64525: sqlite3VdbeMemStringify(pRec, enc);
64526: }
64527: pRec->flags &= ~(MEM_Real|MEM_Int);
64528: }else if( affinity!=SQLITE_AFF_NONE ){
64529: assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
64530: || affinity==SQLITE_AFF_NUMERIC );
64531: applyNumericAffinity(pRec);
64532: if( pRec->flags & MEM_Real ){
64533: sqlite3VdbeIntegerAffinity(pRec);
64534: }
64535: }
64536: }
64537:
64538: /*
64539: ** Try to convert the type of a function argument or a result column
64540: ** into a numeric representation. Use either INTEGER or REAL whichever
64541: ** is appropriate. But only do the conversion if it is possible without
64542: ** loss of information and return the revised type of the argument.
64543: */
64544: SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){
64545: Mem *pMem = (Mem*)pVal;
64546: if( pMem->type==SQLITE_TEXT ){
64547: applyNumericAffinity(pMem);
64548: sqlite3VdbeMemStoreType(pMem);
64549: }
64550: return pMem->type;
64551: }
64552:
64553: /*
64554: ** Exported version of applyAffinity(). This one works on sqlite3_value*,
64555: ** not the internal Mem* type.
64556: */
64557: SQLITE_PRIVATE void sqlite3ValueApplyAffinity(
64558: sqlite3_value *pVal,
64559: u8 affinity,
64560: u8 enc
64561: ){
64562: applyAffinity((Mem *)pVal, affinity, enc);
64563: }
64564:
64565: #ifdef SQLITE_DEBUG
64566: /*
64567: ** Write a nice string representation of the contents of cell pMem
64568: ** into buffer zBuf, length nBuf.
64569: */
64570: SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
64571: char *zCsr = zBuf;
64572: int f = pMem->flags;
64573:
64574: static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"};
64575:
64576: if( f&MEM_Blob ){
64577: int i;
64578: char c;
64579: if( f & MEM_Dyn ){
64580: c = 'z';
64581: assert( (f & (MEM_Static|MEM_Ephem))==0 );
64582: }else if( f & MEM_Static ){
64583: c = 't';
64584: assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
64585: }else if( f & MEM_Ephem ){
64586: c = 'e';
64587: assert( (f & (MEM_Static|MEM_Dyn))==0 );
64588: }else{
64589: c = 's';
64590: }
64591:
64592: sqlite3_snprintf(100, zCsr, "%c", c);
64593: zCsr += sqlite3Strlen30(zCsr);
64594: sqlite3_snprintf(100, zCsr, "%d[", pMem->n);
64595: zCsr += sqlite3Strlen30(zCsr);
64596: for(i=0; i<16 && i<pMem->n; i++){
64597: sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF));
64598: zCsr += sqlite3Strlen30(zCsr);
64599: }
64600: for(i=0; i<16 && i<pMem->n; i++){
64601: char z = pMem->z[i];
64602: if( z<32 || z>126 ) *zCsr++ = '.';
64603: else *zCsr++ = z;
64604: }
64605:
64606: sqlite3_snprintf(100, zCsr, "]%s", encnames[pMem->enc]);
64607: zCsr += sqlite3Strlen30(zCsr);
64608: if( f & MEM_Zero ){
64609: sqlite3_snprintf(100, zCsr,"+%dz",pMem->u.nZero);
64610: zCsr += sqlite3Strlen30(zCsr);
64611: }
64612: *zCsr = '\0';
64613: }else if( f & MEM_Str ){
64614: int j, k;
64615: zBuf[0] = ' ';
64616: if( f & MEM_Dyn ){
64617: zBuf[1] = 'z';
64618: assert( (f & (MEM_Static|MEM_Ephem))==0 );
64619: }else if( f & MEM_Static ){
64620: zBuf[1] = 't';
64621: assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
64622: }else if( f & MEM_Ephem ){
64623: zBuf[1] = 'e';
64624: assert( (f & (MEM_Static|MEM_Dyn))==0 );
64625: }else{
64626: zBuf[1] = 's';
64627: }
64628: k = 2;
64629: sqlite3_snprintf(100, &zBuf[k], "%d", pMem->n);
64630: k += sqlite3Strlen30(&zBuf[k]);
64631: zBuf[k++] = '[';
64632: for(j=0; j<15 && j<pMem->n; j++){
64633: u8 c = pMem->z[j];
64634: if( c>=0x20 && c<0x7f ){
64635: zBuf[k++] = c;
64636: }else{
64637: zBuf[k++] = '.';
64638: }
64639: }
64640: zBuf[k++] = ']';
64641: sqlite3_snprintf(100,&zBuf[k], encnames[pMem->enc]);
64642: k += sqlite3Strlen30(&zBuf[k]);
64643: zBuf[k++] = 0;
64644: }
64645: }
64646: #endif
64647:
64648: #ifdef SQLITE_DEBUG
64649: /*
64650: ** Print the value of a register for tracing purposes:
64651: */
64652: static void memTracePrint(FILE *out, Mem *p){
64653: if( p->flags & MEM_Null ){
64654: fprintf(out, " NULL");
64655: }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
64656: fprintf(out, " si:%lld", p->u.i);
64657: }else if( p->flags & MEM_Int ){
64658: fprintf(out, " i:%lld", p->u.i);
64659: #ifndef SQLITE_OMIT_FLOATING_POINT
64660: }else if( p->flags & MEM_Real ){
64661: fprintf(out, " r:%g", p->r);
64662: #endif
64663: }else if( p->flags & MEM_RowSet ){
64664: fprintf(out, " (rowset)");
64665: }else{
64666: char zBuf[200];
64667: sqlite3VdbeMemPrettyPrint(p, zBuf);
64668: fprintf(out, " ");
64669: fprintf(out, "%s", zBuf);
64670: }
64671: }
64672: static void registerTrace(FILE *out, int iReg, Mem *p){
64673: fprintf(out, "REG[%d] = ", iReg);
64674: memTracePrint(out, p);
64675: fprintf(out, "\n");
64676: }
64677: #endif
64678:
64679: #ifdef SQLITE_DEBUG
64680: # define REGISTER_TRACE(R,M) if(p->trace)registerTrace(p->trace,R,M)
64681: #else
64682: # define REGISTER_TRACE(R,M)
64683: #endif
64684:
64685:
64686: #ifdef VDBE_PROFILE
64687:
64688: /*
64689: ** hwtime.h contains inline assembler code for implementing
64690: ** high-performance timing routines.
64691: */
64692: /************** Include hwtime.h in the middle of vdbe.c *********************/
64693: /************** Begin file hwtime.h ******************************************/
64694: /*
64695: ** 2008 May 27
64696: **
64697: ** The author disclaims copyright to this source code. In place of
64698: ** a legal notice, here is a blessing:
64699: **
64700: ** May you do good and not evil.
64701: ** May you find forgiveness for yourself and forgive others.
64702: ** May you share freely, never taking more than you give.
64703: **
64704: ******************************************************************************
64705: **
64706: ** This file contains inline asm code for retrieving "high-performance"
64707: ** counters for x86 class CPUs.
64708: */
64709: #ifndef _HWTIME_H_
64710: #define _HWTIME_H_
64711:
64712: /*
64713: ** The following routine only works on pentium-class (or newer) processors.
64714: ** It uses the RDTSC opcode to read the cycle count value out of the
64715: ** processor and returns that value. This can be used for high-res
64716: ** profiling.
64717: */
64718: #if (defined(__GNUC__) || defined(_MSC_VER)) && \
64719: (defined(i386) || defined(__i386__) || defined(_M_IX86))
64720:
64721: #if defined(__GNUC__)
64722:
64723: __inline__ sqlite_uint64 sqlite3Hwtime(void){
64724: unsigned int lo, hi;
64725: __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
64726: return (sqlite_uint64)hi << 32 | lo;
64727: }
64728:
64729: #elif defined(_MSC_VER)
64730:
64731: __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(void){
64732: __asm {
64733: rdtsc
64734: ret ; return value at EDX:EAX
64735: }
64736: }
64737:
64738: #endif
64739:
64740: #elif (defined(__GNUC__) && defined(__x86_64__))
64741:
64742: __inline__ sqlite_uint64 sqlite3Hwtime(void){
64743: unsigned long val;
64744: __asm__ __volatile__ ("rdtsc" : "=A" (val));
64745: return val;
64746: }
64747:
64748: #elif (defined(__GNUC__) && defined(__ppc__))
64749:
64750: __inline__ sqlite_uint64 sqlite3Hwtime(void){
64751: unsigned long long retval;
64752: unsigned long junk;
64753: __asm__ __volatile__ ("\n\
64754: 1: mftbu %1\n\
64755: mftb %L0\n\
64756: mftbu %0\n\
64757: cmpw %0,%1\n\
64758: bne 1b"
64759: : "=r" (retval), "=r" (junk));
64760: return retval;
64761: }
64762:
64763: #else
64764:
64765: #error Need implementation of sqlite3Hwtime() for your platform.
64766:
64767: /*
64768: ** To compile without implementing sqlite3Hwtime() for your platform,
64769: ** you can remove the above #error and use the following
64770: ** stub function. You will lose timing support for many
64771: ** of the debugging and testing utilities, but it should at
64772: ** least compile and run.
64773: */
64774: SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(void){ return ((sqlite_uint64)0); }
64775:
64776: #endif
64777:
64778: #endif /* !defined(_HWTIME_H_) */
64779:
64780: /************** End of hwtime.h **********************************************/
64781: /************** Continuing where we left off in vdbe.c ***********************/
64782:
64783: #endif
64784:
64785: /*
64786: ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
64787: ** sqlite3_interrupt() routine has been called. If it has been, then
64788: ** processing of the VDBE program is interrupted.
64789: **
64790: ** This macro added to every instruction that does a jump in order to
64791: ** implement a loop. This test used to be on every single instruction,
64792: ** but that meant we more testing than we needed. By only testing the
64793: ** flag on jump instructions, we get a (small) speed improvement.
64794: */
64795: #define CHECK_FOR_INTERRUPT \
64796: if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
64797:
64798:
64799: #ifndef NDEBUG
64800: /*
64801: ** This function is only called from within an assert() expression. It
64802: ** checks that the sqlite3.nTransaction variable is correctly set to
64803: ** the number of non-transaction savepoints currently in the
64804: ** linked list starting at sqlite3.pSavepoint.
64805: **
64806: ** Usage:
64807: **
64808: ** assert( checkSavepointCount(db) );
64809: */
64810: static int checkSavepointCount(sqlite3 *db){
64811: int n = 0;
64812: Savepoint *p;
64813: for(p=db->pSavepoint; p; p=p->pNext) n++;
64814: assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
64815: return 1;
64816: }
64817: #endif
64818:
64819: /*
64820: ** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored
64821: ** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored
64822: ** in memory obtained from sqlite3DbMalloc).
64823: */
64824: static void importVtabErrMsg(Vdbe *p, sqlite3_vtab *pVtab){
64825: sqlite3 *db = p->db;
64826: sqlite3DbFree(db, p->zErrMsg);
64827: p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
64828: sqlite3_free(pVtab->zErrMsg);
64829: pVtab->zErrMsg = 0;
64830: }
64831:
64832:
64833: /*
64834: ** Execute as much of a VDBE program as we can then return.
64835: **
64836: ** sqlite3VdbeMakeReady() must be called before this routine in order to
64837: ** close the program with a final OP_Halt and to set up the callbacks
64838: ** and the error message pointer.
64839: **
64840: ** Whenever a row or result data is available, this routine will either
64841: ** invoke the result callback (if there is one) or return with
64842: ** SQLITE_ROW.
64843: **
64844: ** If an attempt is made to open a locked database, then this routine
64845: ** will either invoke the busy callback (if there is one) or it will
64846: ** return SQLITE_BUSY.
64847: **
64848: ** If an error occurs, an error message is written to memory obtained
64849: ** from sqlite3_malloc() and p->zErrMsg is made to point to that memory.
64850: ** The error code is stored in p->rc and this routine returns SQLITE_ERROR.
64851: **
64852: ** If the callback ever returns non-zero, then the program exits
64853: ** immediately. There will be no error message but the p->rc field is
64854: ** set to SQLITE_ABORT and this routine will return SQLITE_ERROR.
64855: **
64856: ** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this
64857: ** routine to return SQLITE_ERROR.
64858: **
64859: ** Other fatal errors return SQLITE_ERROR.
64860: **
64861: ** After this routine has finished, sqlite3VdbeFinalize() should be
64862: ** used to clean up the mess that was left behind.
64863: */
64864: SQLITE_PRIVATE int sqlite3VdbeExec(
64865: Vdbe *p /* The VDBE */
64866: ){
64867: int pc=0; /* The program counter */
64868: Op *aOp = p->aOp; /* Copy of p->aOp */
64869: Op *pOp; /* Current operation */
64870: int rc = SQLITE_OK; /* Value to return */
64871: sqlite3 *db = p->db; /* The database */
64872: u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */
64873: u8 encoding = ENC(db); /* The database encoding */
64874: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
64875: int checkProgress; /* True if progress callbacks are enabled */
64876: int nProgressOps = 0; /* Opcodes executed since progress callback. */
64877: #endif
64878: Mem *aMem = p->aMem; /* Copy of p->aMem */
64879: Mem *pIn1 = 0; /* 1st input operand */
64880: Mem *pIn2 = 0; /* 2nd input operand */
64881: Mem *pIn3 = 0; /* 3rd input operand */
64882: Mem *pOut = 0; /* Output operand */
64883: int iCompare = 0; /* Result of last OP_Compare operation */
64884: int *aPermute = 0; /* Permutation of columns for OP_Compare */
64885: i64 lastRowid = db->lastRowid; /* Saved value of the last insert ROWID */
64886: #ifdef VDBE_PROFILE
64887: u64 start; /* CPU clock count at start of opcode */
64888: int origPc; /* Program counter at start of opcode */
64889: #endif
64890: /********************************************************************
64891: ** Automatically generated code
64892: **
64893: ** The following union is automatically generated by the
64894: ** vdbe-compress.tcl script. The purpose of this union is to
64895: ** reduce the amount of stack space required by this function.
64896: ** See comments in the vdbe-compress.tcl script for details.
64897: */
64898: union vdbeExecUnion {
64899: struct OP_Yield_stack_vars {
64900: int pcDest;
64901: } aa;
64902: struct OP_Null_stack_vars {
64903: int cnt;
64904: } ab;
64905: struct OP_Variable_stack_vars {
64906: Mem *pVar; /* Value being transferred */
64907: } ac;
64908: struct OP_Move_stack_vars {
64909: char *zMalloc; /* Holding variable for allocated memory */
64910: int n; /* Number of registers left to copy */
64911: int p1; /* Register to copy from */
64912: int p2; /* Register to copy to */
64913: } ad;
64914: struct OP_ResultRow_stack_vars {
64915: Mem *pMem;
64916: int i;
64917: } ae;
64918: struct OP_Concat_stack_vars {
64919: i64 nByte;
64920: } af;
64921: struct OP_Remainder_stack_vars {
64922: int flags; /* Combined MEM_* flags from both inputs */
64923: i64 iA; /* Integer value of left operand */
64924: i64 iB; /* Integer value of right operand */
64925: double rA; /* Real value of left operand */
64926: double rB; /* Real value of right operand */
64927: } ag;
64928: struct OP_Function_stack_vars {
64929: int i;
64930: Mem *pArg;
64931: sqlite3_context ctx;
64932: sqlite3_value **apVal;
64933: int n;
64934: } ah;
64935: struct OP_ShiftRight_stack_vars {
64936: i64 iA;
64937: u64 uA;
64938: i64 iB;
64939: u8 op;
64940: } ai;
64941: struct OP_Ge_stack_vars {
64942: int res; /* Result of the comparison of pIn1 against pIn3 */
64943: char affinity; /* Affinity to use for comparison */
64944: u16 flags1; /* Copy of initial value of pIn1->flags */
64945: u16 flags3; /* Copy of initial value of pIn3->flags */
64946: } aj;
64947: struct OP_Compare_stack_vars {
64948: int n;
64949: int i;
64950: int p1;
64951: int p2;
64952: const KeyInfo *pKeyInfo;
64953: int idx;
64954: CollSeq *pColl; /* Collating sequence to use on this term */
64955: int bRev; /* True for DESCENDING sort order */
64956: } ak;
64957: struct OP_Or_stack_vars {
64958: int v1; /* Left operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
64959: int v2; /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
64960: } al;
64961: struct OP_IfNot_stack_vars {
64962: int c;
64963: } am;
64964: struct OP_Column_stack_vars {
64965: u32 payloadSize; /* Number of bytes in the record */
64966: i64 payloadSize64; /* Number of bytes in the record */
64967: int p1; /* P1 value of the opcode */
64968: int p2; /* column number to retrieve */
64969: VdbeCursor *pC; /* The VDBE cursor */
64970: char *zRec; /* Pointer to complete record-data */
64971: BtCursor *pCrsr; /* The BTree cursor */
64972: u32 *aType; /* aType[i] holds the numeric type of the i-th column */
64973: u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
64974: int nField; /* number of fields in the record */
64975: int len; /* The length of the serialized data for the column */
64976: int i; /* Loop counter */
64977: char *zData; /* Part of the record being decoded */
64978: Mem *pDest; /* Where to write the extracted value */
64979: Mem sMem; /* For storing the record being decoded */
64980: u8 *zIdx; /* Index into header */
64981: u8 *zEndHdr; /* Pointer to first byte after the header */
64982: u32 offset; /* Offset into the data */
64983: u32 szField; /* Number of bytes in the content of a field */
64984: int szHdr; /* Size of the header size field at start of record */
64985: int avail; /* Number of bytes of available data */
64986: u32 t; /* A type code from the record header */
64987: Mem *pReg; /* PseudoTable input register */
64988: } an;
64989: struct OP_Affinity_stack_vars {
64990: const char *zAffinity; /* The affinity to be applied */
64991: char cAff; /* A single character of affinity */
64992: } ao;
64993: struct OP_MakeRecord_stack_vars {
64994: u8 *zNewRecord; /* A buffer to hold the data for the new record */
64995: Mem *pRec; /* The new record */
64996: u64 nData; /* Number of bytes of data space */
64997: int nHdr; /* Number of bytes of header space */
64998: i64 nByte; /* Data space required for this record */
64999: int nZero; /* Number of zero bytes at the end of the record */
65000: int nVarint; /* Number of bytes in a varint */
65001: u32 serial_type; /* Type field */
65002: Mem *pData0; /* First field to be combined into the record */
65003: Mem *pLast; /* Last field of the record */
65004: int nField; /* Number of fields in the record */
65005: char *zAffinity; /* The affinity string for the record */
65006: int file_format; /* File format to use for encoding */
65007: int i; /* Space used in zNewRecord[] */
65008: int len; /* Length of a field */
65009: } ap;
65010: struct OP_Count_stack_vars {
65011: i64 nEntry;
65012: BtCursor *pCrsr;
65013: } aq;
65014: struct OP_Savepoint_stack_vars {
65015: int p1; /* Value of P1 operand */
65016: char *zName; /* Name of savepoint */
65017: int nName;
65018: Savepoint *pNew;
65019: Savepoint *pSavepoint;
65020: Savepoint *pTmp;
65021: int iSavepoint;
65022: int ii;
65023: } ar;
65024: struct OP_AutoCommit_stack_vars {
65025: int desiredAutoCommit;
65026: int iRollback;
65027: int turnOnAC;
65028: } as;
65029: struct OP_Transaction_stack_vars {
65030: Btree *pBt;
65031: } at;
65032: struct OP_ReadCookie_stack_vars {
65033: int iMeta;
65034: int iDb;
65035: int iCookie;
65036: } au;
65037: struct OP_SetCookie_stack_vars {
65038: Db *pDb;
65039: } av;
65040: struct OP_VerifyCookie_stack_vars {
65041: int iMeta;
65042: int iGen;
65043: Btree *pBt;
65044: } aw;
65045: struct OP_OpenWrite_stack_vars {
65046: int nField;
65047: KeyInfo *pKeyInfo;
65048: int p2;
65049: int iDb;
65050: int wrFlag;
65051: Btree *pX;
65052: VdbeCursor *pCur;
65053: Db *pDb;
65054: } ax;
65055: struct OP_OpenEphemeral_stack_vars {
65056: VdbeCursor *pCx;
65057: } ay;
65058: struct OP_SorterOpen_stack_vars {
65059: VdbeCursor *pCx;
65060: } az;
65061: struct OP_OpenPseudo_stack_vars {
65062: VdbeCursor *pCx;
65063: } ba;
65064: struct OP_SeekGt_stack_vars {
65065: int res;
65066: int oc;
65067: VdbeCursor *pC;
65068: UnpackedRecord r;
65069: int nField;
65070: i64 iKey; /* The rowid we are to seek to */
65071: } bb;
65072: struct OP_Seek_stack_vars {
65073: VdbeCursor *pC;
65074: } bc;
65075: struct OP_Found_stack_vars {
65076: int alreadyExists;
65077: VdbeCursor *pC;
65078: int res;
65079: char *pFree;
65080: UnpackedRecord *pIdxKey;
65081: UnpackedRecord r;
65082: char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
65083: } bd;
65084: struct OP_IsUnique_stack_vars {
65085: u16 ii;
65086: VdbeCursor *pCx;
65087: BtCursor *pCrsr;
65088: u16 nField;
65089: Mem *aMx;
65090: UnpackedRecord r; /* B-Tree index search key */
65091: i64 R; /* Rowid stored in register P3 */
65092: } be;
65093: struct OP_NotExists_stack_vars {
65094: VdbeCursor *pC;
65095: BtCursor *pCrsr;
65096: int res;
65097: u64 iKey;
65098: } bf;
65099: struct OP_NewRowid_stack_vars {
65100: i64 v; /* The new rowid */
65101: VdbeCursor *pC; /* Cursor of table to get the new rowid */
65102: int res; /* Result of an sqlite3BtreeLast() */
65103: int cnt; /* Counter to limit the number of searches */
65104: Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
65105: VdbeFrame *pFrame; /* Root frame of VDBE */
65106: } bg;
65107: struct OP_InsertInt_stack_vars {
65108: Mem *pData; /* MEM cell holding data for the record to be inserted */
65109: Mem *pKey; /* MEM cell holding key for the record */
65110: i64 iKey; /* The integer ROWID or key for the record to be inserted */
65111: VdbeCursor *pC; /* Cursor to table into which insert is written */
65112: int nZero; /* Number of zero-bytes to append */
65113: int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */
65114: const char *zDb; /* database name - used by the update hook */
65115: const char *zTbl; /* Table name - used by the opdate hook */
65116: int op; /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */
65117: } bh;
65118: struct OP_Delete_stack_vars {
65119: i64 iKey;
65120: VdbeCursor *pC;
65121: } bi;
65122: struct OP_SorterCompare_stack_vars {
65123: VdbeCursor *pC;
65124: int res;
65125: } bj;
65126: struct OP_SorterData_stack_vars {
65127: VdbeCursor *pC;
65128: } bk;
65129: struct OP_RowData_stack_vars {
65130: VdbeCursor *pC;
65131: BtCursor *pCrsr;
65132: u32 n;
65133: i64 n64;
65134: } bl;
65135: struct OP_Rowid_stack_vars {
65136: VdbeCursor *pC;
65137: i64 v;
65138: sqlite3_vtab *pVtab;
65139: const sqlite3_module *pModule;
65140: } bm;
65141: struct OP_NullRow_stack_vars {
65142: VdbeCursor *pC;
65143: } bn;
65144: struct OP_Last_stack_vars {
65145: VdbeCursor *pC;
65146: BtCursor *pCrsr;
65147: int res;
65148: } bo;
65149: struct OP_Rewind_stack_vars {
65150: VdbeCursor *pC;
65151: BtCursor *pCrsr;
65152: int res;
65153: } bp;
65154: struct OP_Next_stack_vars {
65155: VdbeCursor *pC;
65156: int res;
65157: } bq;
65158: struct OP_IdxInsert_stack_vars {
65159: VdbeCursor *pC;
65160: BtCursor *pCrsr;
65161: int nKey;
65162: const char *zKey;
65163: } br;
65164: struct OP_IdxDelete_stack_vars {
65165: VdbeCursor *pC;
65166: BtCursor *pCrsr;
65167: int res;
65168: UnpackedRecord r;
65169: } bs;
65170: struct OP_IdxRowid_stack_vars {
65171: BtCursor *pCrsr;
65172: VdbeCursor *pC;
65173: i64 rowid;
65174: } bt;
65175: struct OP_IdxGE_stack_vars {
65176: VdbeCursor *pC;
65177: int res;
65178: UnpackedRecord r;
65179: } bu;
65180: struct OP_Destroy_stack_vars {
65181: int iMoved;
65182: int iCnt;
65183: Vdbe *pVdbe;
65184: int iDb;
65185: } bv;
65186: struct OP_Clear_stack_vars {
65187: int nChange;
65188: } bw;
65189: struct OP_CreateTable_stack_vars {
65190: int pgno;
65191: int flags;
65192: Db *pDb;
65193: } bx;
65194: struct OP_ParseSchema_stack_vars {
65195: int iDb;
65196: const char *zMaster;
65197: char *zSql;
65198: InitData initData;
65199: } by;
65200: struct OP_IntegrityCk_stack_vars {
65201: int nRoot; /* Number of tables to check. (Number of root pages.) */
65202: int *aRoot; /* Array of rootpage numbers for tables to be checked */
65203: int j; /* Loop counter */
65204: int nErr; /* Number of errors reported */
65205: char *z; /* Text of the error report */
65206: Mem *pnErr; /* Register keeping track of errors remaining */
65207: } bz;
65208: struct OP_RowSetRead_stack_vars {
65209: i64 val;
65210: } ca;
65211: struct OP_RowSetTest_stack_vars {
65212: int iSet;
65213: int exists;
65214: } cb;
65215: struct OP_Program_stack_vars {
65216: int nMem; /* Number of memory registers for sub-program */
65217: int nByte; /* Bytes of runtime space required for sub-program */
65218: Mem *pRt; /* Register to allocate runtime space */
65219: Mem *pMem; /* Used to iterate through memory cells */
65220: Mem *pEnd; /* Last memory cell in new array */
65221: VdbeFrame *pFrame; /* New vdbe frame to execute in */
65222: SubProgram *pProgram; /* Sub-program to execute */
65223: void *t; /* Token identifying trigger */
65224: } cc;
65225: struct OP_Param_stack_vars {
65226: VdbeFrame *pFrame;
65227: Mem *pIn;
65228: } cd;
65229: struct OP_MemMax_stack_vars {
65230: Mem *pIn1;
65231: VdbeFrame *pFrame;
65232: } ce;
65233: struct OP_AggStep_stack_vars {
65234: int n;
65235: int i;
65236: Mem *pMem;
65237: Mem *pRec;
65238: sqlite3_context ctx;
65239: sqlite3_value **apVal;
65240: } cf;
65241: struct OP_AggFinal_stack_vars {
65242: Mem *pMem;
65243: } cg;
65244: struct OP_Checkpoint_stack_vars {
65245: int i; /* Loop counter */
65246: int aRes[3]; /* Results */
65247: Mem *pMem; /* Write results here */
65248: } ch;
65249: struct OP_JournalMode_stack_vars {
65250: Btree *pBt; /* Btree to change journal mode of */
65251: Pager *pPager; /* Pager associated with pBt */
65252: int eNew; /* New journal mode */
65253: int eOld; /* The old journal mode */
65254: const char *zFilename; /* Name of database file for pPager */
65255: } ci;
65256: struct OP_IncrVacuum_stack_vars {
65257: Btree *pBt;
65258: } cj;
65259: struct OP_VBegin_stack_vars {
65260: VTable *pVTab;
65261: } ck;
65262: struct OP_VOpen_stack_vars {
65263: VdbeCursor *pCur;
65264: sqlite3_vtab_cursor *pVtabCursor;
65265: sqlite3_vtab *pVtab;
65266: sqlite3_module *pModule;
65267: } cl;
65268: struct OP_VFilter_stack_vars {
65269: int nArg;
65270: int iQuery;
65271: const sqlite3_module *pModule;
65272: Mem *pQuery;
65273: Mem *pArgc;
65274: sqlite3_vtab_cursor *pVtabCursor;
65275: sqlite3_vtab *pVtab;
65276: VdbeCursor *pCur;
65277: int res;
65278: int i;
65279: Mem **apArg;
65280: } cm;
65281: struct OP_VColumn_stack_vars {
65282: sqlite3_vtab *pVtab;
65283: const sqlite3_module *pModule;
65284: Mem *pDest;
65285: sqlite3_context sContext;
65286: } cn;
65287: struct OP_VNext_stack_vars {
65288: sqlite3_vtab *pVtab;
65289: const sqlite3_module *pModule;
65290: int res;
65291: VdbeCursor *pCur;
65292: } co;
65293: struct OP_VRename_stack_vars {
65294: sqlite3_vtab *pVtab;
65295: Mem *pName;
65296: } cp;
65297: struct OP_VUpdate_stack_vars {
65298: sqlite3_vtab *pVtab;
65299: sqlite3_module *pModule;
65300: int nArg;
65301: int i;
65302: sqlite_int64 rowid;
65303: Mem **apArg;
65304: Mem *pX;
65305: } cq;
65306: struct OP_Trace_stack_vars {
65307: char *zTrace;
65308: char *z;
65309: } cr;
65310: } u;
65311: /* End automatically generated code
65312: ********************************************************************/
65313:
65314: assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */
65315: sqlite3VdbeEnter(p);
65316: if( p->rc==SQLITE_NOMEM ){
65317: /* This happens if a malloc() inside a call to sqlite3_column_text() or
65318: ** sqlite3_column_text16() failed. */
65319: goto no_mem;
65320: }
65321: assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
65322: p->rc = SQLITE_OK;
65323: assert( p->explain==0 );
65324: p->pResultSet = 0;
65325: db->busyHandler.nBusy = 0;
65326: CHECK_FOR_INTERRUPT;
65327: sqlite3VdbeIOTraceSql(p);
65328: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
65329: checkProgress = db->xProgress!=0;
65330: #endif
65331: #ifdef SQLITE_DEBUG
65332: sqlite3BeginBenignMalloc();
65333: if( p->pc==0 && (p->db->flags & SQLITE_VdbeListing)!=0 ){
65334: int i;
65335: printf("VDBE Program Listing:\n");
65336: sqlite3VdbePrintSql(p);
65337: for(i=0; i<p->nOp; i++){
65338: sqlite3VdbePrintOp(stdout, i, &aOp[i]);
65339: }
65340: }
65341: sqlite3EndBenignMalloc();
65342: #endif
65343: for(pc=p->pc; rc==SQLITE_OK; pc++){
65344: assert( pc>=0 && pc<p->nOp );
65345: if( db->mallocFailed ) goto no_mem;
65346: #ifdef VDBE_PROFILE
65347: origPc = pc;
65348: start = sqlite3Hwtime();
65349: #endif
65350: pOp = &aOp[pc];
65351:
65352: /* Only allow tracing if SQLITE_DEBUG is defined.
65353: */
65354: #ifdef SQLITE_DEBUG
65355: if( p->trace ){
65356: if( pc==0 ){
65357: printf("VDBE Execution Trace:\n");
65358: sqlite3VdbePrintSql(p);
65359: }
65360: sqlite3VdbePrintOp(p->trace, pc, pOp);
65361: }
65362: #endif
65363:
65364:
65365: /* Check to see if we need to simulate an interrupt. This only happens
65366: ** if we have a special test build.
65367: */
65368: #ifdef SQLITE_TEST
65369: if( sqlite3_interrupt_count>0 ){
65370: sqlite3_interrupt_count--;
65371: if( sqlite3_interrupt_count==0 ){
65372: sqlite3_interrupt(db);
65373: }
65374: }
65375: #endif
65376:
65377: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
65378: /* Call the progress callback if it is configured and the required number
65379: ** of VDBE ops have been executed (either since this invocation of
65380: ** sqlite3VdbeExec() or since last time the progress callback was called).
65381: ** If the progress callback returns non-zero, exit the virtual machine with
65382: ** a return code SQLITE_ABORT.
65383: */
65384: if( checkProgress ){
65385: if( db->nProgressOps==nProgressOps ){
65386: int prc;
65387: prc = db->xProgress(db->pProgressArg);
65388: if( prc!=0 ){
65389: rc = SQLITE_INTERRUPT;
65390: goto vdbe_error_halt;
65391: }
65392: nProgressOps = 0;
65393: }
65394: nProgressOps++;
65395: }
65396: #endif
65397:
65398: /* On any opcode with the "out2-prerelase" tag, free any
65399: ** external allocations out of mem[p2] and set mem[p2] to be
65400: ** an undefined integer. Opcodes will either fill in the integer
65401: ** value or convert mem[p2] to a different type.
65402: */
65403: assert( pOp->opflags==sqlite3OpcodeProperty[pOp->opcode] );
65404: if( pOp->opflags & OPFLG_OUT2_PRERELEASE ){
65405: assert( pOp->p2>0 );
65406: assert( pOp->p2<=p->nMem );
65407: pOut = &aMem[pOp->p2];
65408: memAboutToChange(p, pOut);
65409: VdbeMemRelease(pOut);
65410: pOut->flags = MEM_Int;
65411: }
65412:
65413: /* Sanity checking on other operands */
65414: #ifdef SQLITE_DEBUG
65415: if( (pOp->opflags & OPFLG_IN1)!=0 ){
65416: assert( pOp->p1>0 );
65417: assert( pOp->p1<=p->nMem );
65418: assert( memIsValid(&aMem[pOp->p1]) );
65419: REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
65420: }
65421: if( (pOp->opflags & OPFLG_IN2)!=0 ){
65422: assert( pOp->p2>0 );
65423: assert( pOp->p2<=p->nMem );
65424: assert( memIsValid(&aMem[pOp->p2]) );
65425: REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
65426: }
65427: if( (pOp->opflags & OPFLG_IN3)!=0 ){
65428: assert( pOp->p3>0 );
65429: assert( pOp->p3<=p->nMem );
65430: assert( memIsValid(&aMem[pOp->p3]) );
65431: REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
65432: }
65433: if( (pOp->opflags & OPFLG_OUT2)!=0 ){
65434: assert( pOp->p2>0 );
65435: assert( pOp->p2<=p->nMem );
65436: memAboutToChange(p, &aMem[pOp->p2]);
65437: }
65438: if( (pOp->opflags & OPFLG_OUT3)!=0 ){
65439: assert( pOp->p3>0 );
65440: assert( pOp->p3<=p->nMem );
65441: memAboutToChange(p, &aMem[pOp->p3]);
65442: }
65443: #endif
65444:
65445: switch( pOp->opcode ){
65446:
65447: /*****************************************************************************
65448: ** What follows is a massive switch statement where each case implements a
65449: ** separate instruction in the virtual machine. If we follow the usual
65450: ** indentation conventions, each case should be indented by 6 spaces. But
65451: ** that is a lot of wasted space on the left margin. So the code within
65452: ** the switch statement will break with convention and be flush-left. Another
65453: ** big comment (similar to this one) will mark the point in the code where
65454: ** we transition back to normal indentation.
65455: **
65456: ** The formatting of each case is important. The makefile for SQLite
65457: ** generates two C files "opcodes.h" and "opcodes.c" by scanning this
65458: ** file looking for lines that begin with "case OP_". The opcodes.h files
65459: ** will be filled with #defines that give unique integer values to each
65460: ** opcode and the opcodes.c file is filled with an array of strings where
65461: ** each string is the symbolic name for the corresponding opcode. If the
65462: ** case statement is followed by a comment of the form "/# same as ... #/"
65463: ** that comment is used to determine the particular value of the opcode.
65464: **
65465: ** Other keywords in the comment that follows each case are used to
65466: ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
65467: ** Keywords include: in1, in2, in3, out2_prerelease, out2, out3. See
65468: ** the mkopcodeh.awk script for additional information.
65469: **
65470: ** Documentation about VDBE opcodes is generated by scanning this file
65471: ** for lines of that contain "Opcode:". That line and all subsequent
65472: ** comment lines are used in the generation of the opcode.html documentation
65473: ** file.
65474: **
65475: ** SUMMARY:
65476: **
65477: ** Formatting is important to scripts that scan this file.
65478: ** Do not deviate from the formatting style currently in use.
65479: **
65480: *****************************************************************************/
65481:
65482: /* Opcode: Goto * P2 * * *
65483: **
65484: ** An unconditional jump to address P2.
65485: ** The next instruction executed will be
65486: ** the one at index P2 from the beginning of
65487: ** the program.
65488: */
65489: case OP_Goto: { /* jump */
65490: CHECK_FOR_INTERRUPT;
65491: pc = pOp->p2 - 1;
65492: break;
65493: }
65494:
65495: /* Opcode: Gosub P1 P2 * * *
65496: **
65497: ** Write the current address onto register P1
65498: ** and then jump to address P2.
65499: */
65500: case OP_Gosub: { /* jump */
65501: assert( pOp->p1>0 && pOp->p1<=p->nMem );
65502: pIn1 = &aMem[pOp->p1];
65503: assert( (pIn1->flags & MEM_Dyn)==0 );
65504: memAboutToChange(p, pIn1);
65505: pIn1->flags = MEM_Int;
65506: pIn1->u.i = pc;
65507: REGISTER_TRACE(pOp->p1, pIn1);
65508: pc = pOp->p2 - 1;
65509: break;
65510: }
65511:
65512: /* Opcode: Return P1 * * * *
65513: **
65514: ** Jump to the next instruction after the address in register P1.
65515: */
65516: case OP_Return: { /* in1 */
65517: pIn1 = &aMem[pOp->p1];
65518: assert( pIn1->flags & MEM_Int );
65519: pc = (int)pIn1->u.i;
65520: break;
65521: }
65522:
65523: /* Opcode: Yield P1 * * * *
65524: **
65525: ** Swap the program counter with the value in register P1.
65526: */
65527: case OP_Yield: { /* in1 */
65528: #if 0 /* local variables moved into u.aa */
65529: int pcDest;
65530: #endif /* local variables moved into u.aa */
65531: pIn1 = &aMem[pOp->p1];
65532: assert( (pIn1->flags & MEM_Dyn)==0 );
65533: pIn1->flags = MEM_Int;
65534: u.aa.pcDest = (int)pIn1->u.i;
65535: pIn1->u.i = pc;
65536: REGISTER_TRACE(pOp->p1, pIn1);
65537: pc = u.aa.pcDest;
65538: break;
65539: }
65540:
65541: /* Opcode: HaltIfNull P1 P2 P3 P4 *
65542: **
65543: ** Check the value in register P3. If it is NULL then Halt using
65544: ** parameter P1, P2, and P4 as if this were a Halt instruction. If the
65545: ** value in register P3 is not NULL, then this routine is a no-op.
65546: */
65547: case OP_HaltIfNull: { /* in3 */
65548: pIn3 = &aMem[pOp->p3];
65549: if( (pIn3->flags & MEM_Null)==0 ) break;
65550: /* Fall through into OP_Halt */
65551: }
65552:
65553: /* Opcode: Halt P1 P2 * P4 *
65554: **
65555: ** Exit immediately. All open cursors, etc are closed
65556: ** automatically.
65557: **
65558: ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
65559: ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0).
65560: ** For errors, it can be some other value. If P1!=0 then P2 will determine
65561: ** whether or not to rollback the current transaction. Do not rollback
65562: ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort,
65563: ** then back out all changes that have occurred during this execution of the
65564: ** VDBE, but do not rollback the transaction.
65565: **
65566: ** If P4 is not null then it is an error message string.
65567: **
65568: ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
65569: ** every program. So a jump past the last instruction of the program
65570: ** is the same as executing Halt.
65571: */
65572: case OP_Halt: {
65573: if( pOp->p1==SQLITE_OK && p->pFrame ){
65574: /* Halt the sub-program. Return control to the parent frame. */
65575: VdbeFrame *pFrame = p->pFrame;
65576: p->pFrame = pFrame->pParent;
65577: p->nFrame--;
65578: sqlite3VdbeSetChanges(db, p->nChange);
65579: pc = sqlite3VdbeFrameRestore(pFrame);
65580: lastRowid = db->lastRowid;
65581: if( pOp->p2==OE_Ignore ){
65582: /* Instruction pc is the OP_Program that invoked the sub-program
65583: ** currently being halted. If the p2 instruction of this OP_Halt
65584: ** instruction is set to OE_Ignore, then the sub-program is throwing
65585: ** an IGNORE exception. In this case jump to the address specified
65586: ** as the p2 of the calling OP_Program. */
65587: pc = p->aOp[pc].p2-1;
65588: }
65589: aOp = p->aOp;
65590: aMem = p->aMem;
65591: break;
65592: }
65593:
65594: p->rc = pOp->p1;
65595: p->errorAction = (u8)pOp->p2;
65596: p->pc = pc;
65597: if( pOp->p4.z ){
65598: assert( p->rc!=SQLITE_OK );
65599: sqlite3SetString(&p->zErrMsg, db, "%s", pOp->p4.z);
65600: testcase( sqlite3GlobalConfig.xLog!=0 );
65601: sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pc, p->zSql, pOp->p4.z);
65602: }else if( p->rc ){
65603: testcase( sqlite3GlobalConfig.xLog!=0 );
65604: sqlite3_log(pOp->p1, "constraint failed at %d in [%s]", pc, p->zSql);
65605: }
65606: rc = sqlite3VdbeHalt(p);
65607: assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
65608: if( rc==SQLITE_BUSY ){
65609: p->rc = rc = SQLITE_BUSY;
65610: }else{
65611: assert( rc==SQLITE_OK || p->rc==SQLITE_CONSTRAINT );
65612: assert( rc==SQLITE_OK || db->nDeferredCons>0 );
65613: rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
65614: }
65615: goto vdbe_return;
65616: }
65617:
65618: /* Opcode: Integer P1 P2 * * *
65619: **
65620: ** The 32-bit integer value P1 is written into register P2.
65621: */
65622: case OP_Integer: { /* out2-prerelease */
65623: pOut->u.i = pOp->p1;
65624: break;
65625: }
65626:
65627: /* Opcode: Int64 * P2 * P4 *
65628: **
65629: ** P4 is a pointer to a 64-bit integer value.
65630: ** Write that value into register P2.
65631: */
65632: case OP_Int64: { /* out2-prerelease */
65633: assert( pOp->p4.pI64!=0 );
65634: pOut->u.i = *pOp->p4.pI64;
65635: break;
65636: }
65637:
65638: #ifndef SQLITE_OMIT_FLOATING_POINT
65639: /* Opcode: Real * P2 * P4 *
65640: **
65641: ** P4 is a pointer to a 64-bit floating point value.
65642: ** Write that value into register P2.
65643: */
65644: case OP_Real: { /* same as TK_FLOAT, out2-prerelease */
65645: pOut->flags = MEM_Real;
65646: assert( !sqlite3IsNaN(*pOp->p4.pReal) );
65647: pOut->r = *pOp->p4.pReal;
65648: break;
65649: }
65650: #endif
65651:
65652: /* Opcode: String8 * P2 * P4 *
65653: **
65654: ** P4 points to a nul terminated UTF-8 string. This opcode is transformed
65655: ** into an OP_String before it is executed for the first time.
65656: */
65657: case OP_String8: { /* same as TK_STRING, out2-prerelease */
65658: assert( pOp->p4.z!=0 );
65659: pOp->opcode = OP_String;
65660: pOp->p1 = sqlite3Strlen30(pOp->p4.z);
65661:
65662: #ifndef SQLITE_OMIT_UTF16
65663: if( encoding!=SQLITE_UTF8 ){
65664: rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
65665: if( rc==SQLITE_TOOBIG ) goto too_big;
65666: if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
65667: assert( pOut->zMalloc==pOut->z );
65668: assert( pOut->flags & MEM_Dyn );
65669: pOut->zMalloc = 0;
65670: pOut->flags |= MEM_Static;
65671: pOut->flags &= ~MEM_Dyn;
65672: if( pOp->p4type==P4_DYNAMIC ){
65673: sqlite3DbFree(db, pOp->p4.z);
65674: }
65675: pOp->p4type = P4_DYNAMIC;
65676: pOp->p4.z = pOut->z;
65677: pOp->p1 = pOut->n;
65678: }
65679: #endif
65680: if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
65681: goto too_big;
65682: }
65683: /* Fall through to the next case, OP_String */
65684: }
65685:
65686: /* Opcode: String P1 P2 * P4 *
65687: **
65688: ** The string value P4 of length P1 (bytes) is stored in register P2.
65689: */
65690: case OP_String: { /* out2-prerelease */
65691: assert( pOp->p4.z!=0 );
65692: pOut->flags = MEM_Str|MEM_Static|MEM_Term;
65693: pOut->z = pOp->p4.z;
65694: pOut->n = pOp->p1;
65695: pOut->enc = encoding;
65696: UPDATE_MAX_BLOBSIZE(pOut);
65697: break;
65698: }
65699:
65700: /* Opcode: Null * P2 P3 * *
65701: **
65702: ** Write a NULL into registers P2. If P3 greater than P2, then also write
65703: ** NULL into register P3 and ever register in between P2 and P3. If P3
65704: ** is less than P2 (typically P3 is zero) then only register P2 is
65705: ** set to NULL
65706: */
65707: case OP_Null: { /* out2-prerelease */
65708: #if 0 /* local variables moved into u.ab */
65709: int cnt;
65710: #endif /* local variables moved into u.ab */
65711: u.ab.cnt = pOp->p3-pOp->p2;
65712: assert( pOp->p3<=p->nMem );
65713: pOut->flags = MEM_Null;
65714: while( u.ab.cnt>0 ){
65715: pOut++;
65716: memAboutToChange(p, pOut);
65717: VdbeMemRelease(pOut);
65718: pOut->flags = MEM_Null;
65719: u.ab.cnt--;
65720: }
65721: break;
65722: }
65723:
65724:
65725: /* Opcode: Blob P1 P2 * P4
65726: **
65727: ** P4 points to a blob of data P1 bytes long. Store this
65728: ** blob in register P2.
65729: */
65730: case OP_Blob: { /* out2-prerelease */
65731: assert( pOp->p1 <= SQLITE_MAX_LENGTH );
65732: sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
65733: pOut->enc = encoding;
65734: UPDATE_MAX_BLOBSIZE(pOut);
65735: break;
65736: }
65737:
65738: /* Opcode: Variable P1 P2 * P4 *
65739: **
65740: ** Transfer the values of bound parameter P1 into register P2
65741: **
65742: ** If the parameter is named, then its name appears in P4 and P3==1.
65743: ** The P4 value is used by sqlite3_bind_parameter_name().
65744: */
65745: case OP_Variable: { /* out2-prerelease */
65746: #if 0 /* local variables moved into u.ac */
65747: Mem *pVar; /* Value being transferred */
65748: #endif /* local variables moved into u.ac */
65749:
65750: assert( pOp->p1>0 && pOp->p1<=p->nVar );
65751: assert( pOp->p4.z==0 || pOp->p4.z==p->azVar[pOp->p1-1] );
65752: u.ac.pVar = &p->aVar[pOp->p1 - 1];
65753: if( sqlite3VdbeMemTooBig(u.ac.pVar) ){
65754: goto too_big;
65755: }
65756: sqlite3VdbeMemShallowCopy(pOut, u.ac.pVar, MEM_Static);
65757: UPDATE_MAX_BLOBSIZE(pOut);
65758: break;
65759: }
65760:
65761: /* Opcode: Move P1 P2 P3 * *
65762: **
65763: ** Move the values in register P1..P1+P3-1 over into
65764: ** registers P2..P2+P3-1. Registers P1..P1+P1-1 are
65765: ** left holding a NULL. It is an error for register ranges
65766: ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.
65767: */
65768: case OP_Move: {
65769: #if 0 /* local variables moved into u.ad */
65770: char *zMalloc; /* Holding variable for allocated memory */
65771: int n; /* Number of registers left to copy */
65772: int p1; /* Register to copy from */
65773: int p2; /* Register to copy to */
65774: #endif /* local variables moved into u.ad */
65775:
65776: u.ad.n = pOp->p3;
65777: u.ad.p1 = pOp->p1;
65778: u.ad.p2 = pOp->p2;
65779: assert( u.ad.n>0 && u.ad.p1>0 && u.ad.p2>0 );
65780: assert( u.ad.p1+u.ad.n<=u.ad.p2 || u.ad.p2+u.ad.n<=u.ad.p1 );
65781:
65782: pIn1 = &aMem[u.ad.p1];
65783: pOut = &aMem[u.ad.p2];
65784: while( u.ad.n-- ){
65785: assert( pOut<=&aMem[p->nMem] );
65786: assert( pIn1<=&aMem[p->nMem] );
65787: assert( memIsValid(pIn1) );
65788: memAboutToChange(p, pOut);
65789: u.ad.zMalloc = pOut->zMalloc;
65790: pOut->zMalloc = 0;
65791: sqlite3VdbeMemMove(pOut, pIn1);
65792: #ifdef SQLITE_DEBUG
65793: if( pOut->pScopyFrom>=&aMem[u.ad.p1] && pOut->pScopyFrom<&aMem[u.ad.p1+pOp->p3] ){
65794: pOut->pScopyFrom += u.ad.p1 - pOp->p2;
65795: }
65796: #endif
65797: pIn1->zMalloc = u.ad.zMalloc;
65798: REGISTER_TRACE(u.ad.p2++, pOut);
65799: pIn1++;
65800: pOut++;
65801: }
65802: break;
65803: }
65804:
65805: /* Opcode: Copy P1 P2 * * *
65806: **
65807: ** Make a copy of register P1 into register P2.
65808: **
65809: ** This instruction makes a deep copy of the value. A duplicate
65810: ** is made of any string or blob constant. See also OP_SCopy.
65811: */
65812: case OP_Copy: { /* in1, out2 */
65813: pIn1 = &aMem[pOp->p1];
65814: pOut = &aMem[pOp->p2];
65815: assert( pOut!=pIn1 );
65816: sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
65817: Deephemeralize(pOut);
65818: REGISTER_TRACE(pOp->p2, pOut);
65819: break;
65820: }
65821:
65822: /* Opcode: SCopy P1 P2 * * *
65823: **
65824: ** Make a shallow copy of register P1 into register P2.
65825: **
65826: ** This instruction makes a shallow copy of the value. If the value
65827: ** is a string or blob, then the copy is only a pointer to the
65828: ** original and hence if the original changes so will the copy.
65829: ** Worse, if the original is deallocated, the copy becomes invalid.
65830: ** Thus the program must guarantee that the original will not change
65831: ** during the lifetime of the copy. Use OP_Copy to make a complete
65832: ** copy.
65833: */
65834: case OP_SCopy: { /* in1, out2 */
65835: pIn1 = &aMem[pOp->p1];
65836: pOut = &aMem[pOp->p2];
65837: assert( pOut!=pIn1 );
65838: sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
65839: #ifdef SQLITE_DEBUG
65840: if( pOut->pScopyFrom==0 ) pOut->pScopyFrom = pIn1;
65841: #endif
65842: REGISTER_TRACE(pOp->p2, pOut);
65843: break;
65844: }
65845:
65846: /* Opcode: ResultRow P1 P2 * * *
65847: **
65848: ** The registers P1 through P1+P2-1 contain a single row of
65849: ** results. This opcode causes the sqlite3_step() call to terminate
65850: ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
65851: ** structure to provide access to the top P1 values as the result
65852: ** row.
65853: */
65854: case OP_ResultRow: {
65855: #if 0 /* local variables moved into u.ae */
65856: Mem *pMem;
65857: int i;
65858: #endif /* local variables moved into u.ae */
65859: assert( p->nResColumn==pOp->p2 );
65860: assert( pOp->p1>0 );
65861: assert( pOp->p1+pOp->p2<=p->nMem+1 );
65862:
65863: /* If this statement has violated immediate foreign key constraints, do
65864: ** not return the number of rows modified. And do not RELEASE the statement
65865: ** transaction. It needs to be rolled back. */
65866: if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
65867: assert( db->flags&SQLITE_CountRows );
65868: assert( p->usesStmtJournal );
65869: break;
65870: }
65871:
65872: /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
65873: ** DML statements invoke this opcode to return the number of rows
65874: ** modified to the user. This is the only way that a VM that
65875: ** opens a statement transaction may invoke this opcode.
65876: **
65877: ** In case this is such a statement, close any statement transaction
65878: ** opened by this VM before returning control to the user. This is to
65879: ** ensure that statement-transactions are always nested, not overlapping.
65880: ** If the open statement-transaction is not closed here, then the user
65881: ** may step another VM that opens its own statement transaction. This
65882: ** may lead to overlapping statement transactions.
65883: **
65884: ** The statement transaction is never a top-level transaction. Hence
65885: ** the RELEASE call below can never fail.
65886: */
65887: assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
65888: rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE);
65889: if( NEVER(rc!=SQLITE_OK) ){
65890: break;
65891: }
65892:
65893: /* Invalidate all ephemeral cursor row caches */
65894: p->cacheCtr = (p->cacheCtr + 2)|1;
65895:
65896: /* Make sure the results of the current row are \000 terminated
65897: ** and have an assigned type. The results are de-ephemeralized as
65898: ** a side effect.
65899: */
65900: u.ae.pMem = p->pResultSet = &aMem[pOp->p1];
65901: for(u.ae.i=0; u.ae.i<pOp->p2; u.ae.i++){
65902: assert( memIsValid(&u.ae.pMem[u.ae.i]) );
65903: Deephemeralize(&u.ae.pMem[u.ae.i]);
65904: assert( (u.ae.pMem[u.ae.i].flags & MEM_Ephem)==0
65905: || (u.ae.pMem[u.ae.i].flags & (MEM_Str|MEM_Blob))==0 );
65906: sqlite3VdbeMemNulTerminate(&u.ae.pMem[u.ae.i]);
65907: sqlite3VdbeMemStoreType(&u.ae.pMem[u.ae.i]);
65908: REGISTER_TRACE(pOp->p1+u.ae.i, &u.ae.pMem[u.ae.i]);
65909: }
65910: if( db->mallocFailed ) goto no_mem;
65911:
65912: /* Return SQLITE_ROW
65913: */
65914: p->pc = pc + 1;
65915: rc = SQLITE_ROW;
65916: goto vdbe_return;
65917: }
65918:
65919: /* Opcode: Concat P1 P2 P3 * *
65920: **
65921: ** Add the text in register P1 onto the end of the text in
65922: ** register P2 and store the result in register P3.
65923: ** If either the P1 or P2 text are NULL then store NULL in P3.
65924: **
65925: ** P3 = P2 || P1
65926: **
65927: ** It is illegal for P1 and P3 to be the same register. Sometimes,
65928: ** if P3 is the same register as P2, the implementation is able
65929: ** to avoid a memcpy().
65930: */
65931: case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */
65932: #if 0 /* local variables moved into u.af */
65933: i64 nByte;
65934: #endif /* local variables moved into u.af */
65935:
65936: pIn1 = &aMem[pOp->p1];
65937: pIn2 = &aMem[pOp->p2];
65938: pOut = &aMem[pOp->p3];
65939: assert( pIn1!=pOut );
65940: if( (pIn1->flags | pIn2->flags) & MEM_Null ){
65941: sqlite3VdbeMemSetNull(pOut);
65942: break;
65943: }
65944: if( ExpandBlob(pIn1) || ExpandBlob(pIn2) ) goto no_mem;
65945: Stringify(pIn1, encoding);
65946: Stringify(pIn2, encoding);
65947: u.af.nByte = pIn1->n + pIn2->n;
65948: if( u.af.nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
65949: goto too_big;
65950: }
65951: MemSetTypeFlag(pOut, MEM_Str);
65952: if( sqlite3VdbeMemGrow(pOut, (int)u.af.nByte+2, pOut==pIn2) ){
65953: goto no_mem;
65954: }
65955: if( pOut!=pIn2 ){
65956: memcpy(pOut->z, pIn2->z, pIn2->n);
65957: }
65958: memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
65959: pOut->z[u.af.nByte] = 0;
65960: pOut->z[u.af.nByte+1] = 0;
65961: pOut->flags |= MEM_Term;
65962: pOut->n = (int)u.af.nByte;
65963: pOut->enc = encoding;
65964: UPDATE_MAX_BLOBSIZE(pOut);
65965: break;
65966: }
65967:
65968: /* Opcode: Add P1 P2 P3 * *
65969: **
65970: ** Add the value in register P1 to the value in register P2
65971: ** and store the result in register P3.
65972: ** If either input is NULL, the result is NULL.
65973: */
65974: /* Opcode: Multiply P1 P2 P3 * *
65975: **
65976: **
65977: ** Multiply the value in register P1 by the value in register P2
65978: ** and store the result in register P3.
65979: ** If either input is NULL, the result is NULL.
65980: */
65981: /* Opcode: Subtract P1 P2 P3 * *
65982: **
65983: ** Subtract the value in register P1 from the value in register P2
65984: ** and store the result in register P3.
65985: ** If either input is NULL, the result is NULL.
65986: */
65987: /* Opcode: Divide P1 P2 P3 * *
65988: **
65989: ** Divide the value in register P1 by the value in register P2
65990: ** and store the result in register P3 (P3=P2/P1). If the value in
65991: ** register P1 is zero, then the result is NULL. If either input is
65992: ** NULL, the result is NULL.
65993: */
65994: /* Opcode: Remainder P1 P2 P3 * *
65995: **
65996: ** Compute the remainder after integer division of the value in
65997: ** register P1 by the value in register P2 and store the result in P3.
65998: ** If the value in register P2 is zero the result is NULL.
65999: ** If either operand is NULL, the result is NULL.
66000: */
66001: case OP_Add: /* same as TK_PLUS, in1, in2, out3 */
66002: case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */
66003: case OP_Multiply: /* same as TK_STAR, in1, in2, out3 */
66004: case OP_Divide: /* same as TK_SLASH, in1, in2, out3 */
66005: case OP_Remainder: { /* same as TK_REM, in1, in2, out3 */
66006: #if 0 /* local variables moved into u.ag */
66007: int flags; /* Combined MEM_* flags from both inputs */
66008: i64 iA; /* Integer value of left operand */
66009: i64 iB; /* Integer value of right operand */
66010: double rA; /* Real value of left operand */
66011: double rB; /* Real value of right operand */
66012: #endif /* local variables moved into u.ag */
66013:
66014: pIn1 = &aMem[pOp->p1];
66015: applyNumericAffinity(pIn1);
66016: pIn2 = &aMem[pOp->p2];
66017: applyNumericAffinity(pIn2);
66018: pOut = &aMem[pOp->p3];
66019: u.ag.flags = pIn1->flags | pIn2->flags;
66020: if( (u.ag.flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;
66021: if( (pIn1->flags & pIn2->flags & MEM_Int)==MEM_Int ){
66022: u.ag.iA = pIn1->u.i;
66023: u.ag.iB = pIn2->u.i;
66024: switch( pOp->opcode ){
66025: case OP_Add: if( sqlite3AddInt64(&u.ag.iB,u.ag.iA) ) goto fp_math; break;
66026: case OP_Subtract: if( sqlite3SubInt64(&u.ag.iB,u.ag.iA) ) goto fp_math; break;
66027: case OP_Multiply: if( sqlite3MulInt64(&u.ag.iB,u.ag.iA) ) goto fp_math; break;
66028: case OP_Divide: {
66029: if( u.ag.iA==0 ) goto arithmetic_result_is_null;
66030: if( u.ag.iA==-1 && u.ag.iB==SMALLEST_INT64 ) goto fp_math;
66031: u.ag.iB /= u.ag.iA;
66032: break;
66033: }
66034: default: {
66035: if( u.ag.iA==0 ) goto arithmetic_result_is_null;
66036: if( u.ag.iA==-1 ) u.ag.iA = 1;
66037: u.ag.iB %= u.ag.iA;
66038: break;
66039: }
66040: }
66041: pOut->u.i = u.ag.iB;
66042: MemSetTypeFlag(pOut, MEM_Int);
66043: }else{
66044: fp_math:
66045: u.ag.rA = sqlite3VdbeRealValue(pIn1);
66046: u.ag.rB = sqlite3VdbeRealValue(pIn2);
66047: switch( pOp->opcode ){
66048: case OP_Add: u.ag.rB += u.ag.rA; break;
66049: case OP_Subtract: u.ag.rB -= u.ag.rA; break;
66050: case OP_Multiply: u.ag.rB *= u.ag.rA; break;
66051: case OP_Divide: {
66052: /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
66053: if( u.ag.rA==(double)0 ) goto arithmetic_result_is_null;
66054: u.ag.rB /= u.ag.rA;
66055: break;
66056: }
66057: default: {
66058: u.ag.iA = (i64)u.ag.rA;
66059: u.ag.iB = (i64)u.ag.rB;
66060: if( u.ag.iA==0 ) goto arithmetic_result_is_null;
66061: if( u.ag.iA==-1 ) u.ag.iA = 1;
66062: u.ag.rB = (double)(u.ag.iB % u.ag.iA);
66063: break;
66064: }
66065: }
66066: #ifdef SQLITE_OMIT_FLOATING_POINT
66067: pOut->u.i = u.ag.rB;
66068: MemSetTypeFlag(pOut, MEM_Int);
66069: #else
66070: if( sqlite3IsNaN(u.ag.rB) ){
66071: goto arithmetic_result_is_null;
66072: }
66073: pOut->r = u.ag.rB;
66074: MemSetTypeFlag(pOut, MEM_Real);
66075: if( (u.ag.flags & MEM_Real)==0 ){
66076: sqlite3VdbeIntegerAffinity(pOut);
66077: }
66078: #endif
66079: }
66080: break;
66081:
66082: arithmetic_result_is_null:
66083: sqlite3VdbeMemSetNull(pOut);
66084: break;
66085: }
66086:
66087: /* Opcode: CollSeq * * P4
66088: **
66089: ** P4 is a pointer to a CollSeq struct. If the next call to a user function
66090: ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
66091: ** be returned. This is used by the built-in min(), max() and nullif()
66092: ** functions.
66093: **
66094: ** The interface used by the implementation of the aforementioned functions
66095: ** to retrieve the collation sequence set by this opcode is not available
66096: ** publicly, only to user functions defined in func.c.
66097: */
66098: case OP_CollSeq: {
66099: assert( pOp->p4type==P4_COLLSEQ );
66100: break;
66101: }
66102:
66103: /* Opcode: Function P1 P2 P3 P4 P5
66104: **
66105: ** Invoke a user function (P4 is a pointer to a Function structure that
66106: ** defines the function) with P5 arguments taken from register P2 and
66107: ** successors. The result of the function is stored in register P3.
66108: ** Register P3 must not be one of the function inputs.
66109: **
66110: ** P1 is a 32-bit bitmask indicating whether or not each argument to the
66111: ** function was determined to be constant at compile time. If the first
66112: ** argument was constant then bit 0 of P1 is set. This is used to determine
66113: ** whether meta data associated with a user function argument using the
66114: ** sqlite3_set_auxdata() API may be safely retained until the next
66115: ** invocation of this opcode.
66116: **
66117: ** See also: AggStep and AggFinal
66118: */
66119: case OP_Function: {
66120: #if 0 /* local variables moved into u.ah */
66121: int i;
66122: Mem *pArg;
66123: sqlite3_context ctx;
66124: sqlite3_value **apVal;
66125: int n;
66126: #endif /* local variables moved into u.ah */
66127:
66128: u.ah.n = pOp->p5;
66129: u.ah.apVal = p->apArg;
66130: assert( u.ah.apVal || u.ah.n==0 );
66131: assert( pOp->p3>0 && pOp->p3<=p->nMem );
66132: pOut = &aMem[pOp->p3];
66133: memAboutToChange(p, pOut);
66134:
66135: assert( u.ah.n==0 || (pOp->p2>0 && pOp->p2+u.ah.n<=p->nMem+1) );
66136: assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+u.ah.n );
66137: u.ah.pArg = &aMem[pOp->p2];
66138: for(u.ah.i=0; u.ah.i<u.ah.n; u.ah.i++, u.ah.pArg++){
66139: assert( memIsValid(u.ah.pArg) );
66140: u.ah.apVal[u.ah.i] = u.ah.pArg;
66141: Deephemeralize(u.ah.pArg);
66142: sqlite3VdbeMemStoreType(u.ah.pArg);
66143: REGISTER_TRACE(pOp->p2+u.ah.i, u.ah.pArg);
66144: }
66145:
66146: assert( pOp->p4type==P4_FUNCDEF || pOp->p4type==P4_VDBEFUNC );
66147: if( pOp->p4type==P4_FUNCDEF ){
66148: u.ah.ctx.pFunc = pOp->p4.pFunc;
66149: u.ah.ctx.pVdbeFunc = 0;
66150: }else{
66151: u.ah.ctx.pVdbeFunc = (VdbeFunc*)pOp->p4.pVdbeFunc;
66152: u.ah.ctx.pFunc = u.ah.ctx.pVdbeFunc->pFunc;
66153: }
66154:
66155: u.ah.ctx.s.flags = MEM_Null;
66156: u.ah.ctx.s.db = db;
66157: u.ah.ctx.s.xDel = 0;
66158: u.ah.ctx.s.zMalloc = 0;
66159:
66160: /* The output cell may already have a buffer allocated. Move
66161: ** the pointer to u.ah.ctx.s so in case the user-function can use
66162: ** the already allocated buffer instead of allocating a new one.
66163: */
66164: sqlite3VdbeMemMove(&u.ah.ctx.s, pOut);
66165: MemSetTypeFlag(&u.ah.ctx.s, MEM_Null);
66166:
66167: u.ah.ctx.isError = 0;
66168: if( u.ah.ctx.pFunc->flags & SQLITE_FUNC_NEEDCOLL ){
66169: assert( pOp>aOp );
66170: assert( pOp[-1].p4type==P4_COLLSEQ );
66171: assert( pOp[-1].opcode==OP_CollSeq );
66172: u.ah.ctx.pColl = pOp[-1].p4.pColl;
66173: }
66174: db->lastRowid = lastRowid;
66175: (*u.ah.ctx.pFunc->xFunc)(&u.ah.ctx, u.ah.n, u.ah.apVal); /* IMP: R-24505-23230 */
66176: lastRowid = db->lastRowid;
66177:
66178: /* If any auxiliary data functions have been called by this user function,
66179: ** immediately call the destructor for any non-static values.
66180: */
66181: if( u.ah.ctx.pVdbeFunc ){
66182: sqlite3VdbeDeleteAuxData(u.ah.ctx.pVdbeFunc, pOp->p1);
66183: pOp->p4.pVdbeFunc = u.ah.ctx.pVdbeFunc;
66184: pOp->p4type = P4_VDBEFUNC;
66185: }
66186:
66187: if( db->mallocFailed ){
66188: /* Even though a malloc() has failed, the implementation of the
66189: ** user function may have called an sqlite3_result_XXX() function
66190: ** to return a value. The following call releases any resources
66191: ** associated with such a value.
66192: */
66193: sqlite3VdbeMemRelease(&u.ah.ctx.s);
66194: goto no_mem;
66195: }
66196:
66197: /* If the function returned an error, throw an exception */
66198: if( u.ah.ctx.isError ){
66199: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&u.ah.ctx.s));
66200: rc = u.ah.ctx.isError;
66201: }
66202:
66203: /* Copy the result of the function into register P3 */
66204: sqlite3VdbeChangeEncoding(&u.ah.ctx.s, encoding);
66205: sqlite3VdbeMemMove(pOut, &u.ah.ctx.s);
66206: if( sqlite3VdbeMemTooBig(pOut) ){
66207: goto too_big;
66208: }
66209:
66210: #if 0
66211: /* The app-defined function has done something that as caused this
66212: ** statement to expire. (Perhaps the function called sqlite3_exec()
66213: ** with a CREATE TABLE statement.)
66214: */
66215: if( p->expired ) rc = SQLITE_ABORT;
66216: #endif
66217:
66218: REGISTER_TRACE(pOp->p3, pOut);
66219: UPDATE_MAX_BLOBSIZE(pOut);
66220: break;
66221: }
66222:
66223: /* Opcode: BitAnd P1 P2 P3 * *
66224: **
66225: ** Take the bit-wise AND of the values in register P1 and P2 and
66226: ** store the result in register P3.
66227: ** If either input is NULL, the result is NULL.
66228: */
66229: /* Opcode: BitOr P1 P2 P3 * *
66230: **
66231: ** Take the bit-wise OR of the values in register P1 and P2 and
66232: ** store the result in register P3.
66233: ** If either input is NULL, the result is NULL.
66234: */
66235: /* Opcode: ShiftLeft P1 P2 P3 * *
66236: **
66237: ** Shift the integer value in register P2 to the left by the
66238: ** number of bits specified by the integer in register P1.
66239: ** Store the result in register P3.
66240: ** If either input is NULL, the result is NULL.
66241: */
66242: /* Opcode: ShiftRight P1 P2 P3 * *
66243: **
66244: ** Shift the integer value in register P2 to the right by the
66245: ** number of bits specified by the integer in register P1.
66246: ** Store the result in register P3.
66247: ** If either input is NULL, the result is NULL.
66248: */
66249: case OP_BitAnd: /* same as TK_BITAND, in1, in2, out3 */
66250: case OP_BitOr: /* same as TK_BITOR, in1, in2, out3 */
66251: case OP_ShiftLeft: /* same as TK_LSHIFT, in1, in2, out3 */
66252: case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */
66253: #if 0 /* local variables moved into u.ai */
66254: i64 iA;
66255: u64 uA;
66256: i64 iB;
66257: u8 op;
66258: #endif /* local variables moved into u.ai */
66259:
66260: pIn1 = &aMem[pOp->p1];
66261: pIn2 = &aMem[pOp->p2];
66262: pOut = &aMem[pOp->p3];
66263: if( (pIn1->flags | pIn2->flags) & MEM_Null ){
66264: sqlite3VdbeMemSetNull(pOut);
66265: break;
66266: }
66267: u.ai.iA = sqlite3VdbeIntValue(pIn2);
66268: u.ai.iB = sqlite3VdbeIntValue(pIn1);
66269: u.ai.op = pOp->opcode;
66270: if( u.ai.op==OP_BitAnd ){
66271: u.ai.iA &= u.ai.iB;
66272: }else if( u.ai.op==OP_BitOr ){
66273: u.ai.iA |= u.ai.iB;
66274: }else if( u.ai.iB!=0 ){
66275: assert( u.ai.op==OP_ShiftRight || u.ai.op==OP_ShiftLeft );
66276:
66277: /* If shifting by a negative amount, shift in the other direction */
66278: if( u.ai.iB<0 ){
66279: assert( OP_ShiftRight==OP_ShiftLeft+1 );
66280: u.ai.op = 2*OP_ShiftLeft + 1 - u.ai.op;
66281: u.ai.iB = u.ai.iB>(-64) ? -u.ai.iB : 64;
66282: }
66283:
66284: if( u.ai.iB>=64 ){
66285: u.ai.iA = (u.ai.iA>=0 || u.ai.op==OP_ShiftLeft) ? 0 : -1;
66286: }else{
66287: memcpy(&u.ai.uA, &u.ai.iA, sizeof(u.ai.uA));
66288: if( u.ai.op==OP_ShiftLeft ){
66289: u.ai.uA <<= u.ai.iB;
66290: }else{
66291: u.ai.uA >>= u.ai.iB;
66292: /* Sign-extend on a right shift of a negative number */
66293: if( u.ai.iA<0 ) u.ai.uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-u.ai.iB);
66294: }
66295: memcpy(&u.ai.iA, &u.ai.uA, sizeof(u.ai.iA));
66296: }
66297: }
66298: pOut->u.i = u.ai.iA;
66299: MemSetTypeFlag(pOut, MEM_Int);
66300: break;
66301: }
66302:
66303: /* Opcode: AddImm P1 P2 * * *
66304: **
66305: ** Add the constant P2 to the value in register P1.
66306: ** The result is always an integer.
66307: **
66308: ** To force any register to be an integer, just add 0.
66309: */
66310: case OP_AddImm: { /* in1 */
66311: pIn1 = &aMem[pOp->p1];
66312: memAboutToChange(p, pIn1);
66313: sqlite3VdbeMemIntegerify(pIn1);
66314: pIn1->u.i += pOp->p2;
66315: break;
66316: }
66317:
66318: /* Opcode: MustBeInt P1 P2 * * *
66319: **
66320: ** Force the value in register P1 to be an integer. If the value
66321: ** in P1 is not an integer and cannot be converted into an integer
66322: ** without data loss, then jump immediately to P2, or if P2==0
66323: ** raise an SQLITE_MISMATCH exception.
66324: */
66325: case OP_MustBeInt: { /* jump, in1 */
66326: pIn1 = &aMem[pOp->p1];
66327: applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
66328: if( (pIn1->flags & MEM_Int)==0 ){
66329: if( pOp->p2==0 ){
66330: rc = SQLITE_MISMATCH;
66331: goto abort_due_to_error;
66332: }else{
66333: pc = pOp->p2 - 1;
66334: }
66335: }else{
66336: MemSetTypeFlag(pIn1, MEM_Int);
66337: }
66338: break;
66339: }
66340:
66341: #ifndef SQLITE_OMIT_FLOATING_POINT
66342: /* Opcode: RealAffinity P1 * * * *
66343: **
66344: ** If register P1 holds an integer convert it to a real value.
66345: **
66346: ** This opcode is used when extracting information from a column that
66347: ** has REAL affinity. Such column values may still be stored as
66348: ** integers, for space efficiency, but after extraction we want them
66349: ** to have only a real value.
66350: */
66351: case OP_RealAffinity: { /* in1 */
66352: pIn1 = &aMem[pOp->p1];
66353: if( pIn1->flags & MEM_Int ){
66354: sqlite3VdbeMemRealify(pIn1);
66355: }
66356: break;
66357: }
66358: #endif
66359:
66360: #ifndef SQLITE_OMIT_CAST
66361: /* Opcode: ToText P1 * * * *
66362: **
66363: ** Force the value in register P1 to be text.
66364: ** If the value is numeric, convert it to a string using the
66365: ** equivalent of printf(). Blob values are unchanged and
66366: ** are afterwards simply interpreted as text.
66367: **
66368: ** A NULL value is not changed by this routine. It remains NULL.
66369: */
66370: case OP_ToText: { /* same as TK_TO_TEXT, in1 */
66371: pIn1 = &aMem[pOp->p1];
66372: memAboutToChange(p, pIn1);
66373: if( pIn1->flags & MEM_Null ) break;
66374: assert( MEM_Str==(MEM_Blob>>3) );
66375: pIn1->flags |= (pIn1->flags&MEM_Blob)>>3;
66376: applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
66377: rc = ExpandBlob(pIn1);
66378: assert( pIn1->flags & MEM_Str || db->mallocFailed );
66379: pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_Blob|MEM_Zero);
66380: UPDATE_MAX_BLOBSIZE(pIn1);
66381: break;
66382: }
66383:
66384: /* Opcode: ToBlob P1 * * * *
66385: **
66386: ** Force the value in register P1 to be a BLOB.
66387: ** If the value is numeric, convert it to a string first.
66388: ** Strings are simply reinterpreted as blobs with no change
66389: ** to the underlying data.
66390: **
66391: ** A NULL value is not changed by this routine. It remains NULL.
66392: */
66393: case OP_ToBlob: { /* same as TK_TO_BLOB, in1 */
66394: pIn1 = &aMem[pOp->p1];
66395: if( pIn1->flags & MEM_Null ) break;
66396: if( (pIn1->flags & MEM_Blob)==0 ){
66397: applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
66398: assert( pIn1->flags & MEM_Str || db->mallocFailed );
66399: MemSetTypeFlag(pIn1, MEM_Blob);
66400: }else{
66401: pIn1->flags &= ~(MEM_TypeMask&~MEM_Blob);
66402: }
66403: UPDATE_MAX_BLOBSIZE(pIn1);
66404: break;
66405: }
66406:
66407: /* Opcode: ToNumeric P1 * * * *
66408: **
66409: ** Force the value in register P1 to be numeric (either an
66410: ** integer or a floating-point number.)
66411: ** If the value is text or blob, try to convert it to an using the
66412: ** equivalent of atoi() or atof() and store 0 if no such conversion
66413: ** is possible.
66414: **
66415: ** A NULL value is not changed by this routine. It remains NULL.
66416: */
66417: case OP_ToNumeric: { /* same as TK_TO_NUMERIC, in1 */
66418: pIn1 = &aMem[pOp->p1];
66419: sqlite3VdbeMemNumerify(pIn1);
66420: break;
66421: }
66422: #endif /* SQLITE_OMIT_CAST */
66423:
66424: /* Opcode: ToInt P1 * * * *
66425: **
66426: ** Force the value in register P1 to be an integer. If
66427: ** The value is currently a real number, drop its fractional part.
66428: ** If the value is text or blob, try to convert it to an integer using the
66429: ** equivalent of atoi() and store 0 if no such conversion is possible.
66430: **
66431: ** A NULL value is not changed by this routine. It remains NULL.
66432: */
66433: case OP_ToInt: { /* same as TK_TO_INT, in1 */
66434: pIn1 = &aMem[pOp->p1];
66435: if( (pIn1->flags & MEM_Null)==0 ){
66436: sqlite3VdbeMemIntegerify(pIn1);
66437: }
66438: break;
66439: }
66440:
66441: #if !defined(SQLITE_OMIT_CAST) && !defined(SQLITE_OMIT_FLOATING_POINT)
66442: /* Opcode: ToReal P1 * * * *
66443: **
66444: ** Force the value in register P1 to be a floating point number.
66445: ** If The value is currently an integer, convert it.
66446: ** If the value is text or blob, try to convert it to an integer using the
66447: ** equivalent of atoi() and store 0.0 if no such conversion is possible.
66448: **
66449: ** A NULL value is not changed by this routine. It remains NULL.
66450: */
66451: case OP_ToReal: { /* same as TK_TO_REAL, in1 */
66452: pIn1 = &aMem[pOp->p1];
66453: memAboutToChange(p, pIn1);
66454: if( (pIn1->flags & MEM_Null)==0 ){
66455: sqlite3VdbeMemRealify(pIn1);
66456: }
66457: break;
66458: }
66459: #endif /* !defined(SQLITE_OMIT_CAST) && !defined(SQLITE_OMIT_FLOATING_POINT) */
66460:
66461: /* Opcode: Lt P1 P2 P3 P4 P5
66462: **
66463: ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then
66464: ** jump to address P2.
66465: **
66466: ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
66467: ** reg(P3) is NULL then take the jump. If the SQLITE_JUMPIFNULL
66468: ** bit is clear then fall through if either operand is NULL.
66469: **
66470: ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
66471: ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made
66472: ** to coerce both inputs according to this affinity before the
66473: ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
66474: ** affinity is used. Note that the affinity conversions are stored
66475: ** back into the input registers P1 and P3. So this opcode can cause
66476: ** persistent changes to registers P1 and P3.
66477: **
66478: ** Once any conversions have taken place, and neither value is NULL,
66479: ** the values are compared. If both values are blobs then memcmp() is
66480: ** used to determine the results of the comparison. If both values
66481: ** are text, then the appropriate collating function specified in
66482: ** P4 is used to do the comparison. If P4 is not specified then
66483: ** memcmp() is used to compare text string. If both values are
66484: ** numeric, then a numeric comparison is used. If the two values
66485: ** are of different types, then numbers are considered less than
66486: ** strings and strings are considered less than blobs.
66487: **
66488: ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump. Instead,
66489: ** store a boolean result (either 0, or 1, or NULL) in register P2.
66490: */
66491: /* Opcode: Ne P1 P2 P3 P4 P5
66492: **
66493: ** This works just like the Lt opcode except that the jump is taken if
66494: ** the operands in registers P1 and P3 are not equal. See the Lt opcode for
66495: ** additional information.
66496: **
66497: ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
66498: ** true or false and is never NULL. If both operands are NULL then the result
66499: ** of comparison is false. If either operand is NULL then the result is true.
66500: ** If neither operand is NULL the result is the same as it would be if
66501: ** the SQLITE_NULLEQ flag were omitted from P5.
66502: */
66503: /* Opcode: Eq P1 P2 P3 P4 P5
66504: **
66505: ** This works just like the Lt opcode except that the jump is taken if
66506: ** the operands in registers P1 and P3 are equal.
66507: ** See the Lt opcode for additional information.
66508: **
66509: ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
66510: ** true or false and is never NULL. If both operands are NULL then the result
66511: ** of comparison is true. If either operand is NULL then the result is false.
66512: ** If neither operand is NULL the result is the same as it would be if
66513: ** the SQLITE_NULLEQ flag were omitted from P5.
66514: */
66515: /* Opcode: Le P1 P2 P3 P4 P5
66516: **
66517: ** This works just like the Lt opcode except that the jump is taken if
66518: ** the content of register P3 is less than or equal to the content of
66519: ** register P1. See the Lt opcode for additional information.
66520: */
66521: /* Opcode: Gt P1 P2 P3 P4 P5
66522: **
66523: ** This works just like the Lt opcode except that the jump is taken if
66524: ** the content of register P3 is greater than the content of
66525: ** register P1. See the Lt opcode for additional information.
66526: */
66527: /* Opcode: Ge P1 P2 P3 P4 P5
66528: **
66529: ** This works just like the Lt opcode except that the jump is taken if
66530: ** the content of register P3 is greater than or equal to the content of
66531: ** register P1. See the Lt opcode for additional information.
66532: */
66533: case OP_Eq: /* same as TK_EQ, jump, in1, in3 */
66534: case OP_Ne: /* same as TK_NE, jump, in1, in3 */
66535: case OP_Lt: /* same as TK_LT, jump, in1, in3 */
66536: case OP_Le: /* same as TK_LE, jump, in1, in3 */
66537: case OP_Gt: /* same as TK_GT, jump, in1, in3 */
66538: case OP_Ge: { /* same as TK_GE, jump, in1, in3 */
66539: #if 0 /* local variables moved into u.aj */
66540: int res; /* Result of the comparison of pIn1 against pIn3 */
66541: char affinity; /* Affinity to use for comparison */
66542: u16 flags1; /* Copy of initial value of pIn1->flags */
66543: u16 flags3; /* Copy of initial value of pIn3->flags */
66544: #endif /* local variables moved into u.aj */
66545:
66546: pIn1 = &aMem[pOp->p1];
66547: pIn3 = &aMem[pOp->p3];
66548: u.aj.flags1 = pIn1->flags;
66549: u.aj.flags3 = pIn3->flags;
66550: if( (u.aj.flags1 | u.aj.flags3)&MEM_Null ){
66551: /* One or both operands are NULL */
66552: if( pOp->p5 & SQLITE_NULLEQ ){
66553: /* If SQLITE_NULLEQ is set (which will only happen if the operator is
66554: ** OP_Eq or OP_Ne) then take the jump or not depending on whether
66555: ** or not both operands are null.
66556: */
66557: assert( pOp->opcode==OP_Eq || pOp->opcode==OP_Ne );
66558: u.aj.res = (u.aj.flags1 & u.aj.flags3 & MEM_Null)==0;
66559: }else{
66560: /* SQLITE_NULLEQ is clear and at least one operand is NULL,
66561: ** then the result is always NULL.
66562: ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
66563: */
66564: if( pOp->p5 & SQLITE_STOREP2 ){
66565: pOut = &aMem[pOp->p2];
66566: MemSetTypeFlag(pOut, MEM_Null);
66567: REGISTER_TRACE(pOp->p2, pOut);
66568: }else if( pOp->p5 & SQLITE_JUMPIFNULL ){
66569: pc = pOp->p2-1;
66570: }
66571: break;
66572: }
66573: }else{
66574: /* Neither operand is NULL. Do a comparison. */
66575: u.aj.affinity = pOp->p5 & SQLITE_AFF_MASK;
66576: if( u.aj.affinity ){
66577: applyAffinity(pIn1, u.aj.affinity, encoding);
66578: applyAffinity(pIn3, u.aj.affinity, encoding);
66579: if( db->mallocFailed ) goto no_mem;
66580: }
66581:
66582: assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
66583: ExpandBlob(pIn1);
66584: ExpandBlob(pIn3);
66585: u.aj.res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
66586: }
66587: switch( pOp->opcode ){
66588: case OP_Eq: u.aj.res = u.aj.res==0; break;
66589: case OP_Ne: u.aj.res = u.aj.res!=0; break;
66590: case OP_Lt: u.aj.res = u.aj.res<0; break;
66591: case OP_Le: u.aj.res = u.aj.res<=0; break;
66592: case OP_Gt: u.aj.res = u.aj.res>0; break;
66593: default: u.aj.res = u.aj.res>=0; break;
66594: }
66595:
66596: if( pOp->p5 & SQLITE_STOREP2 ){
66597: pOut = &aMem[pOp->p2];
66598: memAboutToChange(p, pOut);
66599: MemSetTypeFlag(pOut, MEM_Int);
66600: pOut->u.i = u.aj.res;
66601: REGISTER_TRACE(pOp->p2, pOut);
66602: }else if( u.aj.res ){
66603: pc = pOp->p2-1;
66604: }
66605:
66606: /* Undo any changes made by applyAffinity() to the input registers. */
66607: pIn1->flags = (pIn1->flags&~MEM_TypeMask) | (u.aj.flags1&MEM_TypeMask);
66608: pIn3->flags = (pIn3->flags&~MEM_TypeMask) | (u.aj.flags3&MEM_TypeMask);
66609: break;
66610: }
66611:
66612: /* Opcode: Permutation * * * P4 *
66613: **
66614: ** Set the permutation used by the OP_Compare operator to be the array
66615: ** of integers in P4.
66616: **
66617: ** The permutation is only valid until the next OP_Permutation, OP_Compare,
66618: ** OP_Halt, or OP_ResultRow. Typically the OP_Permutation should occur
66619: ** immediately prior to the OP_Compare.
66620: */
66621: case OP_Permutation: {
66622: assert( pOp->p4type==P4_INTARRAY );
66623: assert( pOp->p4.ai );
66624: aPermute = pOp->p4.ai;
66625: break;
66626: }
66627:
66628: /* Opcode: Compare P1 P2 P3 P4 *
66629: **
66630: ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
66631: ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
66632: ** the comparison for use by the next OP_Jump instruct.
66633: **
66634: ** P4 is a KeyInfo structure that defines collating sequences and sort
66635: ** orders for the comparison. The permutation applies to registers
66636: ** only. The KeyInfo elements are used sequentially.
66637: **
66638: ** The comparison is a sort comparison, so NULLs compare equal,
66639: ** NULLs are less than numbers, numbers are less than strings,
66640: ** and strings are less than blobs.
66641: */
66642: case OP_Compare: {
66643: #if 0 /* local variables moved into u.ak */
66644: int n;
66645: int i;
66646: int p1;
66647: int p2;
66648: const KeyInfo *pKeyInfo;
66649: int idx;
66650: CollSeq *pColl; /* Collating sequence to use on this term */
66651: int bRev; /* True for DESCENDING sort order */
66652: #endif /* local variables moved into u.ak */
66653:
66654: u.ak.n = pOp->p3;
66655: u.ak.pKeyInfo = pOp->p4.pKeyInfo;
66656: assert( u.ak.n>0 );
66657: assert( u.ak.pKeyInfo!=0 );
66658: u.ak.p1 = pOp->p1;
66659: u.ak.p2 = pOp->p2;
66660: #if SQLITE_DEBUG
66661: if( aPermute ){
66662: int k, mx = 0;
66663: for(k=0; k<u.ak.n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
66664: assert( u.ak.p1>0 && u.ak.p1+mx<=p->nMem+1 );
66665: assert( u.ak.p2>0 && u.ak.p2+mx<=p->nMem+1 );
66666: }else{
66667: assert( u.ak.p1>0 && u.ak.p1+u.ak.n<=p->nMem+1 );
66668: assert( u.ak.p2>0 && u.ak.p2+u.ak.n<=p->nMem+1 );
66669: }
66670: #endif /* SQLITE_DEBUG */
66671: for(u.ak.i=0; u.ak.i<u.ak.n; u.ak.i++){
66672: u.ak.idx = aPermute ? aPermute[u.ak.i] : u.ak.i;
66673: assert( memIsValid(&aMem[u.ak.p1+u.ak.idx]) );
66674: assert( memIsValid(&aMem[u.ak.p2+u.ak.idx]) );
66675: REGISTER_TRACE(u.ak.p1+u.ak.idx, &aMem[u.ak.p1+u.ak.idx]);
66676: REGISTER_TRACE(u.ak.p2+u.ak.idx, &aMem[u.ak.p2+u.ak.idx]);
66677: assert( u.ak.i<u.ak.pKeyInfo->nField );
66678: u.ak.pColl = u.ak.pKeyInfo->aColl[u.ak.i];
66679: u.ak.bRev = u.ak.pKeyInfo->aSortOrder[u.ak.i];
66680: iCompare = sqlite3MemCompare(&aMem[u.ak.p1+u.ak.idx], &aMem[u.ak.p2+u.ak.idx], u.ak.pColl);
66681: if( iCompare ){
66682: if( u.ak.bRev ) iCompare = -iCompare;
66683: break;
66684: }
66685: }
66686: aPermute = 0;
66687: break;
66688: }
66689:
66690: /* Opcode: Jump P1 P2 P3 * *
66691: **
66692: ** Jump to the instruction at address P1, P2, or P3 depending on whether
66693: ** in the most recent OP_Compare instruction the P1 vector was less than
66694: ** equal to, or greater than the P2 vector, respectively.
66695: */
66696: case OP_Jump: { /* jump */
66697: if( iCompare<0 ){
66698: pc = pOp->p1 - 1;
66699: }else if( iCompare==0 ){
66700: pc = pOp->p2 - 1;
66701: }else{
66702: pc = pOp->p3 - 1;
66703: }
66704: break;
66705: }
66706:
66707: /* Opcode: And P1 P2 P3 * *
66708: **
66709: ** Take the logical AND of the values in registers P1 and P2 and
66710: ** write the result into register P3.
66711: **
66712: ** If either P1 or P2 is 0 (false) then the result is 0 even if
66713: ** the other input is NULL. A NULL and true or two NULLs give
66714: ** a NULL output.
66715: */
66716: /* Opcode: Or P1 P2 P3 * *
66717: **
66718: ** Take the logical OR of the values in register P1 and P2 and
66719: ** store the answer in register P3.
66720: **
66721: ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
66722: ** even if the other input is NULL. A NULL and false or two NULLs
66723: ** give a NULL output.
66724: */
66725: case OP_And: /* same as TK_AND, in1, in2, out3 */
66726: case OP_Or: { /* same as TK_OR, in1, in2, out3 */
66727: #if 0 /* local variables moved into u.al */
66728: int v1; /* Left operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
66729: int v2; /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
66730: #endif /* local variables moved into u.al */
66731:
66732: pIn1 = &aMem[pOp->p1];
66733: if( pIn1->flags & MEM_Null ){
66734: u.al.v1 = 2;
66735: }else{
66736: u.al.v1 = sqlite3VdbeIntValue(pIn1)!=0;
66737: }
66738: pIn2 = &aMem[pOp->p2];
66739: if( pIn2->flags & MEM_Null ){
66740: u.al.v2 = 2;
66741: }else{
66742: u.al.v2 = sqlite3VdbeIntValue(pIn2)!=0;
66743: }
66744: if( pOp->opcode==OP_And ){
66745: static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
66746: u.al.v1 = and_logic[u.al.v1*3+u.al.v2];
66747: }else{
66748: static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
66749: u.al.v1 = or_logic[u.al.v1*3+u.al.v2];
66750: }
66751: pOut = &aMem[pOp->p3];
66752: if( u.al.v1==2 ){
66753: MemSetTypeFlag(pOut, MEM_Null);
66754: }else{
66755: pOut->u.i = u.al.v1;
66756: MemSetTypeFlag(pOut, MEM_Int);
66757: }
66758: break;
66759: }
66760:
66761: /* Opcode: Not P1 P2 * * *
66762: **
66763: ** Interpret the value in register P1 as a boolean value. Store the
66764: ** boolean complement in register P2. If the value in register P1 is
66765: ** NULL, then a NULL is stored in P2.
66766: */
66767: case OP_Not: { /* same as TK_NOT, in1, out2 */
66768: pIn1 = &aMem[pOp->p1];
66769: pOut = &aMem[pOp->p2];
66770: if( pIn1->flags & MEM_Null ){
66771: sqlite3VdbeMemSetNull(pOut);
66772: }else{
66773: sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeIntValue(pIn1));
66774: }
66775: break;
66776: }
66777:
66778: /* Opcode: BitNot P1 P2 * * *
66779: **
66780: ** Interpret the content of register P1 as an integer. Store the
66781: ** ones-complement of the P1 value into register P2. If P1 holds
66782: ** a NULL then store a NULL in P2.
66783: */
66784: case OP_BitNot: { /* same as TK_BITNOT, in1, out2 */
66785: pIn1 = &aMem[pOp->p1];
66786: pOut = &aMem[pOp->p2];
66787: if( pIn1->flags & MEM_Null ){
66788: sqlite3VdbeMemSetNull(pOut);
66789: }else{
66790: sqlite3VdbeMemSetInt64(pOut, ~sqlite3VdbeIntValue(pIn1));
66791: }
66792: break;
66793: }
66794:
66795: /* Opcode: Once P1 P2 * * *
66796: **
66797: ** Check if OP_Once flag P1 is set. If so, jump to instruction P2. Otherwise,
66798: ** set the flag and fall through to the next instruction.
66799: **
66800: ** See also: JumpOnce
66801: */
66802: case OP_Once: { /* jump */
66803: assert( pOp->p1<p->nOnceFlag );
66804: if( p->aOnceFlag[pOp->p1] ){
66805: pc = pOp->p2-1;
66806: }else{
66807: p->aOnceFlag[pOp->p1] = 1;
66808: }
66809: break;
66810: }
66811:
66812: /* Opcode: If P1 P2 P3 * *
66813: **
66814: ** Jump to P2 if the value in register P1 is true. The value
66815: ** is considered true if it is numeric and non-zero. If the value
66816: ** in P1 is NULL then take the jump if P3 is non-zero.
66817: */
66818: /* Opcode: IfNot P1 P2 P3 * *
66819: **
66820: ** Jump to P2 if the value in register P1 is False. The value
66821: ** is considered false if it has a numeric value of zero. If the value
66822: ** in P1 is NULL then take the jump if P3 is zero.
66823: */
66824: case OP_If: /* jump, in1 */
66825: case OP_IfNot: { /* jump, in1 */
66826: #if 0 /* local variables moved into u.am */
66827: int c;
66828: #endif /* local variables moved into u.am */
66829: pIn1 = &aMem[pOp->p1];
66830: if( pIn1->flags & MEM_Null ){
66831: u.am.c = pOp->p3;
66832: }else{
66833: #ifdef SQLITE_OMIT_FLOATING_POINT
66834: u.am.c = sqlite3VdbeIntValue(pIn1)!=0;
66835: #else
66836: u.am.c = sqlite3VdbeRealValue(pIn1)!=0.0;
66837: #endif
66838: if( pOp->opcode==OP_IfNot ) u.am.c = !u.am.c;
66839: }
66840: if( u.am.c ){
66841: pc = pOp->p2-1;
66842: }
66843: break;
66844: }
66845:
66846: /* Opcode: IsNull P1 P2 * * *
66847: **
66848: ** Jump to P2 if the value in register P1 is NULL.
66849: */
66850: case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */
66851: pIn1 = &aMem[pOp->p1];
66852: if( (pIn1->flags & MEM_Null)!=0 ){
66853: pc = pOp->p2 - 1;
66854: }
66855: break;
66856: }
66857:
66858: /* Opcode: NotNull P1 P2 * * *
66859: **
66860: ** Jump to P2 if the value in register P1 is not NULL.
66861: */
66862: case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */
66863: pIn1 = &aMem[pOp->p1];
66864: if( (pIn1->flags & MEM_Null)==0 ){
66865: pc = pOp->p2 - 1;
66866: }
66867: break;
66868: }
66869:
66870: /* Opcode: Column P1 P2 P3 P4 P5
66871: **
66872: ** Interpret the data that cursor P1 points to as a structure built using
66873: ** the MakeRecord instruction. (See the MakeRecord opcode for additional
66874: ** information about the format of the data.) Extract the P2-th column
66875: ** from this record. If there are less that (P2+1)
66876: ** values in the record, extract a NULL.
66877: **
66878: ** The value extracted is stored in register P3.
66879: **
66880: ** If the column contains fewer than P2 fields, then extract a NULL. Or,
66881: ** if the P4 argument is a P4_MEM use the value of the P4 argument as
66882: ** the result.
66883: **
66884: ** If the OPFLAG_CLEARCACHE bit is set on P5 and P1 is a pseudo-table cursor,
66885: ** then the cache of the cursor is reset prior to extracting the column.
66886: ** The first OP_Column against a pseudo-table after the value of the content
66887: ** register has changed should have this bit set.
66888: */
66889: case OP_Column: {
66890: #if 0 /* local variables moved into u.an */
66891: u32 payloadSize; /* Number of bytes in the record */
66892: i64 payloadSize64; /* Number of bytes in the record */
66893: int p1; /* P1 value of the opcode */
66894: int p2; /* column number to retrieve */
66895: VdbeCursor *pC; /* The VDBE cursor */
66896: char *zRec; /* Pointer to complete record-data */
66897: BtCursor *pCrsr; /* The BTree cursor */
66898: u32 *aType; /* aType[i] holds the numeric type of the i-th column */
66899: u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
66900: int nField; /* number of fields in the record */
66901: int len; /* The length of the serialized data for the column */
66902: int i; /* Loop counter */
66903: char *zData; /* Part of the record being decoded */
66904: Mem *pDest; /* Where to write the extracted value */
66905: Mem sMem; /* For storing the record being decoded */
66906: u8 *zIdx; /* Index into header */
66907: u8 *zEndHdr; /* Pointer to first byte after the header */
66908: u32 offset; /* Offset into the data */
66909: u32 szField; /* Number of bytes in the content of a field */
66910: int szHdr; /* Size of the header size field at start of record */
66911: int avail; /* Number of bytes of available data */
66912: u32 t; /* A type code from the record header */
66913: Mem *pReg; /* PseudoTable input register */
66914: #endif /* local variables moved into u.an */
66915:
66916:
66917: u.an.p1 = pOp->p1;
66918: u.an.p2 = pOp->p2;
66919: u.an.pC = 0;
66920: memset(&u.an.sMem, 0, sizeof(u.an.sMem));
66921: assert( u.an.p1<p->nCursor );
66922: assert( pOp->p3>0 && pOp->p3<=p->nMem );
66923: u.an.pDest = &aMem[pOp->p3];
66924: memAboutToChange(p, u.an.pDest);
66925: u.an.zRec = 0;
66926:
66927: /* This block sets the variable u.an.payloadSize to be the total number of
66928: ** bytes in the record.
66929: **
66930: ** u.an.zRec is set to be the complete text of the record if it is available.
66931: ** The complete record text is always available for pseudo-tables
66932: ** If the record is stored in a cursor, the complete record text
66933: ** might be available in the u.an.pC->aRow cache. Or it might not be.
66934: ** If the data is unavailable, u.an.zRec is set to NULL.
66935: **
66936: ** We also compute the number of columns in the record. For cursors,
66937: ** the number of columns is stored in the VdbeCursor.nField element.
66938: */
66939: u.an.pC = p->apCsr[u.an.p1];
66940: assert( u.an.pC!=0 );
66941: #ifndef SQLITE_OMIT_VIRTUALTABLE
66942: assert( u.an.pC->pVtabCursor==0 );
66943: #endif
66944: u.an.pCrsr = u.an.pC->pCursor;
66945: if( u.an.pCrsr!=0 ){
66946: /* The record is stored in a B-Tree */
66947: rc = sqlite3VdbeCursorMoveto(u.an.pC);
66948: if( rc ) goto abort_due_to_error;
66949: if( u.an.pC->nullRow ){
66950: u.an.payloadSize = 0;
66951: }else if( u.an.pC->cacheStatus==p->cacheCtr ){
66952: u.an.payloadSize = u.an.pC->payloadSize;
66953: u.an.zRec = (char*)u.an.pC->aRow;
66954: }else if( u.an.pC->isIndex ){
66955: assert( sqlite3BtreeCursorIsValid(u.an.pCrsr) );
66956: VVA_ONLY(rc =) sqlite3BtreeKeySize(u.an.pCrsr, &u.an.payloadSize64);
66957: assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
66958: /* sqlite3BtreeParseCellPtr() uses getVarint32() to extract the
66959: ** payload size, so it is impossible for u.an.payloadSize64 to be
66960: ** larger than 32 bits. */
66961: assert( (u.an.payloadSize64 & SQLITE_MAX_U32)==(u64)u.an.payloadSize64 );
66962: u.an.payloadSize = (u32)u.an.payloadSize64;
66963: }else{
66964: assert( sqlite3BtreeCursorIsValid(u.an.pCrsr) );
66965: VVA_ONLY(rc =) sqlite3BtreeDataSize(u.an.pCrsr, &u.an.payloadSize);
66966: assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
66967: }
66968: }else if( ALWAYS(u.an.pC->pseudoTableReg>0) ){
66969: u.an.pReg = &aMem[u.an.pC->pseudoTableReg];
66970: assert( u.an.pReg->flags & MEM_Blob );
66971: assert( memIsValid(u.an.pReg) );
66972: u.an.payloadSize = u.an.pReg->n;
66973: u.an.zRec = u.an.pReg->z;
66974: u.an.pC->cacheStatus = (pOp->p5&OPFLAG_CLEARCACHE) ? CACHE_STALE : p->cacheCtr;
66975: assert( u.an.payloadSize==0 || u.an.zRec!=0 );
66976: }else{
66977: /* Consider the row to be NULL */
66978: u.an.payloadSize = 0;
66979: }
66980:
66981: /* If u.an.payloadSize is 0, then just store a NULL. This can happen because of
66982: ** nullRow or because of a corrupt database. */
66983: if( u.an.payloadSize==0 ){
66984: MemSetTypeFlag(u.an.pDest, MEM_Null);
66985: goto op_column_out;
66986: }
66987: assert( db->aLimit[SQLITE_LIMIT_LENGTH]>=0 );
66988: if( u.an.payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
66989: goto too_big;
66990: }
66991:
66992: u.an.nField = u.an.pC->nField;
66993: assert( u.an.p2<u.an.nField );
66994:
66995: /* Read and parse the table header. Store the results of the parse
66996: ** into the record header cache fields of the cursor.
66997: */
66998: u.an.aType = u.an.pC->aType;
66999: if( u.an.pC->cacheStatus==p->cacheCtr ){
67000: u.an.aOffset = u.an.pC->aOffset;
67001: }else{
67002: assert(u.an.aType);
67003: u.an.avail = 0;
67004: u.an.pC->aOffset = u.an.aOffset = &u.an.aType[u.an.nField];
67005: u.an.pC->payloadSize = u.an.payloadSize;
67006: u.an.pC->cacheStatus = p->cacheCtr;
67007:
67008: /* Figure out how many bytes are in the header */
67009: if( u.an.zRec ){
67010: u.an.zData = u.an.zRec;
67011: }else{
67012: if( u.an.pC->isIndex ){
67013: u.an.zData = (char*)sqlite3BtreeKeyFetch(u.an.pCrsr, &u.an.avail);
67014: }else{
67015: u.an.zData = (char*)sqlite3BtreeDataFetch(u.an.pCrsr, &u.an.avail);
67016: }
67017: /* If KeyFetch()/DataFetch() managed to get the entire payload,
67018: ** save the payload in the u.an.pC->aRow cache. That will save us from
67019: ** having to make additional calls to fetch the content portion of
67020: ** the record.
67021: */
67022: assert( u.an.avail>=0 );
67023: if( u.an.payloadSize <= (u32)u.an.avail ){
67024: u.an.zRec = u.an.zData;
67025: u.an.pC->aRow = (u8*)u.an.zData;
67026: }else{
67027: u.an.pC->aRow = 0;
67028: }
67029: }
67030: /* The following assert is true in all cases accept when
67031: ** the database file has been corrupted externally.
67032: ** assert( u.an.zRec!=0 || u.an.avail>=u.an.payloadSize || u.an.avail>=9 ); */
67033: u.an.szHdr = getVarint32((u8*)u.an.zData, u.an.offset);
67034:
67035: /* Make sure a corrupt database has not given us an oversize header.
67036: ** Do this now to avoid an oversize memory allocation.
67037: **
67038: ** Type entries can be between 1 and 5 bytes each. But 4 and 5 byte
67039: ** types use so much data space that there can only be 4096 and 32 of
67040: ** them, respectively. So the maximum header length results from a
67041: ** 3-byte type for each of the maximum of 32768 columns plus three
67042: ** extra bytes for the header length itself. 32768*3 + 3 = 98307.
67043: */
67044: if( u.an.offset > 98307 ){
67045: rc = SQLITE_CORRUPT_BKPT;
67046: goto op_column_out;
67047: }
67048:
67049: /* Compute in u.an.len the number of bytes of data we need to read in order
67050: ** to get u.an.nField type values. u.an.offset is an upper bound on this. But
67051: ** u.an.nField might be significantly less than the true number of columns
67052: ** in the table, and in that case, 5*u.an.nField+3 might be smaller than u.an.offset.
67053: ** We want to minimize u.an.len in order to limit the size of the memory
67054: ** allocation, especially if a corrupt database file has caused u.an.offset
67055: ** to be oversized. Offset is limited to 98307 above. But 98307 might
67056: ** still exceed Robson memory allocation limits on some configurations.
67057: ** On systems that cannot tolerate large memory allocations, u.an.nField*5+3
67058: ** will likely be much smaller since u.an.nField will likely be less than
67059: ** 20 or so. This insures that Robson memory allocation limits are
67060: ** not exceeded even for corrupt database files.
67061: */
67062: u.an.len = u.an.nField*5 + 3;
67063: if( u.an.len > (int)u.an.offset ) u.an.len = (int)u.an.offset;
67064:
67065: /* The KeyFetch() or DataFetch() above are fast and will get the entire
67066: ** record header in most cases. But they will fail to get the complete
67067: ** record header if the record header does not fit on a single page
67068: ** in the B-Tree. When that happens, use sqlite3VdbeMemFromBtree() to
67069: ** acquire the complete header text.
67070: */
67071: if( !u.an.zRec && u.an.avail<u.an.len ){
67072: u.an.sMem.flags = 0;
67073: u.an.sMem.db = 0;
67074: rc = sqlite3VdbeMemFromBtree(u.an.pCrsr, 0, u.an.len, u.an.pC->isIndex, &u.an.sMem);
67075: if( rc!=SQLITE_OK ){
67076: goto op_column_out;
67077: }
67078: u.an.zData = u.an.sMem.z;
67079: }
67080: u.an.zEndHdr = (u8 *)&u.an.zData[u.an.len];
67081: u.an.zIdx = (u8 *)&u.an.zData[u.an.szHdr];
67082:
67083: /* Scan the header and use it to fill in the u.an.aType[] and u.an.aOffset[]
67084: ** arrays. u.an.aType[u.an.i] will contain the type integer for the u.an.i-th
67085: ** column and u.an.aOffset[u.an.i] will contain the u.an.offset from the beginning
67086: ** of the record to the start of the data for the u.an.i-th column
67087: */
67088: for(u.an.i=0; u.an.i<u.an.nField; u.an.i++){
67089: if( u.an.zIdx<u.an.zEndHdr ){
67090: u.an.aOffset[u.an.i] = u.an.offset;
67091: if( u.an.zIdx[0]<0x80 ){
67092: u.an.t = u.an.zIdx[0];
67093: u.an.zIdx++;
67094: }else{
67095: u.an.zIdx += sqlite3GetVarint32(u.an.zIdx, &u.an.t);
67096: }
67097: u.an.aType[u.an.i] = u.an.t;
67098: u.an.szField = sqlite3VdbeSerialTypeLen(u.an.t);
67099: u.an.offset += u.an.szField;
67100: if( u.an.offset<u.an.szField ){ /* True if u.an.offset overflows */
67101: u.an.zIdx = &u.an.zEndHdr[1]; /* Forces SQLITE_CORRUPT return below */
67102: break;
67103: }
67104: }else{
67105: /* If u.an.i is less that u.an.nField, then there are less fields in this
67106: ** record than SetNumColumns indicated there are columns in the
67107: ** table. Set the u.an.offset for any extra columns not present in
67108: ** the record to 0. This tells code below to store a NULL
67109: ** instead of deserializing a value from the record.
67110: */
67111: u.an.aOffset[u.an.i] = 0;
67112: }
67113: }
67114: sqlite3VdbeMemRelease(&u.an.sMem);
67115: u.an.sMem.flags = MEM_Null;
67116:
67117: /* If we have read more header data than was contained in the header,
67118: ** or if the end of the last field appears to be past the end of the
67119: ** record, or if the end of the last field appears to be before the end
67120: ** of the record (when all fields present), then we must be dealing
67121: ** with a corrupt database.
67122: */
67123: if( (u.an.zIdx > u.an.zEndHdr) || (u.an.offset > u.an.payloadSize)
67124: || (u.an.zIdx==u.an.zEndHdr && u.an.offset!=u.an.payloadSize) ){
67125: rc = SQLITE_CORRUPT_BKPT;
67126: goto op_column_out;
67127: }
67128: }
67129:
67130: /* Get the column information. If u.an.aOffset[u.an.p2] is non-zero, then
67131: ** deserialize the value from the record. If u.an.aOffset[u.an.p2] is zero,
67132: ** then there are not enough fields in the record to satisfy the
67133: ** request. In this case, set the value NULL or to P4 if P4 is
67134: ** a pointer to a Mem object.
67135: */
67136: if( u.an.aOffset[u.an.p2] ){
67137: assert( rc==SQLITE_OK );
67138: if( u.an.zRec ){
67139: VdbeMemRelease(u.an.pDest);
67140: sqlite3VdbeSerialGet((u8 *)&u.an.zRec[u.an.aOffset[u.an.p2]], u.an.aType[u.an.p2], u.an.pDest);
67141: }else{
67142: u.an.len = sqlite3VdbeSerialTypeLen(u.an.aType[u.an.p2]);
67143: sqlite3VdbeMemMove(&u.an.sMem, u.an.pDest);
67144: rc = sqlite3VdbeMemFromBtree(u.an.pCrsr, u.an.aOffset[u.an.p2], u.an.len, u.an.pC->isIndex, &u.an.sMem);
67145: if( rc!=SQLITE_OK ){
67146: goto op_column_out;
67147: }
67148: u.an.zData = u.an.sMem.z;
67149: sqlite3VdbeSerialGet((u8*)u.an.zData, u.an.aType[u.an.p2], u.an.pDest);
67150: }
67151: u.an.pDest->enc = encoding;
67152: }else{
67153: if( pOp->p4type==P4_MEM ){
67154: sqlite3VdbeMemShallowCopy(u.an.pDest, pOp->p4.pMem, MEM_Static);
67155: }else{
67156: MemSetTypeFlag(u.an.pDest, MEM_Null);
67157: }
67158: }
67159:
67160: /* If we dynamically allocated space to hold the data (in the
67161: ** sqlite3VdbeMemFromBtree() call above) then transfer control of that
67162: ** dynamically allocated space over to the u.an.pDest structure.
67163: ** This prevents a memory copy.
67164: */
67165: if( u.an.sMem.zMalloc ){
67166: assert( u.an.sMem.z==u.an.sMem.zMalloc );
67167: assert( !(u.an.pDest->flags & MEM_Dyn) );
67168: assert( !(u.an.pDest->flags & (MEM_Blob|MEM_Str)) || u.an.pDest->z==u.an.sMem.z );
67169: u.an.pDest->flags &= ~(MEM_Ephem|MEM_Static);
67170: u.an.pDest->flags |= MEM_Term;
67171: u.an.pDest->z = u.an.sMem.z;
67172: u.an.pDest->zMalloc = u.an.sMem.zMalloc;
67173: }
67174:
67175: rc = sqlite3VdbeMemMakeWriteable(u.an.pDest);
67176:
67177: op_column_out:
67178: UPDATE_MAX_BLOBSIZE(u.an.pDest);
67179: REGISTER_TRACE(pOp->p3, u.an.pDest);
67180: break;
67181: }
67182:
67183: /* Opcode: Affinity P1 P2 * P4 *
67184: **
67185: ** Apply affinities to a range of P2 registers starting with P1.
67186: **
67187: ** P4 is a string that is P2 characters long. The nth character of the
67188: ** string indicates the column affinity that should be used for the nth
67189: ** memory cell in the range.
67190: */
67191: case OP_Affinity: {
67192: #if 0 /* local variables moved into u.ao */
67193: const char *zAffinity; /* The affinity to be applied */
67194: char cAff; /* A single character of affinity */
67195: #endif /* local variables moved into u.ao */
67196:
67197: u.ao.zAffinity = pOp->p4.z;
67198: assert( u.ao.zAffinity!=0 );
67199: assert( u.ao.zAffinity[pOp->p2]==0 );
67200: pIn1 = &aMem[pOp->p1];
67201: while( (u.ao.cAff = *(u.ao.zAffinity++))!=0 ){
67202: assert( pIn1 <= &p->aMem[p->nMem] );
67203: assert( memIsValid(pIn1) );
67204: ExpandBlob(pIn1);
67205: applyAffinity(pIn1, u.ao.cAff, encoding);
67206: pIn1++;
67207: }
67208: break;
67209: }
67210:
67211: /* Opcode: MakeRecord P1 P2 P3 P4 *
67212: **
67213: ** Convert P2 registers beginning with P1 into the [record format]
67214: ** use as a data record in a database table or as a key
67215: ** in an index. The OP_Column opcode can decode the record later.
67216: **
67217: ** P4 may be a string that is P2 characters long. The nth character of the
67218: ** string indicates the column affinity that should be used for the nth
67219: ** field of the index key.
67220: **
67221: ** The mapping from character to affinity is given by the SQLITE_AFF_
67222: ** macros defined in sqliteInt.h.
67223: **
67224: ** If P4 is NULL then all index fields have the affinity NONE.
67225: */
67226: case OP_MakeRecord: {
67227: #if 0 /* local variables moved into u.ap */
67228: u8 *zNewRecord; /* A buffer to hold the data for the new record */
67229: Mem *pRec; /* The new record */
67230: u64 nData; /* Number of bytes of data space */
67231: int nHdr; /* Number of bytes of header space */
67232: i64 nByte; /* Data space required for this record */
67233: int nZero; /* Number of zero bytes at the end of the record */
67234: int nVarint; /* Number of bytes in a varint */
67235: u32 serial_type; /* Type field */
67236: Mem *pData0; /* First field to be combined into the record */
67237: Mem *pLast; /* Last field of the record */
67238: int nField; /* Number of fields in the record */
67239: char *zAffinity; /* The affinity string for the record */
67240: int file_format; /* File format to use for encoding */
67241: int i; /* Space used in zNewRecord[] */
67242: int len; /* Length of a field */
67243: #endif /* local variables moved into u.ap */
67244:
67245: /* Assuming the record contains N fields, the record format looks
67246: ** like this:
67247: **
67248: ** ------------------------------------------------------------------------
67249: ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
67250: ** ------------------------------------------------------------------------
67251: **
67252: ** Data(0) is taken from register P1. Data(1) comes from register P1+1
67253: ** and so froth.
67254: **
67255: ** Each type field is a varint representing the serial type of the
67256: ** corresponding data element (see sqlite3VdbeSerialType()). The
67257: ** hdr-size field is also a varint which is the offset from the beginning
67258: ** of the record to data0.
67259: */
67260: u.ap.nData = 0; /* Number of bytes of data space */
67261: u.ap.nHdr = 0; /* Number of bytes of header space */
67262: u.ap.nZero = 0; /* Number of zero bytes at the end of the record */
67263: u.ap.nField = pOp->p1;
67264: u.ap.zAffinity = pOp->p4.z;
67265: assert( u.ap.nField>0 && pOp->p2>0 && pOp->p2+u.ap.nField<=p->nMem+1 );
67266: u.ap.pData0 = &aMem[u.ap.nField];
67267: u.ap.nField = pOp->p2;
67268: u.ap.pLast = &u.ap.pData0[u.ap.nField-1];
67269: u.ap.file_format = p->minWriteFileFormat;
67270:
67271: /* Identify the output register */
67272: assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
67273: pOut = &aMem[pOp->p3];
67274: memAboutToChange(p, pOut);
67275:
67276: /* Loop through the elements that will make up the record to figure
67277: ** out how much space is required for the new record.
67278: */
67279: for(u.ap.pRec=u.ap.pData0; u.ap.pRec<=u.ap.pLast; u.ap.pRec++){
67280: assert( memIsValid(u.ap.pRec) );
67281: if( u.ap.zAffinity ){
67282: applyAffinity(u.ap.pRec, u.ap.zAffinity[u.ap.pRec-u.ap.pData0], encoding);
67283: }
67284: if( u.ap.pRec->flags&MEM_Zero && u.ap.pRec->n>0 ){
67285: sqlite3VdbeMemExpandBlob(u.ap.pRec);
67286: }
67287: u.ap.serial_type = sqlite3VdbeSerialType(u.ap.pRec, u.ap.file_format);
67288: u.ap.len = sqlite3VdbeSerialTypeLen(u.ap.serial_type);
67289: u.ap.nData += u.ap.len;
67290: u.ap.nHdr += sqlite3VarintLen(u.ap.serial_type);
67291: if( u.ap.pRec->flags & MEM_Zero ){
67292: /* Only pure zero-filled BLOBs can be input to this Opcode.
67293: ** We do not allow blobs with a prefix and a zero-filled tail. */
67294: u.ap.nZero += u.ap.pRec->u.nZero;
67295: }else if( u.ap.len ){
67296: u.ap.nZero = 0;
67297: }
67298: }
67299:
67300: /* Add the initial header varint and total the size */
67301: u.ap.nHdr += u.ap.nVarint = sqlite3VarintLen(u.ap.nHdr);
67302: if( u.ap.nVarint<sqlite3VarintLen(u.ap.nHdr) ){
67303: u.ap.nHdr++;
67304: }
67305: u.ap.nByte = u.ap.nHdr+u.ap.nData-u.ap.nZero;
67306: if( u.ap.nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
67307: goto too_big;
67308: }
67309:
67310: /* Make sure the output register has a buffer large enough to store
67311: ** the new record. The output register (pOp->p3) is not allowed to
67312: ** be one of the input registers (because the following call to
67313: ** sqlite3VdbeMemGrow() could clobber the value before it is used).
67314: */
67315: if( sqlite3VdbeMemGrow(pOut, (int)u.ap.nByte, 0) ){
67316: goto no_mem;
67317: }
67318: u.ap.zNewRecord = (u8 *)pOut->z;
67319:
67320: /* Write the record */
67321: u.ap.i = putVarint32(u.ap.zNewRecord, u.ap.nHdr);
67322: for(u.ap.pRec=u.ap.pData0; u.ap.pRec<=u.ap.pLast; u.ap.pRec++){
67323: u.ap.serial_type = sqlite3VdbeSerialType(u.ap.pRec, u.ap.file_format);
67324: u.ap.i += putVarint32(&u.ap.zNewRecord[u.ap.i], u.ap.serial_type); /* serial type */
67325: }
67326: for(u.ap.pRec=u.ap.pData0; u.ap.pRec<=u.ap.pLast; u.ap.pRec++){ /* serial data */
67327: u.ap.i += sqlite3VdbeSerialPut(&u.ap.zNewRecord[u.ap.i], (int)(u.ap.nByte-u.ap.i), u.ap.pRec,u.ap.file_format);
67328: }
67329: assert( u.ap.i==u.ap.nByte );
67330:
67331: assert( pOp->p3>0 && pOp->p3<=p->nMem );
67332: pOut->n = (int)u.ap.nByte;
67333: pOut->flags = MEM_Blob | MEM_Dyn;
67334: pOut->xDel = 0;
67335: if( u.ap.nZero ){
67336: pOut->u.nZero = u.ap.nZero;
67337: pOut->flags |= MEM_Zero;
67338: }
67339: pOut->enc = SQLITE_UTF8; /* In case the blob is ever converted to text */
67340: REGISTER_TRACE(pOp->p3, pOut);
67341: UPDATE_MAX_BLOBSIZE(pOut);
67342: break;
67343: }
67344:
67345: /* Opcode: Count P1 P2 * * *
67346: **
67347: ** Store the number of entries (an integer value) in the table or index
67348: ** opened by cursor P1 in register P2
67349: */
67350: #ifndef SQLITE_OMIT_BTREECOUNT
67351: case OP_Count: { /* out2-prerelease */
67352: #if 0 /* local variables moved into u.aq */
67353: i64 nEntry;
67354: BtCursor *pCrsr;
67355: #endif /* local variables moved into u.aq */
67356:
67357: u.aq.pCrsr = p->apCsr[pOp->p1]->pCursor;
67358: if( ALWAYS(u.aq.pCrsr) ){
67359: rc = sqlite3BtreeCount(u.aq.pCrsr, &u.aq.nEntry);
67360: }else{
67361: u.aq.nEntry = 0;
67362: }
67363: pOut->u.i = u.aq.nEntry;
67364: break;
67365: }
67366: #endif
67367:
67368: /* Opcode: Savepoint P1 * * P4 *
67369: **
67370: ** Open, release or rollback the savepoint named by parameter P4, depending
67371: ** on the value of P1. To open a new savepoint, P1==0. To release (commit) an
67372: ** existing savepoint, P1==1, or to rollback an existing savepoint P1==2.
67373: */
67374: case OP_Savepoint: {
67375: #if 0 /* local variables moved into u.ar */
67376: int p1; /* Value of P1 operand */
67377: char *zName; /* Name of savepoint */
67378: int nName;
67379: Savepoint *pNew;
67380: Savepoint *pSavepoint;
67381: Savepoint *pTmp;
67382: int iSavepoint;
67383: int ii;
67384: #endif /* local variables moved into u.ar */
67385:
67386: u.ar.p1 = pOp->p1;
67387: u.ar.zName = pOp->p4.z;
67388:
67389: /* Assert that the u.ar.p1 parameter is valid. Also that if there is no open
67390: ** transaction, then there cannot be any savepoints.
67391: */
67392: assert( db->pSavepoint==0 || db->autoCommit==0 );
67393: assert( u.ar.p1==SAVEPOINT_BEGIN||u.ar.p1==SAVEPOINT_RELEASE||u.ar.p1==SAVEPOINT_ROLLBACK );
67394: assert( db->pSavepoint || db->isTransactionSavepoint==0 );
67395: assert( checkSavepointCount(db) );
67396:
67397: if( u.ar.p1==SAVEPOINT_BEGIN ){
67398: if( db->writeVdbeCnt>0 ){
67399: /* A new savepoint cannot be created if there are active write
67400: ** statements (i.e. open read/write incremental blob handles).
67401: */
67402: sqlite3SetString(&p->zErrMsg, db, "cannot open savepoint - "
67403: "SQL statements in progress");
67404: rc = SQLITE_BUSY;
67405: }else{
67406: u.ar.nName = sqlite3Strlen30(u.ar.zName);
67407:
67408: #ifndef SQLITE_OMIT_VIRTUALTABLE
67409: /* This call is Ok even if this savepoint is actually a transaction
67410: ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
67411: ** If this is a transaction savepoint being opened, it is guaranteed
67412: ** that the db->aVTrans[] array is empty. */
67413: assert( db->autoCommit==0 || db->nVTrans==0 );
67414: rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN,
67415: db->nStatement+db->nSavepoint);
67416: if( rc!=SQLITE_OK ) goto abort_due_to_error;
67417: #endif
67418:
67419: /* Create a new savepoint structure. */
67420: u.ar.pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+u.ar.nName+1);
67421: if( u.ar.pNew ){
67422: u.ar.pNew->zName = (char *)&u.ar.pNew[1];
67423: memcpy(u.ar.pNew->zName, u.ar.zName, u.ar.nName+1);
67424:
67425: /* If there is no open transaction, then mark this as a special
67426: ** "transaction savepoint". */
67427: if( db->autoCommit ){
67428: db->autoCommit = 0;
67429: db->isTransactionSavepoint = 1;
67430: }else{
67431: db->nSavepoint++;
67432: }
67433:
67434: /* Link the new savepoint into the database handle's list. */
67435: u.ar.pNew->pNext = db->pSavepoint;
67436: db->pSavepoint = u.ar.pNew;
67437: u.ar.pNew->nDeferredCons = db->nDeferredCons;
67438: }
67439: }
67440: }else{
67441: u.ar.iSavepoint = 0;
67442:
67443: /* Find the named savepoint. If there is no such savepoint, then an
67444: ** an error is returned to the user. */
67445: for(
67446: u.ar.pSavepoint = db->pSavepoint;
67447: u.ar.pSavepoint && sqlite3StrICmp(u.ar.pSavepoint->zName, u.ar.zName);
67448: u.ar.pSavepoint = u.ar.pSavepoint->pNext
67449: ){
67450: u.ar.iSavepoint++;
67451: }
67452: if( !u.ar.pSavepoint ){
67453: sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", u.ar.zName);
67454: rc = SQLITE_ERROR;
67455: }else if(
67456: db->writeVdbeCnt>0 || (u.ar.p1==SAVEPOINT_ROLLBACK && db->activeVdbeCnt>1)
67457: ){
67458: /* It is not possible to release (commit) a savepoint if there are
67459: ** active write statements. It is not possible to rollback a savepoint
67460: ** if there are any active statements at all.
67461: */
67462: sqlite3SetString(&p->zErrMsg, db,
67463: "cannot %s savepoint - SQL statements in progress",
67464: (u.ar.p1==SAVEPOINT_ROLLBACK ? "rollback": "release")
67465: );
67466: rc = SQLITE_BUSY;
67467: }else{
67468:
67469: /* Determine whether or not this is a transaction savepoint. If so,
67470: ** and this is a RELEASE command, then the current transaction
67471: ** is committed.
67472: */
67473: int isTransaction = u.ar.pSavepoint->pNext==0 && db->isTransactionSavepoint;
67474: if( isTransaction && u.ar.p1==SAVEPOINT_RELEASE ){
67475: if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
67476: goto vdbe_return;
67477: }
67478: db->autoCommit = 1;
67479: if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
67480: p->pc = pc;
67481: db->autoCommit = 0;
67482: p->rc = rc = SQLITE_BUSY;
67483: goto vdbe_return;
67484: }
67485: db->isTransactionSavepoint = 0;
67486: rc = p->rc;
67487: }else{
67488: u.ar.iSavepoint = db->nSavepoint - u.ar.iSavepoint - 1;
67489: for(u.ar.ii=0; u.ar.ii<db->nDb; u.ar.ii++){
67490: rc = sqlite3BtreeSavepoint(db->aDb[u.ar.ii].pBt, u.ar.p1, u.ar.iSavepoint);
67491: if( rc!=SQLITE_OK ){
67492: goto abort_due_to_error;
67493: }
67494: }
67495: if( u.ar.p1==SAVEPOINT_ROLLBACK && (db->flags&SQLITE_InternChanges)!=0 ){
67496: sqlite3ExpirePreparedStatements(db);
67497: sqlite3ResetInternalSchema(db, -1);
67498: db->flags = (db->flags | SQLITE_InternChanges);
67499: }
67500: }
67501:
67502: /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
67503: ** savepoints nested inside of the savepoint being operated on. */
67504: while( db->pSavepoint!=u.ar.pSavepoint ){
67505: u.ar.pTmp = db->pSavepoint;
67506: db->pSavepoint = u.ar.pTmp->pNext;
67507: sqlite3DbFree(db, u.ar.pTmp);
67508: db->nSavepoint--;
67509: }
67510:
67511: /* If it is a RELEASE, then destroy the savepoint being operated on
67512: ** too. If it is a ROLLBACK TO, then set the number of deferred
67513: ** constraint violations present in the database to the value stored
67514: ** when the savepoint was created. */
67515: if( u.ar.p1==SAVEPOINT_RELEASE ){
67516: assert( u.ar.pSavepoint==db->pSavepoint );
67517: db->pSavepoint = u.ar.pSavepoint->pNext;
67518: sqlite3DbFree(db, u.ar.pSavepoint);
67519: if( !isTransaction ){
67520: db->nSavepoint--;
67521: }
67522: }else{
67523: db->nDeferredCons = u.ar.pSavepoint->nDeferredCons;
67524: }
67525:
67526: if( !isTransaction ){
67527: rc = sqlite3VtabSavepoint(db, u.ar.p1, u.ar.iSavepoint);
67528: if( rc!=SQLITE_OK ) goto abort_due_to_error;
67529: }
67530: }
67531: }
67532:
67533: break;
67534: }
67535:
67536: /* Opcode: AutoCommit P1 P2 * * *
67537: **
67538: ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
67539: ** back any currently active btree transactions. If there are any active
67540: ** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if
67541: ** there are active writing VMs or active VMs that use shared cache.
67542: **
67543: ** This instruction causes the VM to halt.
67544: */
67545: case OP_AutoCommit: {
67546: #if 0 /* local variables moved into u.as */
67547: int desiredAutoCommit;
67548: int iRollback;
67549: int turnOnAC;
67550: #endif /* local variables moved into u.as */
67551:
67552: u.as.desiredAutoCommit = pOp->p1;
67553: u.as.iRollback = pOp->p2;
67554: u.as.turnOnAC = u.as.desiredAutoCommit && !db->autoCommit;
67555: assert( u.as.desiredAutoCommit==1 || u.as.desiredAutoCommit==0 );
67556: assert( u.as.desiredAutoCommit==1 || u.as.iRollback==0 );
67557: assert( db->activeVdbeCnt>0 ); /* At least this one VM is active */
67558:
67559: if( u.as.turnOnAC && u.as.iRollback && db->activeVdbeCnt>1 ){
67560: /* If this instruction implements a ROLLBACK and other VMs are
67561: ** still running, and a transaction is active, return an error indicating
67562: ** that the other VMs must complete first.
67563: */
67564: sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
67565: "SQL statements in progress");
67566: rc = SQLITE_BUSY;
67567: }else if( u.as.turnOnAC && !u.as.iRollback && db->writeVdbeCnt>0 ){
67568: /* If this instruction implements a COMMIT and other VMs are writing
67569: ** return an error indicating that the other VMs must complete first.
67570: */
67571: sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
67572: "SQL statements in progress");
67573: rc = SQLITE_BUSY;
67574: }else if( u.as.desiredAutoCommit!=db->autoCommit ){
67575: if( u.as.iRollback ){
67576: assert( u.as.desiredAutoCommit==1 );
67577: sqlite3RollbackAll(db);
67578: db->autoCommit = 1;
67579: }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
67580: goto vdbe_return;
67581: }else{
67582: db->autoCommit = (u8)u.as.desiredAutoCommit;
67583: if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
67584: p->pc = pc;
67585: db->autoCommit = (u8)(1-u.as.desiredAutoCommit);
67586: p->rc = rc = SQLITE_BUSY;
67587: goto vdbe_return;
67588: }
67589: }
67590: assert( db->nStatement==0 );
67591: sqlite3CloseSavepoints(db);
67592: if( p->rc==SQLITE_OK ){
67593: rc = SQLITE_DONE;
67594: }else{
67595: rc = SQLITE_ERROR;
67596: }
67597: goto vdbe_return;
67598: }else{
67599: sqlite3SetString(&p->zErrMsg, db,
67600: (!u.as.desiredAutoCommit)?"cannot start a transaction within a transaction":(
67601: (u.as.iRollback)?"cannot rollback - no transaction is active":
67602: "cannot commit - no transaction is active"));
67603:
67604: rc = SQLITE_ERROR;
67605: }
67606: break;
67607: }
67608:
67609: /* Opcode: Transaction P1 P2 * * *
67610: **
67611: ** Begin a transaction. The transaction ends when a Commit or Rollback
67612: ** opcode is encountered. Depending on the ON CONFLICT setting, the
67613: ** transaction might also be rolled back if an error is encountered.
67614: **
67615: ** P1 is the index of the database file on which the transaction is
67616: ** started. Index 0 is the main database file and index 1 is the
67617: ** file used for temporary tables. Indices of 2 or more are used for
67618: ** attached databases.
67619: **
67620: ** If P2 is non-zero, then a write-transaction is started. A RESERVED lock is
67621: ** obtained on the database file when a write-transaction is started. No
67622: ** other process can start another write transaction while this transaction is
67623: ** underway. Starting a write transaction also creates a rollback journal. A
67624: ** write transaction must be started before any changes can be made to the
67625: ** database. If P2 is 2 or greater then an EXCLUSIVE lock is also obtained
67626: ** on the file.
67627: **
67628: ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
67629: ** true (this flag is set if the Vdbe may modify more than one row and may
67630: ** throw an ABORT exception), a statement transaction may also be opened.
67631: ** More specifically, a statement transaction is opened iff the database
67632: ** connection is currently not in autocommit mode, or if there are other
67633: ** active statements. A statement transaction allows the affects of this
67634: ** VDBE to be rolled back after an error without having to roll back the
67635: ** entire transaction. If no error is encountered, the statement transaction
67636: ** will automatically commit when the VDBE halts.
67637: **
67638: ** If P2 is zero, then a read-lock is obtained on the database file.
67639: */
67640: case OP_Transaction: {
67641: #if 0 /* local variables moved into u.at */
67642: Btree *pBt;
67643: #endif /* local variables moved into u.at */
67644:
67645: assert( pOp->p1>=0 && pOp->p1<db->nDb );
67646: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
67647: u.at.pBt = db->aDb[pOp->p1].pBt;
67648:
67649: if( u.at.pBt ){
67650: rc = sqlite3BtreeBeginTrans(u.at.pBt, pOp->p2);
67651: if( rc==SQLITE_BUSY ){
67652: p->pc = pc;
67653: p->rc = rc = SQLITE_BUSY;
67654: goto vdbe_return;
67655: }
67656: if( rc!=SQLITE_OK ){
67657: goto abort_due_to_error;
67658: }
67659:
67660: if( pOp->p2 && p->usesStmtJournal
67661: && (db->autoCommit==0 || db->activeVdbeCnt>1)
67662: ){
67663: assert( sqlite3BtreeIsInTrans(u.at.pBt) );
67664: if( p->iStatement==0 ){
67665: assert( db->nStatement>=0 && db->nSavepoint>=0 );
67666: db->nStatement++;
67667: p->iStatement = db->nSavepoint + db->nStatement;
67668: }
67669:
67670: rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
67671: if( rc==SQLITE_OK ){
67672: rc = sqlite3BtreeBeginStmt(u.at.pBt, p->iStatement);
67673: }
67674:
67675: /* Store the current value of the database handles deferred constraint
67676: ** counter. If the statement transaction needs to be rolled back,
67677: ** the value of this counter needs to be restored too. */
67678: p->nStmtDefCons = db->nDeferredCons;
67679: }
67680: }
67681: break;
67682: }
67683:
67684: /* Opcode: ReadCookie P1 P2 P3 * *
67685: **
67686: ** Read cookie number P3 from database P1 and write it into register P2.
67687: ** P3==1 is the schema version. P3==2 is the database format.
67688: ** P3==3 is the recommended pager cache size, and so forth. P1==0 is
67689: ** the main database file and P1==1 is the database file used to store
67690: ** temporary tables.
67691: **
67692: ** There must be a read-lock on the database (either a transaction
67693: ** must be started or there must be an open cursor) before
67694: ** executing this instruction.
67695: */
67696: case OP_ReadCookie: { /* out2-prerelease */
67697: #if 0 /* local variables moved into u.au */
67698: int iMeta;
67699: int iDb;
67700: int iCookie;
67701: #endif /* local variables moved into u.au */
67702:
67703: u.au.iDb = pOp->p1;
67704: u.au.iCookie = pOp->p3;
67705: assert( pOp->p3<SQLITE_N_BTREE_META );
67706: assert( u.au.iDb>=0 && u.au.iDb<db->nDb );
67707: assert( db->aDb[u.au.iDb].pBt!=0 );
67708: assert( (p->btreeMask & (((yDbMask)1)<<u.au.iDb))!=0 );
67709:
67710: sqlite3BtreeGetMeta(db->aDb[u.au.iDb].pBt, u.au.iCookie, (u32 *)&u.au.iMeta);
67711: pOut->u.i = u.au.iMeta;
67712: break;
67713: }
67714:
67715: /* Opcode: SetCookie P1 P2 P3 * *
67716: **
67717: ** Write the content of register P3 (interpreted as an integer)
67718: ** into cookie number P2 of database P1. P2==1 is the schema version.
67719: ** P2==2 is the database format. P2==3 is the recommended pager cache
67720: ** size, and so forth. P1==0 is the main database file and P1==1 is the
67721: ** database file used to store temporary tables.
67722: **
67723: ** A transaction must be started before executing this opcode.
67724: */
67725: case OP_SetCookie: { /* in3 */
67726: #if 0 /* local variables moved into u.av */
67727: Db *pDb;
67728: #endif /* local variables moved into u.av */
67729: assert( pOp->p2<SQLITE_N_BTREE_META );
67730: assert( pOp->p1>=0 && pOp->p1<db->nDb );
67731: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
67732: u.av.pDb = &db->aDb[pOp->p1];
67733: assert( u.av.pDb->pBt!=0 );
67734: assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
67735: pIn3 = &aMem[pOp->p3];
67736: sqlite3VdbeMemIntegerify(pIn3);
67737: /* See note about index shifting on OP_ReadCookie */
67738: rc = sqlite3BtreeUpdateMeta(u.av.pDb->pBt, pOp->p2, (int)pIn3->u.i);
67739: if( pOp->p2==BTREE_SCHEMA_VERSION ){
67740: /* When the schema cookie changes, record the new cookie internally */
67741: u.av.pDb->pSchema->schema_cookie = (int)pIn3->u.i;
67742: db->flags |= SQLITE_InternChanges;
67743: }else if( pOp->p2==BTREE_FILE_FORMAT ){
67744: /* Record changes in the file format */
67745: u.av.pDb->pSchema->file_format = (u8)pIn3->u.i;
67746: }
67747: if( pOp->p1==1 ){
67748: /* Invalidate all prepared statements whenever the TEMP database
67749: ** schema is changed. Ticket #1644 */
67750: sqlite3ExpirePreparedStatements(db);
67751: p->expired = 0;
67752: }
67753: break;
67754: }
67755:
67756: /* Opcode: VerifyCookie P1 P2 P3 * *
67757: **
67758: ** Check the value of global database parameter number 0 (the
67759: ** schema version) and make sure it is equal to P2 and that the
67760: ** generation counter on the local schema parse equals P3.
67761: **
67762: ** P1 is the database number which is 0 for the main database file
67763: ** and 1 for the file holding temporary tables and some higher number
67764: ** for auxiliary databases.
67765: **
67766: ** The cookie changes its value whenever the database schema changes.
67767: ** This operation is used to detect when that the cookie has changed
67768: ** and that the current process needs to reread the schema.
67769: **
67770: ** Either a transaction needs to have been started or an OP_Open needs
67771: ** to be executed (to establish a read lock) before this opcode is
67772: ** invoked.
67773: */
67774: case OP_VerifyCookie: {
67775: #if 0 /* local variables moved into u.aw */
67776: int iMeta;
67777: int iGen;
67778: Btree *pBt;
67779: #endif /* local variables moved into u.aw */
67780:
67781: assert( pOp->p1>=0 && pOp->p1<db->nDb );
67782: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
67783: assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
67784: u.aw.pBt = db->aDb[pOp->p1].pBt;
67785: if( u.aw.pBt ){
67786: sqlite3BtreeGetMeta(u.aw.pBt, BTREE_SCHEMA_VERSION, (u32 *)&u.aw.iMeta);
67787: u.aw.iGen = db->aDb[pOp->p1].pSchema->iGeneration;
67788: }else{
67789: u.aw.iGen = u.aw.iMeta = 0;
67790: }
67791: if( u.aw.iMeta!=pOp->p2 || u.aw.iGen!=pOp->p3 ){
67792: sqlite3DbFree(db, p->zErrMsg);
67793: p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
67794: /* If the schema-cookie from the database file matches the cookie
67795: ** stored with the in-memory representation of the schema, do
67796: ** not reload the schema from the database file.
67797: **
67798: ** If virtual-tables are in use, this is not just an optimization.
67799: ** Often, v-tables store their data in other SQLite tables, which
67800: ** are queried from within xNext() and other v-table methods using
67801: ** prepared queries. If such a query is out-of-date, we do not want to
67802: ** discard the database schema, as the user code implementing the
67803: ** v-table would have to be ready for the sqlite3_vtab structure itself
67804: ** to be invalidated whenever sqlite3_step() is called from within
67805: ** a v-table method.
67806: */
67807: if( db->aDb[pOp->p1].pSchema->schema_cookie!=u.aw.iMeta ){
67808: sqlite3ResetInternalSchema(db, pOp->p1);
67809: }
67810:
67811: p->expired = 1;
67812: rc = SQLITE_SCHEMA;
67813: }
67814: break;
67815: }
67816:
67817: /* Opcode: OpenRead P1 P2 P3 P4 P5
67818: **
67819: ** Open a read-only cursor for the database table whose root page is
67820: ** P2 in a database file. The database file is determined by P3.
67821: ** P3==0 means the main database, P3==1 means the database used for
67822: ** temporary tables, and P3>1 means used the corresponding attached
67823: ** database. Give the new cursor an identifier of P1. The P1
67824: ** values need not be contiguous but all P1 values should be small integers.
67825: ** It is an error for P1 to be negative.
67826: **
67827: ** If P5!=0 then use the content of register P2 as the root page, not
67828: ** the value of P2 itself.
67829: **
67830: ** There will be a read lock on the database whenever there is an
67831: ** open cursor. If the database was unlocked prior to this instruction
67832: ** then a read lock is acquired as part of this instruction. A read
67833: ** lock allows other processes to read the database but prohibits
67834: ** any other process from modifying the database. The read lock is
67835: ** released when all cursors are closed. If this instruction attempts
67836: ** to get a read lock but fails, the script terminates with an
67837: ** SQLITE_BUSY error code.
67838: **
67839: ** The P4 value may be either an integer (P4_INT32) or a pointer to
67840: ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
67841: ** structure, then said structure defines the content and collating
67842: ** sequence of the index being opened. Otherwise, if P4 is an integer
67843: ** value, it is set to the number of columns in the table.
67844: **
67845: ** See also OpenWrite.
67846: */
67847: /* Opcode: OpenWrite P1 P2 P3 P4 P5
67848: **
67849: ** Open a read/write cursor named P1 on the table or index whose root
67850: ** page is P2. Or if P5!=0 use the content of register P2 to find the
67851: ** root page.
67852: **
67853: ** The P4 value may be either an integer (P4_INT32) or a pointer to
67854: ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
67855: ** structure, then said structure defines the content and collating
67856: ** sequence of the index being opened. Otherwise, if P4 is an integer
67857: ** value, it is set to the number of columns in the table, or to the
67858: ** largest index of any column of the table that is actually used.
67859: **
67860: ** This instruction works just like OpenRead except that it opens the cursor
67861: ** in read/write mode. For a given table, there can be one or more read-only
67862: ** cursors or a single read/write cursor but not both.
67863: **
67864: ** See also OpenRead.
67865: */
67866: case OP_OpenRead:
67867: case OP_OpenWrite: {
67868: #if 0 /* local variables moved into u.ax */
67869: int nField;
67870: KeyInfo *pKeyInfo;
67871: int p2;
67872: int iDb;
67873: int wrFlag;
67874: Btree *pX;
67875: VdbeCursor *pCur;
67876: Db *pDb;
67877: #endif /* local variables moved into u.ax */
67878:
67879: if( p->expired ){
67880: rc = SQLITE_ABORT;
67881: break;
67882: }
67883:
67884: u.ax.nField = 0;
67885: u.ax.pKeyInfo = 0;
67886: u.ax.p2 = pOp->p2;
67887: u.ax.iDb = pOp->p3;
67888: assert( u.ax.iDb>=0 && u.ax.iDb<db->nDb );
67889: assert( (p->btreeMask & (((yDbMask)1)<<u.ax.iDb))!=0 );
67890: u.ax.pDb = &db->aDb[u.ax.iDb];
67891: u.ax.pX = u.ax.pDb->pBt;
67892: assert( u.ax.pX!=0 );
67893: if( pOp->opcode==OP_OpenWrite ){
67894: u.ax.wrFlag = 1;
67895: assert( sqlite3SchemaMutexHeld(db, u.ax.iDb, 0) );
67896: if( u.ax.pDb->pSchema->file_format < p->minWriteFileFormat ){
67897: p->minWriteFileFormat = u.ax.pDb->pSchema->file_format;
67898: }
67899: }else{
67900: u.ax.wrFlag = 0;
67901: }
67902: if( pOp->p5 ){
67903: assert( u.ax.p2>0 );
67904: assert( u.ax.p2<=p->nMem );
67905: pIn2 = &aMem[u.ax.p2];
67906: assert( memIsValid(pIn2) );
67907: assert( (pIn2->flags & MEM_Int)!=0 );
67908: sqlite3VdbeMemIntegerify(pIn2);
67909: u.ax.p2 = (int)pIn2->u.i;
67910: /* The u.ax.p2 value always comes from a prior OP_CreateTable opcode and
67911: ** that opcode will always set the u.ax.p2 value to 2 or more or else fail.
67912: ** If there were a failure, the prepared statement would have halted
67913: ** before reaching this instruction. */
67914: if( NEVER(u.ax.p2<2) ) {
67915: rc = SQLITE_CORRUPT_BKPT;
67916: goto abort_due_to_error;
67917: }
67918: }
67919: if( pOp->p4type==P4_KEYINFO ){
67920: u.ax.pKeyInfo = pOp->p4.pKeyInfo;
67921: u.ax.pKeyInfo->enc = ENC(p->db);
67922: u.ax.nField = u.ax.pKeyInfo->nField+1;
67923: }else if( pOp->p4type==P4_INT32 ){
67924: u.ax.nField = pOp->p4.i;
67925: }
67926: assert( pOp->p1>=0 );
67927: u.ax.pCur = allocateCursor(p, pOp->p1, u.ax.nField, u.ax.iDb, 1);
67928: if( u.ax.pCur==0 ) goto no_mem;
67929: u.ax.pCur->nullRow = 1;
67930: u.ax.pCur->isOrdered = 1;
67931: rc = sqlite3BtreeCursor(u.ax.pX, u.ax.p2, u.ax.wrFlag, u.ax.pKeyInfo, u.ax.pCur->pCursor);
67932: u.ax.pCur->pKeyInfo = u.ax.pKeyInfo;
67933:
67934: /* Since it performs no memory allocation or IO, the only value that
67935: ** sqlite3BtreeCursor() may return is SQLITE_OK. */
67936: assert( rc==SQLITE_OK );
67937:
67938: /* Set the VdbeCursor.isTable and isIndex variables. Previous versions of
67939: ** SQLite used to check if the root-page flags were sane at this point
67940: ** and report database corruption if they were not, but this check has
67941: ** since moved into the btree layer. */
67942: u.ax.pCur->isTable = pOp->p4type!=P4_KEYINFO;
67943: u.ax.pCur->isIndex = !u.ax.pCur->isTable;
67944: break;
67945: }
67946:
67947: /* Opcode: OpenEphemeral P1 P2 * P4 P5
67948: **
67949: ** Open a new cursor P1 to a transient table.
67950: ** The cursor is always opened read/write even if
67951: ** the main database is read-only. The ephemeral
67952: ** table is deleted automatically when the cursor is closed.
67953: **
67954: ** P2 is the number of columns in the ephemeral table.
67955: ** The cursor points to a BTree table if P4==0 and to a BTree index
67956: ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
67957: ** that defines the format of keys in the index.
67958: **
67959: ** This opcode was once called OpenTemp. But that created
67960: ** confusion because the term "temp table", might refer either
67961: ** to a TEMP table at the SQL level, or to a table opened by
67962: ** this opcode. Then this opcode was call OpenVirtual. But
67963: ** that created confusion with the whole virtual-table idea.
67964: **
67965: ** The P5 parameter can be a mask of the BTREE_* flags defined
67966: ** in btree.h. These flags control aspects of the operation of
67967: ** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
67968: ** added automatically.
67969: */
67970: /* Opcode: OpenAutoindex P1 P2 * P4 *
67971: **
67972: ** This opcode works the same as OP_OpenEphemeral. It has a
67973: ** different name to distinguish its use. Tables created using
67974: ** by this opcode will be used for automatically created transient
67975: ** indices in joins.
67976: */
67977: case OP_OpenAutoindex:
67978: case OP_OpenEphemeral: {
67979: #if 0 /* local variables moved into u.ay */
67980: VdbeCursor *pCx;
67981: #endif /* local variables moved into u.ay */
67982: static const int vfsFlags =
67983: SQLITE_OPEN_READWRITE |
67984: SQLITE_OPEN_CREATE |
67985: SQLITE_OPEN_EXCLUSIVE |
67986: SQLITE_OPEN_DELETEONCLOSE |
67987: SQLITE_OPEN_TRANSIENT_DB;
67988:
67989: assert( pOp->p1>=0 );
67990: u.ay.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
67991: if( u.ay.pCx==0 ) goto no_mem;
67992: u.ay.pCx->nullRow = 1;
67993: rc = sqlite3BtreeOpen(db->pVfs, 0, db, &u.ay.pCx->pBt,
67994: BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, vfsFlags);
67995: if( rc==SQLITE_OK ){
67996: rc = sqlite3BtreeBeginTrans(u.ay.pCx->pBt, 1);
67997: }
67998: if( rc==SQLITE_OK ){
67999: /* If a transient index is required, create it by calling
68000: ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
68001: ** opening it. If a transient table is required, just use the
68002: ** automatically created table with root-page 1 (an BLOB_INTKEY table).
68003: */
68004: if( pOp->p4.pKeyInfo ){
68005: int pgno;
68006: assert( pOp->p4type==P4_KEYINFO );
68007: rc = sqlite3BtreeCreateTable(u.ay.pCx->pBt, &pgno, BTREE_BLOBKEY | pOp->p5);
68008: if( rc==SQLITE_OK ){
68009: assert( pgno==MASTER_ROOT+1 );
68010: rc = sqlite3BtreeCursor(u.ay.pCx->pBt, pgno, 1,
68011: (KeyInfo*)pOp->p4.z, u.ay.pCx->pCursor);
68012: u.ay.pCx->pKeyInfo = pOp->p4.pKeyInfo;
68013: u.ay.pCx->pKeyInfo->enc = ENC(p->db);
68014: }
68015: u.ay.pCx->isTable = 0;
68016: }else{
68017: rc = sqlite3BtreeCursor(u.ay.pCx->pBt, MASTER_ROOT, 1, 0, u.ay.pCx->pCursor);
68018: u.ay.pCx->isTable = 1;
68019: }
68020: }
68021: u.ay.pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
68022: u.ay.pCx->isIndex = !u.ay.pCx->isTable;
68023: break;
68024: }
68025:
68026: /* Opcode: OpenSorter P1 P2 * P4 *
68027: **
68028: ** This opcode works like OP_OpenEphemeral except that it opens
68029: ** a transient index that is specifically designed to sort large
68030: ** tables using an external merge-sort algorithm.
68031: */
68032: case OP_SorterOpen: {
68033: #if 0 /* local variables moved into u.az */
68034: VdbeCursor *pCx;
68035: #endif /* local variables moved into u.az */
68036: #ifndef SQLITE_OMIT_MERGE_SORT
68037: u.az.pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
68038: if( u.az.pCx==0 ) goto no_mem;
68039: u.az.pCx->pKeyInfo = pOp->p4.pKeyInfo;
68040: u.az.pCx->pKeyInfo->enc = ENC(p->db);
68041: u.az.pCx->isSorter = 1;
68042: rc = sqlite3VdbeSorterInit(db, u.az.pCx);
68043: #else
68044: pOp->opcode = OP_OpenEphemeral;
68045: pc--;
68046: #endif
68047: break;
68048: }
68049:
68050: /* Opcode: OpenPseudo P1 P2 P3 * *
68051: **
68052: ** Open a new cursor that points to a fake table that contains a single
68053: ** row of data. The content of that one row in the content of memory
68054: ** register P2. In other words, cursor P1 becomes an alias for the
68055: ** MEM_Blob content contained in register P2.
68056: **
68057: ** A pseudo-table created by this opcode is used to hold a single
68058: ** row output from the sorter so that the row can be decomposed into
68059: ** individual columns using the OP_Column opcode. The OP_Column opcode
68060: ** is the only cursor opcode that works with a pseudo-table.
68061: **
68062: ** P3 is the number of fields in the records that will be stored by
68063: ** the pseudo-table.
68064: */
68065: case OP_OpenPseudo: {
68066: #if 0 /* local variables moved into u.ba */
68067: VdbeCursor *pCx;
68068: #endif /* local variables moved into u.ba */
68069:
68070: assert( pOp->p1>=0 );
68071: u.ba.pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, 0);
68072: if( u.ba.pCx==0 ) goto no_mem;
68073: u.ba.pCx->nullRow = 1;
68074: u.ba.pCx->pseudoTableReg = pOp->p2;
68075: u.ba.pCx->isTable = 1;
68076: u.ba.pCx->isIndex = 0;
68077: break;
68078: }
68079:
68080: /* Opcode: Close P1 * * * *
68081: **
68082: ** Close a cursor previously opened as P1. If P1 is not
68083: ** currently open, this instruction is a no-op.
68084: */
68085: case OP_Close: {
68086: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68087: sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
68088: p->apCsr[pOp->p1] = 0;
68089: break;
68090: }
68091:
68092: /* Opcode: SeekGe P1 P2 P3 P4 *
68093: **
68094: ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
68095: ** use the value in register P3 as the key. If cursor P1 refers
68096: ** to an SQL index, then P3 is the first in an array of P4 registers
68097: ** that are used as an unpacked index key.
68098: **
68099: ** Reposition cursor P1 so that it points to the smallest entry that
68100: ** is greater than or equal to the key value. If there are no records
68101: ** greater than or equal to the key and P2 is not zero, then jump to P2.
68102: **
68103: ** See also: Found, NotFound, Distinct, SeekLt, SeekGt, SeekLe
68104: */
68105: /* Opcode: SeekGt P1 P2 P3 P4 *
68106: **
68107: ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
68108: ** use the value in register P3 as a key. If cursor P1 refers
68109: ** to an SQL index, then P3 is the first in an array of P4 registers
68110: ** that are used as an unpacked index key.
68111: **
68112: ** Reposition cursor P1 so that it points to the smallest entry that
68113: ** is greater than the key value. If there are no records greater than
68114: ** the key and P2 is not zero, then jump to P2.
68115: **
68116: ** See also: Found, NotFound, Distinct, SeekLt, SeekGe, SeekLe
68117: */
68118: /* Opcode: SeekLt P1 P2 P3 P4 *
68119: **
68120: ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
68121: ** use the value in register P3 as a key. If cursor P1 refers
68122: ** to an SQL index, then P3 is the first in an array of P4 registers
68123: ** that are used as an unpacked index key.
68124: **
68125: ** Reposition cursor P1 so that it points to the largest entry that
68126: ** is less than the key value. If there are no records less than
68127: ** the key and P2 is not zero, then jump to P2.
68128: **
68129: ** See also: Found, NotFound, Distinct, SeekGt, SeekGe, SeekLe
68130: */
68131: /* Opcode: SeekLe P1 P2 P3 P4 *
68132: **
68133: ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
68134: ** use the value in register P3 as a key. If cursor P1 refers
68135: ** to an SQL index, then P3 is the first in an array of P4 registers
68136: ** that are used as an unpacked index key.
68137: **
68138: ** Reposition cursor P1 so that it points to the largest entry that
68139: ** is less than or equal to the key value. If there are no records
68140: ** less than or equal to the key and P2 is not zero, then jump to P2.
68141: **
68142: ** See also: Found, NotFound, Distinct, SeekGt, SeekGe, SeekLt
68143: */
68144: case OP_SeekLt: /* jump, in3 */
68145: case OP_SeekLe: /* jump, in3 */
68146: case OP_SeekGe: /* jump, in3 */
68147: case OP_SeekGt: { /* jump, in3 */
68148: #if 0 /* local variables moved into u.bb */
68149: int res;
68150: int oc;
68151: VdbeCursor *pC;
68152: UnpackedRecord r;
68153: int nField;
68154: i64 iKey; /* The rowid we are to seek to */
68155: #endif /* local variables moved into u.bb */
68156:
68157: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68158: assert( pOp->p2!=0 );
68159: u.bb.pC = p->apCsr[pOp->p1];
68160: assert( u.bb.pC!=0 );
68161: assert( u.bb.pC->pseudoTableReg==0 );
68162: assert( OP_SeekLe == OP_SeekLt+1 );
68163: assert( OP_SeekGe == OP_SeekLt+2 );
68164: assert( OP_SeekGt == OP_SeekLt+3 );
68165: assert( u.bb.pC->isOrdered );
68166: if( ALWAYS(u.bb.pC->pCursor!=0) ){
68167: u.bb.oc = pOp->opcode;
68168: u.bb.pC->nullRow = 0;
68169: if( u.bb.pC->isTable ){
68170: /* The input value in P3 might be of any type: integer, real, string,
68171: ** blob, or NULL. But it needs to be an integer before we can do
68172: ** the seek, so covert it. */
68173: pIn3 = &aMem[pOp->p3];
68174: applyNumericAffinity(pIn3);
68175: u.bb.iKey = sqlite3VdbeIntValue(pIn3);
68176: u.bb.pC->rowidIsValid = 0;
68177:
68178: /* If the P3 value could not be converted into an integer without
68179: ** loss of information, then special processing is required... */
68180: if( (pIn3->flags & MEM_Int)==0 ){
68181: if( (pIn3->flags & MEM_Real)==0 ){
68182: /* If the P3 value cannot be converted into any kind of a number,
68183: ** then the seek is not possible, so jump to P2 */
68184: pc = pOp->p2 - 1;
68185: break;
68186: }
68187: /* If we reach this point, then the P3 value must be a floating
68188: ** point number. */
68189: assert( (pIn3->flags & MEM_Real)!=0 );
68190:
68191: if( u.bb.iKey==SMALLEST_INT64 && (pIn3->r<(double)u.bb.iKey || pIn3->r>0) ){
68192: /* The P3 value is too large in magnitude to be expressed as an
68193: ** integer. */
68194: u.bb.res = 1;
68195: if( pIn3->r<0 ){
68196: if( u.bb.oc>=OP_SeekGe ){ assert( u.bb.oc==OP_SeekGe || u.bb.oc==OP_SeekGt );
68197: rc = sqlite3BtreeFirst(u.bb.pC->pCursor, &u.bb.res);
68198: if( rc!=SQLITE_OK ) goto abort_due_to_error;
68199: }
68200: }else{
68201: if( u.bb.oc<=OP_SeekLe ){ assert( u.bb.oc==OP_SeekLt || u.bb.oc==OP_SeekLe );
68202: rc = sqlite3BtreeLast(u.bb.pC->pCursor, &u.bb.res);
68203: if( rc!=SQLITE_OK ) goto abort_due_to_error;
68204: }
68205: }
68206: if( u.bb.res ){
68207: pc = pOp->p2 - 1;
68208: }
68209: break;
68210: }else if( u.bb.oc==OP_SeekLt || u.bb.oc==OP_SeekGe ){
68211: /* Use the ceiling() function to convert real->int */
68212: if( pIn3->r > (double)u.bb.iKey ) u.bb.iKey++;
68213: }else{
68214: /* Use the floor() function to convert real->int */
68215: assert( u.bb.oc==OP_SeekLe || u.bb.oc==OP_SeekGt );
68216: if( pIn3->r < (double)u.bb.iKey ) u.bb.iKey--;
68217: }
68218: }
68219: rc = sqlite3BtreeMovetoUnpacked(u.bb.pC->pCursor, 0, (u64)u.bb.iKey, 0, &u.bb.res);
68220: if( rc!=SQLITE_OK ){
68221: goto abort_due_to_error;
68222: }
68223: if( u.bb.res==0 ){
68224: u.bb.pC->rowidIsValid = 1;
68225: u.bb.pC->lastRowid = u.bb.iKey;
68226: }
68227: }else{
68228: u.bb.nField = pOp->p4.i;
68229: assert( pOp->p4type==P4_INT32 );
68230: assert( u.bb.nField>0 );
68231: u.bb.r.pKeyInfo = u.bb.pC->pKeyInfo;
68232: u.bb.r.nField = (u16)u.bb.nField;
68233:
68234: /* The next line of code computes as follows, only faster:
68235: ** if( u.bb.oc==OP_SeekGt || u.bb.oc==OP_SeekLe ){
68236: ** u.bb.r.flags = UNPACKED_INCRKEY;
68237: ** }else{
68238: ** u.bb.r.flags = 0;
68239: ** }
68240: */
68241: u.bb.r.flags = (u16)(UNPACKED_INCRKEY * (1 & (u.bb.oc - OP_SeekLt)));
68242: assert( u.bb.oc!=OP_SeekGt || u.bb.r.flags==UNPACKED_INCRKEY );
68243: assert( u.bb.oc!=OP_SeekLe || u.bb.r.flags==UNPACKED_INCRKEY );
68244: assert( u.bb.oc!=OP_SeekGe || u.bb.r.flags==0 );
68245: assert( u.bb.oc!=OP_SeekLt || u.bb.r.flags==0 );
68246:
68247: u.bb.r.aMem = &aMem[pOp->p3];
68248: #ifdef SQLITE_DEBUG
68249: { int i; for(i=0; i<u.bb.r.nField; i++) assert( memIsValid(&u.bb.r.aMem[i]) ); }
68250: #endif
68251: ExpandBlob(u.bb.r.aMem);
68252: rc = sqlite3BtreeMovetoUnpacked(u.bb.pC->pCursor, &u.bb.r, 0, 0, &u.bb.res);
68253: if( rc!=SQLITE_OK ){
68254: goto abort_due_to_error;
68255: }
68256: u.bb.pC->rowidIsValid = 0;
68257: }
68258: u.bb.pC->deferredMoveto = 0;
68259: u.bb.pC->cacheStatus = CACHE_STALE;
68260: #ifdef SQLITE_TEST
68261: sqlite3_search_count++;
68262: #endif
68263: if( u.bb.oc>=OP_SeekGe ){ assert( u.bb.oc==OP_SeekGe || u.bb.oc==OP_SeekGt );
68264: if( u.bb.res<0 || (u.bb.res==0 && u.bb.oc==OP_SeekGt) ){
68265: rc = sqlite3BtreeNext(u.bb.pC->pCursor, &u.bb.res);
68266: if( rc!=SQLITE_OK ) goto abort_due_to_error;
68267: u.bb.pC->rowidIsValid = 0;
68268: }else{
68269: u.bb.res = 0;
68270: }
68271: }else{
68272: assert( u.bb.oc==OP_SeekLt || u.bb.oc==OP_SeekLe );
68273: if( u.bb.res>0 || (u.bb.res==0 && u.bb.oc==OP_SeekLt) ){
68274: rc = sqlite3BtreePrevious(u.bb.pC->pCursor, &u.bb.res);
68275: if( rc!=SQLITE_OK ) goto abort_due_to_error;
68276: u.bb.pC->rowidIsValid = 0;
68277: }else{
68278: /* u.bb.res might be negative because the table is empty. Check to
68279: ** see if this is the case.
68280: */
68281: u.bb.res = sqlite3BtreeEof(u.bb.pC->pCursor);
68282: }
68283: }
68284: assert( pOp->p2>0 );
68285: if( u.bb.res ){
68286: pc = pOp->p2 - 1;
68287: }
68288: }else{
68289: /* This happens when attempting to open the sqlite3_master table
68290: ** for read access returns SQLITE_EMPTY. In this case always
68291: ** take the jump (since there are no records in the table).
68292: */
68293: pc = pOp->p2 - 1;
68294: }
68295: break;
68296: }
68297:
68298: /* Opcode: Seek P1 P2 * * *
68299: **
68300: ** P1 is an open table cursor and P2 is a rowid integer. Arrange
68301: ** for P1 to move so that it points to the rowid given by P2.
68302: **
68303: ** This is actually a deferred seek. Nothing actually happens until
68304: ** the cursor is used to read a record. That way, if no reads
68305: ** occur, no unnecessary I/O happens.
68306: */
68307: case OP_Seek: { /* in2 */
68308: #if 0 /* local variables moved into u.bc */
68309: VdbeCursor *pC;
68310: #endif /* local variables moved into u.bc */
68311:
68312: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68313: u.bc.pC = p->apCsr[pOp->p1];
68314: assert( u.bc.pC!=0 );
68315: if( ALWAYS(u.bc.pC->pCursor!=0) ){
68316: assert( u.bc.pC->isTable );
68317: u.bc.pC->nullRow = 0;
68318: pIn2 = &aMem[pOp->p2];
68319: u.bc.pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
68320: u.bc.pC->rowidIsValid = 0;
68321: u.bc.pC->deferredMoveto = 1;
68322: }
68323: break;
68324: }
68325:
68326:
68327: /* Opcode: Found P1 P2 P3 P4 *
68328: **
68329: ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
68330: ** P4>0 then register P3 is the first of P4 registers that form an unpacked
68331: ** record.
68332: **
68333: ** Cursor P1 is on an index btree. If the record identified by P3 and P4
68334: ** is a prefix of any entry in P1 then a jump is made to P2 and
68335: ** P1 is left pointing at the matching entry.
68336: */
68337: /* Opcode: NotFound P1 P2 P3 P4 *
68338: **
68339: ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
68340: ** P4>0 then register P3 is the first of P4 registers that form an unpacked
68341: ** record.
68342: **
68343: ** Cursor P1 is on an index btree. If the record identified by P3 and P4
68344: ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
68345: ** does contain an entry whose prefix matches the P3/P4 record then control
68346: ** falls through to the next instruction and P1 is left pointing at the
68347: ** matching entry.
68348: **
68349: ** See also: Found, NotExists, IsUnique
68350: */
68351: case OP_NotFound: /* jump, in3 */
68352: case OP_Found: { /* jump, in3 */
68353: #if 0 /* local variables moved into u.bd */
68354: int alreadyExists;
68355: VdbeCursor *pC;
68356: int res;
68357: char *pFree;
68358: UnpackedRecord *pIdxKey;
68359: UnpackedRecord r;
68360: char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
68361: #endif /* local variables moved into u.bd */
68362:
68363: #ifdef SQLITE_TEST
68364: sqlite3_found_count++;
68365: #endif
68366:
68367: u.bd.alreadyExists = 0;
68368: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68369: assert( pOp->p4type==P4_INT32 );
68370: u.bd.pC = p->apCsr[pOp->p1];
68371: assert( u.bd.pC!=0 );
68372: pIn3 = &aMem[pOp->p3];
68373: if( ALWAYS(u.bd.pC->pCursor!=0) ){
68374:
68375: assert( u.bd.pC->isTable==0 );
68376: if( pOp->p4.i>0 ){
68377: u.bd.r.pKeyInfo = u.bd.pC->pKeyInfo;
68378: u.bd.r.nField = (u16)pOp->p4.i;
68379: u.bd.r.aMem = pIn3;
68380: #ifdef SQLITE_DEBUG
68381: { int i; for(i=0; i<u.bd.r.nField; i++) assert( memIsValid(&u.bd.r.aMem[i]) ); }
68382: #endif
68383: u.bd.r.flags = UNPACKED_PREFIX_MATCH;
68384: u.bd.pIdxKey = &u.bd.r;
68385: }else{
68386: u.bd.pIdxKey = sqlite3VdbeAllocUnpackedRecord(
68387: u.bd.pC->pKeyInfo, u.bd.aTempRec, sizeof(u.bd.aTempRec), &u.bd.pFree
68388: );
68389: if( u.bd.pIdxKey==0 ) goto no_mem;
68390: assert( pIn3->flags & MEM_Blob );
68391: assert( (pIn3->flags & MEM_Zero)==0 ); /* zeroblobs already expanded */
68392: sqlite3VdbeRecordUnpack(u.bd.pC->pKeyInfo, pIn3->n, pIn3->z, u.bd.pIdxKey);
68393: u.bd.pIdxKey->flags |= UNPACKED_PREFIX_MATCH;
68394: }
68395: rc = sqlite3BtreeMovetoUnpacked(u.bd.pC->pCursor, u.bd.pIdxKey, 0, 0, &u.bd.res);
68396: if( pOp->p4.i==0 ){
68397: sqlite3DbFree(db, u.bd.pFree);
68398: }
68399: if( rc!=SQLITE_OK ){
68400: break;
68401: }
68402: u.bd.alreadyExists = (u.bd.res==0);
68403: u.bd.pC->deferredMoveto = 0;
68404: u.bd.pC->cacheStatus = CACHE_STALE;
68405: }
68406: if( pOp->opcode==OP_Found ){
68407: if( u.bd.alreadyExists ) pc = pOp->p2 - 1;
68408: }else{
68409: if( !u.bd.alreadyExists ) pc = pOp->p2 - 1;
68410: }
68411: break;
68412: }
68413:
68414: /* Opcode: IsUnique P1 P2 P3 P4 *
68415: **
68416: ** Cursor P1 is open on an index b-tree - that is to say, a btree which
68417: ** no data and where the key are records generated by OP_MakeRecord with
68418: ** the list field being the integer ROWID of the entry that the index
68419: ** entry refers to.
68420: **
68421: ** The P3 register contains an integer record number. Call this record
68422: ** number R. Register P4 is the first in a set of N contiguous registers
68423: ** that make up an unpacked index key that can be used with cursor P1.
68424: ** The value of N can be inferred from the cursor. N includes the rowid
68425: ** value appended to the end of the index record. This rowid value may
68426: ** or may not be the same as R.
68427: **
68428: ** If any of the N registers beginning with register P4 contains a NULL
68429: ** value, jump immediately to P2.
68430: **
68431: ** Otherwise, this instruction checks if cursor P1 contains an entry
68432: ** where the first (N-1) fields match but the rowid value at the end
68433: ** of the index entry is not R. If there is no such entry, control jumps
68434: ** to instruction P2. Otherwise, the rowid of the conflicting index
68435: ** entry is copied to register P3 and control falls through to the next
68436: ** instruction.
68437: **
68438: ** See also: NotFound, NotExists, Found
68439: */
68440: case OP_IsUnique: { /* jump, in3 */
68441: #if 0 /* local variables moved into u.be */
68442: u16 ii;
68443: VdbeCursor *pCx;
68444: BtCursor *pCrsr;
68445: u16 nField;
68446: Mem *aMx;
68447: UnpackedRecord r; /* B-Tree index search key */
68448: i64 R; /* Rowid stored in register P3 */
68449: #endif /* local variables moved into u.be */
68450:
68451: pIn3 = &aMem[pOp->p3];
68452: u.be.aMx = &aMem[pOp->p4.i];
68453: /* Assert that the values of parameters P1 and P4 are in range. */
68454: assert( pOp->p4type==P4_INT32 );
68455: assert( pOp->p4.i>0 && pOp->p4.i<=p->nMem );
68456: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68457:
68458: /* Find the index cursor. */
68459: u.be.pCx = p->apCsr[pOp->p1];
68460: assert( u.be.pCx->deferredMoveto==0 );
68461: u.be.pCx->seekResult = 0;
68462: u.be.pCx->cacheStatus = CACHE_STALE;
68463: u.be.pCrsr = u.be.pCx->pCursor;
68464:
68465: /* If any of the values are NULL, take the jump. */
68466: u.be.nField = u.be.pCx->pKeyInfo->nField;
68467: for(u.be.ii=0; u.be.ii<u.be.nField; u.be.ii++){
68468: if( u.be.aMx[u.be.ii].flags & MEM_Null ){
68469: pc = pOp->p2 - 1;
68470: u.be.pCrsr = 0;
68471: break;
68472: }
68473: }
68474: assert( (u.be.aMx[u.be.nField].flags & MEM_Null)==0 );
68475:
68476: if( u.be.pCrsr!=0 ){
68477: /* Populate the index search key. */
68478: u.be.r.pKeyInfo = u.be.pCx->pKeyInfo;
68479: u.be.r.nField = u.be.nField + 1;
68480: u.be.r.flags = UNPACKED_PREFIX_SEARCH;
68481: u.be.r.aMem = u.be.aMx;
68482: #ifdef SQLITE_DEBUG
68483: { int i; for(i=0; i<u.be.r.nField; i++) assert( memIsValid(&u.be.r.aMem[i]) ); }
68484: #endif
68485:
68486: /* Extract the value of u.be.R from register P3. */
68487: sqlite3VdbeMemIntegerify(pIn3);
68488: u.be.R = pIn3->u.i;
68489:
68490: /* Search the B-Tree index. If no conflicting record is found, jump
68491: ** to P2. Otherwise, copy the rowid of the conflicting record to
68492: ** register P3 and fall through to the next instruction. */
68493: rc = sqlite3BtreeMovetoUnpacked(u.be.pCrsr, &u.be.r, 0, 0, &u.be.pCx->seekResult);
68494: if( (u.be.r.flags & UNPACKED_PREFIX_SEARCH) || u.be.r.rowid==u.be.R ){
68495: pc = pOp->p2 - 1;
68496: }else{
68497: pIn3->u.i = u.be.r.rowid;
68498: }
68499: }
68500: break;
68501: }
68502:
68503: /* Opcode: NotExists P1 P2 P3 * *
68504: **
68505: ** Use the content of register P3 as an integer key. If a record
68506: ** with that key does not exist in table of P1, then jump to P2.
68507: ** If the record does exist, then fall through. The cursor is left
68508: ** pointing to the record if it exists.
68509: **
68510: ** The difference between this operation and NotFound is that this
68511: ** operation assumes the key is an integer and that P1 is a table whereas
68512: ** NotFound assumes key is a blob constructed from MakeRecord and
68513: ** P1 is an index.
68514: **
68515: ** See also: Found, NotFound, IsUnique
68516: */
68517: case OP_NotExists: { /* jump, in3 */
68518: #if 0 /* local variables moved into u.bf */
68519: VdbeCursor *pC;
68520: BtCursor *pCrsr;
68521: int res;
68522: u64 iKey;
68523: #endif /* local variables moved into u.bf */
68524:
68525: pIn3 = &aMem[pOp->p3];
68526: assert( pIn3->flags & MEM_Int );
68527: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68528: u.bf.pC = p->apCsr[pOp->p1];
68529: assert( u.bf.pC!=0 );
68530: assert( u.bf.pC->isTable );
68531: assert( u.bf.pC->pseudoTableReg==0 );
68532: u.bf.pCrsr = u.bf.pC->pCursor;
68533: if( ALWAYS(u.bf.pCrsr!=0) ){
68534: u.bf.res = 0;
68535: u.bf.iKey = pIn3->u.i;
68536: rc = sqlite3BtreeMovetoUnpacked(u.bf.pCrsr, 0, u.bf.iKey, 0, &u.bf.res);
68537: u.bf.pC->lastRowid = pIn3->u.i;
68538: u.bf.pC->rowidIsValid = u.bf.res==0 ?1:0;
68539: u.bf.pC->nullRow = 0;
68540: u.bf.pC->cacheStatus = CACHE_STALE;
68541: u.bf.pC->deferredMoveto = 0;
68542: if( u.bf.res!=0 ){
68543: pc = pOp->p2 - 1;
68544: assert( u.bf.pC->rowidIsValid==0 );
68545: }
68546: u.bf.pC->seekResult = u.bf.res;
68547: }else{
68548: /* This happens when an attempt to open a read cursor on the
68549: ** sqlite_master table returns SQLITE_EMPTY.
68550: */
68551: pc = pOp->p2 - 1;
68552: assert( u.bf.pC->rowidIsValid==0 );
68553: u.bf.pC->seekResult = 0;
68554: }
68555: break;
68556: }
68557:
68558: /* Opcode: Sequence P1 P2 * * *
68559: **
68560: ** Find the next available sequence number for cursor P1.
68561: ** Write the sequence number into register P2.
68562: ** The sequence number on the cursor is incremented after this
68563: ** instruction.
68564: */
68565: case OP_Sequence: { /* out2-prerelease */
68566: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68567: assert( p->apCsr[pOp->p1]!=0 );
68568: pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
68569: break;
68570: }
68571:
68572:
68573: /* Opcode: NewRowid P1 P2 P3 * *
68574: **
68575: ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
68576: ** The record number is not previously used as a key in the database
68577: ** table that cursor P1 points to. The new record number is written
68578: ** written to register P2.
68579: **
68580: ** If P3>0 then P3 is a register in the root frame of this VDBE that holds
68581: ** the largest previously generated record number. No new record numbers are
68582: ** allowed to be less than this value. When this value reaches its maximum,
68583: ** an SQLITE_FULL error is generated. The P3 register is updated with the '
68584: ** generated record number. This P3 mechanism is used to help implement the
68585: ** AUTOINCREMENT feature.
68586: */
68587: case OP_NewRowid: { /* out2-prerelease */
68588: #if 0 /* local variables moved into u.bg */
68589: i64 v; /* The new rowid */
68590: VdbeCursor *pC; /* Cursor of table to get the new rowid */
68591: int res; /* Result of an sqlite3BtreeLast() */
68592: int cnt; /* Counter to limit the number of searches */
68593: Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
68594: VdbeFrame *pFrame; /* Root frame of VDBE */
68595: #endif /* local variables moved into u.bg */
68596:
68597: u.bg.v = 0;
68598: u.bg.res = 0;
68599: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68600: u.bg.pC = p->apCsr[pOp->p1];
68601: assert( u.bg.pC!=0 );
68602: if( NEVER(u.bg.pC->pCursor==0) ){
68603: /* The zero initialization above is all that is needed */
68604: }else{
68605: /* The next rowid or record number (different terms for the same
68606: ** thing) is obtained in a two-step algorithm.
68607: **
68608: ** First we attempt to find the largest existing rowid and add one
68609: ** to that. But if the largest existing rowid is already the maximum
68610: ** positive integer, we have to fall through to the second
68611: ** probabilistic algorithm
68612: **
68613: ** The second algorithm is to select a rowid at random and see if
68614: ** it already exists in the table. If it does not exist, we have
68615: ** succeeded. If the random rowid does exist, we select a new one
68616: ** and try again, up to 100 times.
68617: */
68618: assert( u.bg.pC->isTable );
68619:
68620: #ifdef SQLITE_32BIT_ROWID
68621: # define MAX_ROWID 0x7fffffff
68622: #else
68623: /* Some compilers complain about constants of the form 0x7fffffffffffffff.
68624: ** Others complain about 0x7ffffffffffffffffLL. The following macro seems
68625: ** to provide the constant while making all compilers happy.
68626: */
68627: # define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
68628: #endif
68629:
68630: if( !u.bg.pC->useRandomRowid ){
68631: u.bg.v = sqlite3BtreeGetCachedRowid(u.bg.pC->pCursor);
68632: if( u.bg.v==0 ){
68633: rc = sqlite3BtreeLast(u.bg.pC->pCursor, &u.bg.res);
68634: if( rc!=SQLITE_OK ){
68635: goto abort_due_to_error;
68636: }
68637: if( u.bg.res ){
68638: u.bg.v = 1; /* IMP: R-61914-48074 */
68639: }else{
68640: assert( sqlite3BtreeCursorIsValid(u.bg.pC->pCursor) );
68641: rc = sqlite3BtreeKeySize(u.bg.pC->pCursor, &u.bg.v);
68642: assert( rc==SQLITE_OK ); /* Cannot fail following BtreeLast() */
68643: if( u.bg.v==MAX_ROWID ){
68644: u.bg.pC->useRandomRowid = 1;
68645: }else{
68646: u.bg.v++; /* IMP: R-29538-34987 */
68647: }
68648: }
68649: }
68650:
68651: #ifndef SQLITE_OMIT_AUTOINCREMENT
68652: if( pOp->p3 ){
68653: /* Assert that P3 is a valid memory cell. */
68654: assert( pOp->p3>0 );
68655: if( p->pFrame ){
68656: for(u.bg.pFrame=p->pFrame; u.bg.pFrame->pParent; u.bg.pFrame=u.bg.pFrame->pParent);
68657: /* Assert that P3 is a valid memory cell. */
68658: assert( pOp->p3<=u.bg.pFrame->nMem );
68659: u.bg.pMem = &u.bg.pFrame->aMem[pOp->p3];
68660: }else{
68661: /* Assert that P3 is a valid memory cell. */
68662: assert( pOp->p3<=p->nMem );
68663: u.bg.pMem = &aMem[pOp->p3];
68664: memAboutToChange(p, u.bg.pMem);
68665: }
68666: assert( memIsValid(u.bg.pMem) );
68667:
68668: REGISTER_TRACE(pOp->p3, u.bg.pMem);
68669: sqlite3VdbeMemIntegerify(u.bg.pMem);
68670: assert( (u.bg.pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
68671: if( u.bg.pMem->u.i==MAX_ROWID || u.bg.pC->useRandomRowid ){
68672: rc = SQLITE_FULL; /* IMP: R-12275-61338 */
68673: goto abort_due_to_error;
68674: }
68675: if( u.bg.v<u.bg.pMem->u.i+1 ){
68676: u.bg.v = u.bg.pMem->u.i + 1;
68677: }
68678: u.bg.pMem->u.i = u.bg.v;
68679: }
68680: #endif
68681:
68682: sqlite3BtreeSetCachedRowid(u.bg.pC->pCursor, u.bg.v<MAX_ROWID ? u.bg.v+1 : 0);
68683: }
68684: if( u.bg.pC->useRandomRowid ){
68685: /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
68686: ** largest possible integer (9223372036854775807) then the database
68687: ** engine starts picking positive candidate ROWIDs at random until
68688: ** it finds one that is not previously used. */
68689: assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
68690: ** an AUTOINCREMENT table. */
68691: /* on the first attempt, simply do one more than previous */
68692: u.bg.v = lastRowid;
68693: u.bg.v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
68694: u.bg.v++; /* ensure non-zero */
68695: u.bg.cnt = 0;
68696: while( ((rc = sqlite3BtreeMovetoUnpacked(u.bg.pC->pCursor, 0, (u64)u.bg.v,
68697: 0, &u.bg.res))==SQLITE_OK)
68698: && (u.bg.res==0)
68699: && (++u.bg.cnt<100)){
68700: /* collision - try another random rowid */
68701: sqlite3_randomness(sizeof(u.bg.v), &u.bg.v);
68702: if( u.bg.cnt<5 ){
68703: /* try "small" random rowids for the initial attempts */
68704: u.bg.v &= 0xffffff;
68705: }else{
68706: u.bg.v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
68707: }
68708: u.bg.v++; /* ensure non-zero */
68709: }
68710: if( rc==SQLITE_OK && u.bg.res==0 ){
68711: rc = SQLITE_FULL; /* IMP: R-38219-53002 */
68712: goto abort_due_to_error;
68713: }
68714: assert( u.bg.v>0 ); /* EV: R-40812-03570 */
68715: }
68716: u.bg.pC->rowidIsValid = 0;
68717: u.bg.pC->deferredMoveto = 0;
68718: u.bg.pC->cacheStatus = CACHE_STALE;
68719: }
68720: pOut->u.i = u.bg.v;
68721: break;
68722: }
68723:
68724: /* Opcode: Insert P1 P2 P3 P4 P5
68725: **
68726: ** Write an entry into the table of cursor P1. A new entry is
68727: ** created if it doesn't already exist or the data for an existing
68728: ** entry is overwritten. The data is the value MEM_Blob stored in register
68729: ** number P2. The key is stored in register P3. The key must
68730: ** be a MEM_Int.
68731: **
68732: ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
68733: ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set,
68734: ** then rowid is stored for subsequent return by the
68735: ** sqlite3_last_insert_rowid() function (otherwise it is unmodified).
68736: **
68737: ** If the OPFLAG_USESEEKRESULT flag of P5 is set and if the result of
68738: ** the last seek operation (OP_NotExists) was a success, then this
68739: ** operation will not attempt to find the appropriate row before doing
68740: ** the insert but will instead overwrite the row that the cursor is
68741: ** currently pointing to. Presumably, the prior OP_NotExists opcode
68742: ** has already positioned the cursor correctly. This is an optimization
68743: ** that boosts performance by avoiding redundant seeks.
68744: **
68745: ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
68746: ** UPDATE operation. Otherwise (if the flag is clear) then this opcode
68747: ** is part of an INSERT operation. The difference is only important to
68748: ** the update hook.
68749: **
68750: ** Parameter P4 may point to a string containing the table-name, or
68751: ** may be NULL. If it is not NULL, then the update-hook
68752: ** (sqlite3.xUpdateCallback) is invoked following a successful insert.
68753: **
68754: ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
68755: ** allocated, then ownership of P2 is transferred to the pseudo-cursor
68756: ** and register P2 becomes ephemeral. If the cursor is changed, the
68757: ** value of register P2 will then change. Make sure this does not
68758: ** cause any problems.)
68759: **
68760: ** This instruction only works on tables. The equivalent instruction
68761: ** for indices is OP_IdxInsert.
68762: */
68763: /* Opcode: InsertInt P1 P2 P3 P4 P5
68764: **
68765: ** This works exactly like OP_Insert except that the key is the
68766: ** integer value P3, not the value of the integer stored in register P3.
68767: */
68768: case OP_Insert:
68769: case OP_InsertInt: {
68770: #if 0 /* local variables moved into u.bh */
68771: Mem *pData; /* MEM cell holding data for the record to be inserted */
68772: Mem *pKey; /* MEM cell holding key for the record */
68773: i64 iKey; /* The integer ROWID or key for the record to be inserted */
68774: VdbeCursor *pC; /* Cursor to table into which insert is written */
68775: int nZero; /* Number of zero-bytes to append */
68776: int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */
68777: const char *zDb; /* database name - used by the update hook */
68778: const char *zTbl; /* Table name - used by the opdate hook */
68779: int op; /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */
68780: #endif /* local variables moved into u.bh */
68781:
68782: u.bh.pData = &aMem[pOp->p2];
68783: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68784: assert( memIsValid(u.bh.pData) );
68785: u.bh.pC = p->apCsr[pOp->p1];
68786: assert( u.bh.pC!=0 );
68787: assert( u.bh.pC->pCursor!=0 );
68788: assert( u.bh.pC->pseudoTableReg==0 );
68789: assert( u.bh.pC->isTable );
68790: REGISTER_TRACE(pOp->p2, u.bh.pData);
68791:
68792: if( pOp->opcode==OP_Insert ){
68793: u.bh.pKey = &aMem[pOp->p3];
68794: assert( u.bh.pKey->flags & MEM_Int );
68795: assert( memIsValid(u.bh.pKey) );
68796: REGISTER_TRACE(pOp->p3, u.bh.pKey);
68797: u.bh.iKey = u.bh.pKey->u.i;
68798: }else{
68799: assert( pOp->opcode==OP_InsertInt );
68800: u.bh.iKey = pOp->p3;
68801: }
68802:
68803: if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
68804: if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = lastRowid = u.bh.iKey;
68805: if( u.bh.pData->flags & MEM_Null ){
68806: u.bh.pData->z = 0;
68807: u.bh.pData->n = 0;
68808: }else{
68809: assert( u.bh.pData->flags & (MEM_Blob|MEM_Str) );
68810: }
68811: u.bh.seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bh.pC->seekResult : 0);
68812: if( u.bh.pData->flags & MEM_Zero ){
68813: u.bh.nZero = u.bh.pData->u.nZero;
68814: }else{
68815: u.bh.nZero = 0;
68816: }
68817: sqlite3BtreeSetCachedRowid(u.bh.pC->pCursor, 0);
68818: rc = sqlite3BtreeInsert(u.bh.pC->pCursor, 0, u.bh.iKey,
68819: u.bh.pData->z, u.bh.pData->n, u.bh.nZero,
68820: pOp->p5 & OPFLAG_APPEND, u.bh.seekResult
68821: );
68822: u.bh.pC->rowidIsValid = 0;
68823: u.bh.pC->deferredMoveto = 0;
68824: u.bh.pC->cacheStatus = CACHE_STALE;
68825:
68826: /* Invoke the update-hook if required. */
68827: if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
68828: u.bh.zDb = db->aDb[u.bh.pC->iDb].zName;
68829: u.bh.zTbl = pOp->p4.z;
68830: u.bh.op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT);
68831: assert( u.bh.pC->isTable );
68832: db->xUpdateCallback(db->pUpdateArg, u.bh.op, u.bh.zDb, u.bh.zTbl, u.bh.iKey);
68833: assert( u.bh.pC->iDb>=0 );
68834: }
68835: break;
68836: }
68837:
68838: /* Opcode: Delete P1 P2 * P4 *
68839: **
68840: ** Delete the record at which the P1 cursor is currently pointing.
68841: **
68842: ** The cursor will be left pointing at either the next or the previous
68843: ** record in the table. If it is left pointing at the next record, then
68844: ** the next Next instruction will be a no-op. Hence it is OK to delete
68845: ** a record from within an Next loop.
68846: **
68847: ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
68848: ** incremented (otherwise not).
68849: **
68850: ** P1 must not be pseudo-table. It has to be a real table with
68851: ** multiple rows.
68852: **
68853: ** If P4 is not NULL, then it is the name of the table that P1 is
68854: ** pointing to. The update hook will be invoked, if it exists.
68855: ** If P4 is not NULL then the P1 cursor must have been positioned
68856: ** using OP_NotFound prior to invoking this opcode.
68857: */
68858: case OP_Delete: {
68859: #if 0 /* local variables moved into u.bi */
68860: i64 iKey;
68861: VdbeCursor *pC;
68862: #endif /* local variables moved into u.bi */
68863:
68864: u.bi.iKey = 0;
68865: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68866: u.bi.pC = p->apCsr[pOp->p1];
68867: assert( u.bi.pC!=0 );
68868: assert( u.bi.pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
68869:
68870: /* If the update-hook will be invoked, set u.bi.iKey to the rowid of the
68871: ** row being deleted.
68872: */
68873: if( db->xUpdateCallback && pOp->p4.z ){
68874: assert( u.bi.pC->isTable );
68875: assert( u.bi.pC->rowidIsValid ); /* lastRowid set by previous OP_NotFound */
68876: u.bi.iKey = u.bi.pC->lastRowid;
68877: }
68878:
68879: /* The OP_Delete opcode always follows an OP_NotExists or OP_Last or
68880: ** OP_Column on the same table without any intervening operations that
68881: ** might move or invalidate the cursor. Hence cursor u.bi.pC is always pointing
68882: ** to the row to be deleted and the sqlite3VdbeCursorMoveto() operation
68883: ** below is always a no-op and cannot fail. We will run it anyhow, though,
68884: ** to guard against future changes to the code generator.
68885: **/
68886: assert( u.bi.pC->deferredMoveto==0 );
68887: rc = sqlite3VdbeCursorMoveto(u.bi.pC);
68888: if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
68889:
68890: sqlite3BtreeSetCachedRowid(u.bi.pC->pCursor, 0);
68891: rc = sqlite3BtreeDelete(u.bi.pC->pCursor);
68892: u.bi.pC->cacheStatus = CACHE_STALE;
68893:
68894: /* Invoke the update-hook if required. */
68895: if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
68896: const char *zDb = db->aDb[u.bi.pC->iDb].zName;
68897: const char *zTbl = pOp->p4.z;
68898: db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, zTbl, u.bi.iKey);
68899: assert( u.bi.pC->iDb>=0 );
68900: }
68901: if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++;
68902: break;
68903: }
68904: /* Opcode: ResetCount * * * * *
68905: **
68906: ** The value of the change counter is copied to the database handle
68907: ** change counter (returned by subsequent calls to sqlite3_changes()).
68908: ** Then the VMs internal change counter resets to 0.
68909: ** This is used by trigger programs.
68910: */
68911: case OP_ResetCount: {
68912: sqlite3VdbeSetChanges(db, p->nChange);
68913: p->nChange = 0;
68914: break;
68915: }
68916:
68917: /* Opcode: SorterCompare P1 P2 P3
68918: **
68919: ** P1 is a sorter cursor. This instruction compares the record blob in
68920: ** register P3 with the entry that the sorter cursor currently points to.
68921: ** If, excluding the rowid fields at the end, the two records are a match,
68922: ** fall through to the next instruction. Otherwise, jump to instruction P2.
68923: */
68924: case OP_SorterCompare: {
68925: #if 0 /* local variables moved into u.bj */
68926: VdbeCursor *pC;
68927: int res;
68928: #endif /* local variables moved into u.bj */
68929:
68930: u.bj.pC = p->apCsr[pOp->p1];
68931: assert( isSorter(u.bj.pC) );
68932: pIn3 = &aMem[pOp->p3];
68933: rc = sqlite3VdbeSorterCompare(u.bj.pC, pIn3, &u.bj.res);
68934: if( u.bj.res ){
68935: pc = pOp->p2-1;
68936: }
68937: break;
68938: };
68939:
68940: /* Opcode: SorterData P1 P2 * * *
68941: **
68942: ** Write into register P2 the current sorter data for sorter cursor P1.
68943: */
68944: case OP_SorterData: {
68945: #if 0 /* local variables moved into u.bk */
68946: VdbeCursor *pC;
68947: #endif /* local variables moved into u.bk */
68948: #ifndef SQLITE_OMIT_MERGE_SORT
68949: pOut = &aMem[pOp->p2];
68950: u.bk.pC = p->apCsr[pOp->p1];
68951: assert( u.bk.pC->isSorter );
68952: rc = sqlite3VdbeSorterRowkey(u.bk.pC, pOut);
68953: #else
68954: pOp->opcode = OP_RowKey;
68955: pc--;
68956: #endif
68957: break;
68958: }
68959:
68960: /* Opcode: RowData P1 P2 * * *
68961: **
68962: ** Write into register P2 the complete row data for cursor P1.
68963: ** There is no interpretation of the data.
68964: ** It is just copied onto the P2 register exactly as
68965: ** it is found in the database file.
68966: **
68967: ** If the P1 cursor must be pointing to a valid row (not a NULL row)
68968: ** of a real table, not a pseudo-table.
68969: */
68970: /* Opcode: RowKey P1 P2 * * *
68971: **
68972: ** Write into register P2 the complete row key for cursor P1.
68973: ** There is no interpretation of the data.
68974: ** The key is copied onto the P3 register exactly as
68975: ** it is found in the database file.
68976: **
68977: ** If the P1 cursor must be pointing to a valid row (not a NULL row)
68978: ** of a real table, not a pseudo-table.
68979: */
68980: case OP_RowKey:
68981: case OP_RowData: {
68982: #if 0 /* local variables moved into u.bl */
68983: VdbeCursor *pC;
68984: BtCursor *pCrsr;
68985: u32 n;
68986: i64 n64;
68987: #endif /* local variables moved into u.bl */
68988:
68989: pOut = &aMem[pOp->p2];
68990: memAboutToChange(p, pOut);
68991:
68992: /* Note that RowKey and RowData are really exactly the same instruction */
68993: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
68994: u.bl.pC = p->apCsr[pOp->p1];
68995: assert( u.bl.pC->isSorter==0 );
68996: assert( u.bl.pC->isTable || pOp->opcode!=OP_RowData );
68997: assert( u.bl.pC->isIndex || pOp->opcode==OP_RowData );
68998: assert( u.bl.pC!=0 );
68999: assert( u.bl.pC->nullRow==0 );
69000: assert( u.bl.pC->pseudoTableReg==0 );
69001: assert( !u.bl.pC->isSorter );
69002: assert( u.bl.pC->pCursor!=0 );
69003: u.bl.pCrsr = u.bl.pC->pCursor;
69004: assert( sqlite3BtreeCursorIsValid(u.bl.pCrsr) );
69005:
69006: /* The OP_RowKey and OP_RowData opcodes always follow OP_NotExists or
69007: ** OP_Rewind/Op_Next with no intervening instructions that might invalidate
69008: ** the cursor. Hence the following sqlite3VdbeCursorMoveto() call is always
69009: ** a no-op and can never fail. But we leave it in place as a safety.
69010: */
69011: assert( u.bl.pC->deferredMoveto==0 );
69012: rc = sqlite3VdbeCursorMoveto(u.bl.pC);
69013: if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
69014:
69015: if( u.bl.pC->isIndex ){
69016: assert( !u.bl.pC->isTable );
69017: VVA_ONLY(rc =) sqlite3BtreeKeySize(u.bl.pCrsr, &u.bl.n64);
69018: assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
69019: if( u.bl.n64>db->aLimit[SQLITE_LIMIT_LENGTH] ){
69020: goto too_big;
69021: }
69022: u.bl.n = (u32)u.bl.n64;
69023: }else{
69024: VVA_ONLY(rc =) sqlite3BtreeDataSize(u.bl.pCrsr, &u.bl.n);
69025: assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
69026: if( u.bl.n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
69027: goto too_big;
69028: }
69029: }
69030: if( sqlite3VdbeMemGrow(pOut, u.bl.n, 0) ){
69031: goto no_mem;
69032: }
69033: pOut->n = u.bl.n;
69034: MemSetTypeFlag(pOut, MEM_Blob);
69035: if( u.bl.pC->isIndex ){
69036: rc = sqlite3BtreeKey(u.bl.pCrsr, 0, u.bl.n, pOut->z);
69037: }else{
69038: rc = sqlite3BtreeData(u.bl.pCrsr, 0, u.bl.n, pOut->z);
69039: }
69040: pOut->enc = SQLITE_UTF8; /* In case the blob is ever cast to text */
69041: UPDATE_MAX_BLOBSIZE(pOut);
69042: break;
69043: }
69044:
69045: /* Opcode: Rowid P1 P2 * * *
69046: **
69047: ** Store in register P2 an integer which is the key of the table entry that
69048: ** P1 is currently point to.
69049: **
69050: ** P1 can be either an ordinary table or a virtual table. There used to
69051: ** be a separate OP_VRowid opcode for use with virtual tables, but this
69052: ** one opcode now works for both table types.
69053: */
69054: case OP_Rowid: { /* out2-prerelease */
69055: #if 0 /* local variables moved into u.bm */
69056: VdbeCursor *pC;
69057: i64 v;
69058: sqlite3_vtab *pVtab;
69059: const sqlite3_module *pModule;
69060: #endif /* local variables moved into u.bm */
69061:
69062: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69063: u.bm.pC = p->apCsr[pOp->p1];
69064: assert( u.bm.pC!=0 );
69065: assert( u.bm.pC->pseudoTableReg==0 );
69066: if( u.bm.pC->nullRow ){
69067: pOut->flags = MEM_Null;
69068: break;
69069: }else if( u.bm.pC->deferredMoveto ){
69070: u.bm.v = u.bm.pC->movetoTarget;
69071: #ifndef SQLITE_OMIT_VIRTUALTABLE
69072: }else if( u.bm.pC->pVtabCursor ){
69073: u.bm.pVtab = u.bm.pC->pVtabCursor->pVtab;
69074: u.bm.pModule = u.bm.pVtab->pModule;
69075: assert( u.bm.pModule->xRowid );
69076: rc = u.bm.pModule->xRowid(u.bm.pC->pVtabCursor, &u.bm.v);
69077: importVtabErrMsg(p, u.bm.pVtab);
69078: #endif /* SQLITE_OMIT_VIRTUALTABLE */
69079: }else{
69080: assert( u.bm.pC->pCursor!=0 );
69081: rc = sqlite3VdbeCursorMoveto(u.bm.pC);
69082: if( rc ) goto abort_due_to_error;
69083: if( u.bm.pC->rowidIsValid ){
69084: u.bm.v = u.bm.pC->lastRowid;
69085: }else{
69086: rc = sqlite3BtreeKeySize(u.bm.pC->pCursor, &u.bm.v);
69087: assert( rc==SQLITE_OK ); /* Always so because of CursorMoveto() above */
69088: }
69089: }
69090: pOut->u.i = u.bm.v;
69091: break;
69092: }
69093:
69094: /* Opcode: NullRow P1 * * * *
69095: **
69096: ** Move the cursor P1 to a null row. Any OP_Column operations
69097: ** that occur while the cursor is on the null row will always
69098: ** write a NULL.
69099: */
69100: case OP_NullRow: {
69101: #if 0 /* local variables moved into u.bn */
69102: VdbeCursor *pC;
69103: #endif /* local variables moved into u.bn */
69104:
69105: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69106: u.bn.pC = p->apCsr[pOp->p1];
69107: assert( u.bn.pC!=0 );
69108: u.bn.pC->nullRow = 1;
69109: u.bn.pC->rowidIsValid = 0;
69110: assert( u.bn.pC->pCursor || u.bn.pC->pVtabCursor );
69111: if( u.bn.pC->pCursor ){
69112: sqlite3BtreeClearCursor(u.bn.pC->pCursor);
69113: }
69114: break;
69115: }
69116:
69117: /* Opcode: Last P1 P2 * * *
69118: **
69119: ** The next use of the Rowid or Column or Next instruction for P1
69120: ** will refer to the last entry in the database table or index.
69121: ** If the table or index is empty and P2>0, then jump immediately to P2.
69122: ** If P2 is 0 or if the table or index is not empty, fall through
69123: ** to the following instruction.
69124: */
69125: case OP_Last: { /* jump */
69126: #if 0 /* local variables moved into u.bo */
69127: VdbeCursor *pC;
69128: BtCursor *pCrsr;
69129: int res;
69130: #endif /* local variables moved into u.bo */
69131:
69132: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69133: u.bo.pC = p->apCsr[pOp->p1];
69134: assert( u.bo.pC!=0 );
69135: u.bo.pCrsr = u.bo.pC->pCursor;
69136: u.bo.res = 0;
69137: if( ALWAYS(u.bo.pCrsr!=0) ){
69138: rc = sqlite3BtreeLast(u.bo.pCrsr, &u.bo.res);
69139: }
69140: u.bo.pC->nullRow = (u8)u.bo.res;
69141: u.bo.pC->deferredMoveto = 0;
69142: u.bo.pC->rowidIsValid = 0;
69143: u.bo.pC->cacheStatus = CACHE_STALE;
69144: if( pOp->p2>0 && u.bo.res ){
69145: pc = pOp->p2 - 1;
69146: }
69147: break;
69148: }
69149:
69150:
69151: /* Opcode: Sort P1 P2 * * *
69152: **
69153: ** This opcode does exactly the same thing as OP_Rewind except that
69154: ** it increments an undocumented global variable used for testing.
69155: **
69156: ** Sorting is accomplished by writing records into a sorting index,
69157: ** then rewinding that index and playing it back from beginning to
69158: ** end. We use the OP_Sort opcode instead of OP_Rewind to do the
69159: ** rewinding so that the global variable will be incremented and
69160: ** regression tests can determine whether or not the optimizer is
69161: ** correctly optimizing out sorts.
69162: */
69163: case OP_SorterSort: /* jump */
69164: #ifdef SQLITE_OMIT_MERGE_SORT
69165: pOp->opcode = OP_Sort;
69166: #endif
69167: case OP_Sort: { /* jump */
69168: #ifdef SQLITE_TEST
69169: sqlite3_sort_count++;
69170: sqlite3_search_count--;
69171: #endif
69172: p->aCounter[SQLITE_STMTSTATUS_SORT-1]++;
69173: /* Fall through into OP_Rewind */
69174: }
69175: /* Opcode: Rewind P1 P2 * * *
69176: **
69177: ** The next use of the Rowid or Column or Next instruction for P1
69178: ** will refer to the first entry in the database table or index.
69179: ** If the table or index is empty and P2>0, then jump immediately to P2.
69180: ** If P2 is 0 or if the table or index is not empty, fall through
69181: ** to the following instruction.
69182: */
69183: case OP_Rewind: { /* jump */
69184: #if 0 /* local variables moved into u.bp */
69185: VdbeCursor *pC;
69186: BtCursor *pCrsr;
69187: int res;
69188: #endif /* local variables moved into u.bp */
69189:
69190: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69191: u.bp.pC = p->apCsr[pOp->p1];
69192: assert( u.bp.pC!=0 );
69193: assert( u.bp.pC->isSorter==(pOp->opcode==OP_SorterSort) );
69194: u.bp.res = 1;
69195: if( isSorter(u.bp.pC) ){
69196: rc = sqlite3VdbeSorterRewind(db, u.bp.pC, &u.bp.res);
69197: }else{
69198: u.bp.pCrsr = u.bp.pC->pCursor;
69199: assert( u.bp.pCrsr );
69200: rc = sqlite3BtreeFirst(u.bp.pCrsr, &u.bp.res);
69201: u.bp.pC->atFirst = u.bp.res==0 ?1:0;
69202: u.bp.pC->deferredMoveto = 0;
69203: u.bp.pC->cacheStatus = CACHE_STALE;
69204: u.bp.pC->rowidIsValid = 0;
69205: }
69206: u.bp.pC->nullRow = (u8)u.bp.res;
69207: assert( pOp->p2>0 && pOp->p2<p->nOp );
69208: if( u.bp.res ){
69209: pc = pOp->p2 - 1;
69210: }
69211: break;
69212: }
69213:
69214: /* Opcode: Next P1 P2 * P4 P5
69215: **
69216: ** Advance cursor P1 so that it points to the next key/data pair in its
69217: ** table or index. If there are no more key/value pairs then fall through
69218: ** to the following instruction. But if the cursor advance was successful,
69219: ** jump immediately to P2.
69220: **
69221: ** The P1 cursor must be for a real table, not a pseudo-table.
69222: **
69223: ** P4 is always of type P4_ADVANCE. The function pointer points to
69224: ** sqlite3BtreeNext().
69225: **
69226: ** If P5 is positive and the jump is taken, then event counter
69227: ** number P5-1 in the prepared statement is incremented.
69228: **
69229: ** See also: Prev
69230: */
69231: /* Opcode: Prev P1 P2 * * P5
69232: **
69233: ** Back up cursor P1 so that it points to the previous key/data pair in its
69234: ** table or index. If there is no previous key/value pairs then fall through
69235: ** to the following instruction. But if the cursor backup was successful,
69236: ** jump immediately to P2.
69237: **
69238: ** The P1 cursor must be for a real table, not a pseudo-table.
69239: **
69240: ** P4 is always of type P4_ADVANCE. The function pointer points to
69241: ** sqlite3BtreePrevious().
69242: **
69243: ** If P5 is positive and the jump is taken, then event counter
69244: ** number P5-1 in the prepared statement is incremented.
69245: */
69246: case OP_SorterNext: /* jump */
69247: #ifdef SQLITE_OMIT_MERGE_SORT
69248: pOp->opcode = OP_Next;
69249: #endif
69250: case OP_Prev: /* jump */
69251: case OP_Next: { /* jump */
69252: #if 0 /* local variables moved into u.bq */
69253: VdbeCursor *pC;
69254: int res;
69255: #endif /* local variables moved into u.bq */
69256:
69257: CHECK_FOR_INTERRUPT;
69258: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69259: assert( pOp->p5<=ArraySize(p->aCounter) );
69260: u.bq.pC = p->apCsr[pOp->p1];
69261: if( u.bq.pC==0 ){
69262: break; /* See ticket #2273 */
69263: }
69264: assert( u.bq.pC->isSorter==(pOp->opcode==OP_SorterNext) );
69265: if( isSorter(u.bq.pC) ){
69266: assert( pOp->opcode==OP_SorterNext );
69267: rc = sqlite3VdbeSorterNext(db, u.bq.pC, &u.bq.res);
69268: }else{
69269: u.bq.res = 1;
69270: assert( u.bq.pC->deferredMoveto==0 );
69271: assert( u.bq.pC->pCursor );
69272: assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
69273: assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
69274: rc = pOp->p4.xAdvance(u.bq.pC->pCursor, &u.bq.res);
69275: }
69276: u.bq.pC->nullRow = (u8)u.bq.res;
69277: u.bq.pC->cacheStatus = CACHE_STALE;
69278: if( u.bq.res==0 ){
69279: pc = pOp->p2 - 1;
69280: if( pOp->p5 ) p->aCounter[pOp->p5-1]++;
69281: #ifdef SQLITE_TEST
69282: sqlite3_search_count++;
69283: #endif
69284: }
69285: u.bq.pC->rowidIsValid = 0;
69286: break;
69287: }
69288:
69289: /* Opcode: IdxInsert P1 P2 P3 * P5
69290: **
69291: ** Register P2 holds an SQL index key made using the
69292: ** MakeRecord instructions. This opcode writes that key
69293: ** into the index P1. Data for the entry is nil.
69294: **
69295: ** P3 is a flag that provides a hint to the b-tree layer that this
69296: ** insert is likely to be an append.
69297: **
69298: ** This instruction only works for indices. The equivalent instruction
69299: ** for tables is OP_Insert.
69300: */
69301: case OP_SorterInsert: /* in2 */
69302: #ifdef SQLITE_OMIT_MERGE_SORT
69303: pOp->opcode = OP_IdxInsert;
69304: #endif
69305: case OP_IdxInsert: { /* in2 */
69306: #if 0 /* local variables moved into u.br */
69307: VdbeCursor *pC;
69308: BtCursor *pCrsr;
69309: int nKey;
69310: const char *zKey;
69311: #endif /* local variables moved into u.br */
69312:
69313: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69314: u.br.pC = p->apCsr[pOp->p1];
69315: assert( u.br.pC!=0 );
69316: assert( u.br.pC->isSorter==(pOp->opcode==OP_SorterInsert) );
69317: pIn2 = &aMem[pOp->p2];
69318: assert( pIn2->flags & MEM_Blob );
69319: u.br.pCrsr = u.br.pC->pCursor;
69320: if( ALWAYS(u.br.pCrsr!=0) ){
69321: assert( u.br.pC->isTable==0 );
69322: rc = ExpandBlob(pIn2);
69323: if( rc==SQLITE_OK ){
69324: if( isSorter(u.br.pC) ){
69325: rc = sqlite3VdbeSorterWrite(db, u.br.pC, pIn2);
69326: }else{
69327: u.br.nKey = pIn2->n;
69328: u.br.zKey = pIn2->z;
69329: rc = sqlite3BtreeInsert(u.br.pCrsr, u.br.zKey, u.br.nKey, "", 0, 0, pOp->p3,
69330: ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.br.pC->seekResult : 0)
69331: );
69332: assert( u.br.pC->deferredMoveto==0 );
69333: u.br.pC->cacheStatus = CACHE_STALE;
69334: }
69335: }
69336: }
69337: break;
69338: }
69339:
69340: /* Opcode: IdxDelete P1 P2 P3 * *
69341: **
69342: ** The content of P3 registers starting at register P2 form
69343: ** an unpacked index key. This opcode removes that entry from the
69344: ** index opened by cursor P1.
69345: */
69346: case OP_IdxDelete: {
69347: #if 0 /* local variables moved into u.bs */
69348: VdbeCursor *pC;
69349: BtCursor *pCrsr;
69350: int res;
69351: UnpackedRecord r;
69352: #endif /* local variables moved into u.bs */
69353:
69354: assert( pOp->p3>0 );
69355: assert( pOp->p2>0 && pOp->p2+pOp->p3<=p->nMem+1 );
69356: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69357: u.bs.pC = p->apCsr[pOp->p1];
69358: assert( u.bs.pC!=0 );
69359: u.bs.pCrsr = u.bs.pC->pCursor;
69360: if( ALWAYS(u.bs.pCrsr!=0) ){
69361: u.bs.r.pKeyInfo = u.bs.pC->pKeyInfo;
69362: u.bs.r.nField = (u16)pOp->p3;
69363: u.bs.r.flags = 0;
69364: u.bs.r.aMem = &aMem[pOp->p2];
69365: #ifdef SQLITE_DEBUG
69366: { int i; for(i=0; i<u.bs.r.nField; i++) assert( memIsValid(&u.bs.r.aMem[i]) ); }
69367: #endif
69368: rc = sqlite3BtreeMovetoUnpacked(u.bs.pCrsr, &u.bs.r, 0, 0, &u.bs.res);
69369: if( rc==SQLITE_OK && u.bs.res==0 ){
69370: rc = sqlite3BtreeDelete(u.bs.pCrsr);
69371: }
69372: assert( u.bs.pC->deferredMoveto==0 );
69373: u.bs.pC->cacheStatus = CACHE_STALE;
69374: }
69375: break;
69376: }
69377:
69378: /* Opcode: IdxRowid P1 P2 * * *
69379: **
69380: ** Write into register P2 an integer which is the last entry in the record at
69381: ** the end of the index key pointed to by cursor P1. This integer should be
69382: ** the rowid of the table entry to which this index entry points.
69383: **
69384: ** See also: Rowid, MakeRecord.
69385: */
69386: case OP_IdxRowid: { /* out2-prerelease */
69387: #if 0 /* local variables moved into u.bt */
69388: BtCursor *pCrsr;
69389: VdbeCursor *pC;
69390: i64 rowid;
69391: #endif /* local variables moved into u.bt */
69392:
69393: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69394: u.bt.pC = p->apCsr[pOp->p1];
69395: assert( u.bt.pC!=0 );
69396: u.bt.pCrsr = u.bt.pC->pCursor;
69397: pOut->flags = MEM_Null;
69398: if( ALWAYS(u.bt.pCrsr!=0) ){
69399: rc = sqlite3VdbeCursorMoveto(u.bt.pC);
69400: if( NEVER(rc) ) goto abort_due_to_error;
69401: assert( u.bt.pC->deferredMoveto==0 );
69402: assert( u.bt.pC->isTable==0 );
69403: if( !u.bt.pC->nullRow ){
69404: rc = sqlite3VdbeIdxRowid(db, u.bt.pCrsr, &u.bt.rowid);
69405: if( rc!=SQLITE_OK ){
69406: goto abort_due_to_error;
69407: }
69408: pOut->u.i = u.bt.rowid;
69409: pOut->flags = MEM_Int;
69410: }
69411: }
69412: break;
69413: }
69414:
69415: /* Opcode: IdxGE P1 P2 P3 P4 P5
69416: **
69417: ** The P4 register values beginning with P3 form an unpacked index
69418: ** key that omits the ROWID. Compare this key value against the index
69419: ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
69420: **
69421: ** If the P1 index entry is greater than or equal to the key value
69422: ** then jump to P2. Otherwise fall through to the next instruction.
69423: **
69424: ** If P5 is non-zero then the key value is increased by an epsilon
69425: ** prior to the comparison. This make the opcode work like IdxGT except
69426: ** that if the key from register P3 is a prefix of the key in the cursor,
69427: ** the result is false whereas it would be true with IdxGT.
69428: */
69429: /* Opcode: IdxLT P1 P2 P3 P4 P5
69430: **
69431: ** The P4 register values beginning with P3 form an unpacked index
69432: ** key that omits the ROWID. Compare this key value against the index
69433: ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
69434: **
69435: ** If the P1 index entry is less than the key value then jump to P2.
69436: ** Otherwise fall through to the next instruction.
69437: **
69438: ** If P5 is non-zero then the key value is increased by an epsilon prior
69439: ** to the comparison. This makes the opcode work like IdxLE.
69440: */
69441: case OP_IdxLT: /* jump */
69442: case OP_IdxGE: { /* jump */
69443: #if 0 /* local variables moved into u.bu */
69444: VdbeCursor *pC;
69445: int res;
69446: UnpackedRecord r;
69447: #endif /* local variables moved into u.bu */
69448:
69449: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
69450: u.bu.pC = p->apCsr[pOp->p1];
69451: assert( u.bu.pC!=0 );
69452: assert( u.bu.pC->isOrdered );
69453: if( ALWAYS(u.bu.pC->pCursor!=0) ){
69454: assert( u.bu.pC->deferredMoveto==0 );
69455: assert( pOp->p5==0 || pOp->p5==1 );
69456: assert( pOp->p4type==P4_INT32 );
69457: u.bu.r.pKeyInfo = u.bu.pC->pKeyInfo;
69458: u.bu.r.nField = (u16)pOp->p4.i;
69459: if( pOp->p5 ){
69460: u.bu.r.flags = UNPACKED_INCRKEY | UNPACKED_PREFIX_MATCH;
69461: }else{
69462: u.bu.r.flags = UNPACKED_PREFIX_MATCH;
69463: }
69464: u.bu.r.aMem = &aMem[pOp->p3];
69465: #ifdef SQLITE_DEBUG
69466: { int i; for(i=0; i<u.bu.r.nField; i++) assert( memIsValid(&u.bu.r.aMem[i]) ); }
69467: #endif
69468: rc = sqlite3VdbeIdxKeyCompare(u.bu.pC, &u.bu.r, &u.bu.res);
69469: if( pOp->opcode==OP_IdxLT ){
69470: u.bu.res = -u.bu.res;
69471: }else{
69472: assert( pOp->opcode==OP_IdxGE );
69473: u.bu.res++;
69474: }
69475: if( u.bu.res>0 ){
69476: pc = pOp->p2 - 1 ;
69477: }
69478: }
69479: break;
69480: }
69481:
69482: /* Opcode: Destroy P1 P2 P3 * *
69483: **
69484: ** Delete an entire database table or index whose root page in the database
69485: ** file is given by P1.
69486: **
69487: ** The table being destroyed is in the main database file if P3==0. If
69488: ** P3==1 then the table to be clear is in the auxiliary database file
69489: ** that is used to store tables create using CREATE TEMPORARY TABLE.
69490: **
69491: ** If AUTOVACUUM is enabled then it is possible that another root page
69492: ** might be moved into the newly deleted root page in order to keep all
69493: ** root pages contiguous at the beginning of the database. The former
69494: ** value of the root page that moved - its value before the move occurred -
69495: ** is stored in register P2. If no page
69496: ** movement was required (because the table being dropped was already
69497: ** the last one in the database) then a zero is stored in register P2.
69498: ** If AUTOVACUUM is disabled then a zero is stored in register P2.
69499: **
69500: ** See also: Clear
69501: */
69502: case OP_Destroy: { /* out2-prerelease */
69503: #if 0 /* local variables moved into u.bv */
69504: int iMoved;
69505: int iCnt;
69506: Vdbe *pVdbe;
69507: int iDb;
69508: #endif /* local variables moved into u.bv */
69509: #ifndef SQLITE_OMIT_VIRTUALTABLE
69510: u.bv.iCnt = 0;
69511: for(u.bv.pVdbe=db->pVdbe; u.bv.pVdbe; u.bv.pVdbe = u.bv.pVdbe->pNext){
69512: if( u.bv.pVdbe->magic==VDBE_MAGIC_RUN && u.bv.pVdbe->inVtabMethod<2 && u.bv.pVdbe->pc>=0 ){
69513: u.bv.iCnt++;
69514: }
69515: }
69516: #else
69517: u.bv.iCnt = db->activeVdbeCnt;
69518: #endif
69519: pOut->flags = MEM_Null;
69520: if( u.bv.iCnt>1 ){
69521: rc = SQLITE_LOCKED;
69522: p->errorAction = OE_Abort;
69523: }else{
69524: u.bv.iDb = pOp->p3;
69525: assert( u.bv.iCnt==1 );
69526: assert( (p->btreeMask & (((yDbMask)1)<<u.bv.iDb))!=0 );
69527: rc = sqlite3BtreeDropTable(db->aDb[u.bv.iDb].pBt, pOp->p1, &u.bv.iMoved);
69528: pOut->flags = MEM_Int;
69529: pOut->u.i = u.bv.iMoved;
69530: #ifndef SQLITE_OMIT_AUTOVACUUM
69531: if( rc==SQLITE_OK && u.bv.iMoved!=0 ){
69532: sqlite3RootPageMoved(db, u.bv.iDb, u.bv.iMoved, pOp->p1);
69533: /* All OP_Destroy operations occur on the same btree */
69534: assert( resetSchemaOnFault==0 || resetSchemaOnFault==u.bv.iDb+1 );
69535: resetSchemaOnFault = u.bv.iDb+1;
69536: }
69537: #endif
69538: }
69539: break;
69540: }
69541:
69542: /* Opcode: Clear P1 P2 P3
69543: **
69544: ** Delete all contents of the database table or index whose root page
69545: ** in the database file is given by P1. But, unlike Destroy, do not
69546: ** remove the table or index from the database file.
69547: **
69548: ** The table being clear is in the main database file if P2==0. If
69549: ** P2==1 then the table to be clear is in the auxiliary database file
69550: ** that is used to store tables create using CREATE TEMPORARY TABLE.
69551: **
69552: ** If the P3 value is non-zero, then the table referred to must be an
69553: ** intkey table (an SQL table, not an index). In this case the row change
69554: ** count is incremented by the number of rows in the table being cleared.
69555: ** If P3 is greater than zero, then the value stored in register P3 is
69556: ** also incremented by the number of rows in the table being cleared.
69557: **
69558: ** See also: Destroy
69559: */
69560: case OP_Clear: {
69561: #if 0 /* local variables moved into u.bw */
69562: int nChange;
69563: #endif /* local variables moved into u.bw */
69564:
69565: u.bw.nChange = 0;
69566: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
69567: rc = sqlite3BtreeClearTable(
69568: db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &u.bw.nChange : 0)
69569: );
69570: if( pOp->p3 ){
69571: p->nChange += u.bw.nChange;
69572: if( pOp->p3>0 ){
69573: assert( memIsValid(&aMem[pOp->p3]) );
69574: memAboutToChange(p, &aMem[pOp->p3]);
69575: aMem[pOp->p3].u.i += u.bw.nChange;
69576: }
69577: }
69578: break;
69579: }
69580:
69581: /* Opcode: CreateTable P1 P2 * * *
69582: **
69583: ** Allocate a new table in the main database file if P1==0 or in the
69584: ** auxiliary database file if P1==1 or in an attached database if
69585: ** P1>1. Write the root page number of the new table into
69586: ** register P2
69587: **
69588: ** The difference between a table and an index is this: A table must
69589: ** have a 4-byte integer key and can have arbitrary data. An index
69590: ** has an arbitrary key but no data.
69591: **
69592: ** See also: CreateIndex
69593: */
69594: /* Opcode: CreateIndex P1 P2 * * *
69595: **
69596: ** Allocate a new index in the main database file if P1==0 or in the
69597: ** auxiliary database file if P1==1 or in an attached database if
69598: ** P1>1. Write the root page number of the new table into
69599: ** register P2.
69600: **
69601: ** See documentation on OP_CreateTable for additional information.
69602: */
69603: case OP_CreateIndex: /* out2-prerelease */
69604: case OP_CreateTable: { /* out2-prerelease */
69605: #if 0 /* local variables moved into u.bx */
69606: int pgno;
69607: int flags;
69608: Db *pDb;
69609: #endif /* local variables moved into u.bx */
69610:
69611: u.bx.pgno = 0;
69612: assert( pOp->p1>=0 && pOp->p1<db->nDb );
69613: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
69614: u.bx.pDb = &db->aDb[pOp->p1];
69615: assert( u.bx.pDb->pBt!=0 );
69616: if( pOp->opcode==OP_CreateTable ){
69617: /* u.bx.flags = BTREE_INTKEY; */
69618: u.bx.flags = BTREE_INTKEY;
69619: }else{
69620: u.bx.flags = BTREE_BLOBKEY;
69621: }
69622: rc = sqlite3BtreeCreateTable(u.bx.pDb->pBt, &u.bx.pgno, u.bx.flags);
69623: pOut->u.i = u.bx.pgno;
69624: break;
69625: }
69626:
69627: /* Opcode: ParseSchema P1 * * P4 *
69628: **
69629: ** Read and parse all entries from the SQLITE_MASTER table of database P1
69630: ** that match the WHERE clause P4.
69631: **
69632: ** This opcode invokes the parser to create a new virtual machine,
69633: ** then runs the new virtual machine. It is thus a re-entrant opcode.
69634: */
69635: case OP_ParseSchema: {
69636: #if 0 /* local variables moved into u.by */
69637: int iDb;
69638: const char *zMaster;
69639: char *zSql;
69640: InitData initData;
69641: #endif /* local variables moved into u.by */
69642:
69643: /* Any prepared statement that invokes this opcode will hold mutexes
69644: ** on every btree. This is a prerequisite for invoking
69645: ** sqlite3InitCallback().
69646: */
69647: #ifdef SQLITE_DEBUG
69648: for(u.by.iDb=0; u.by.iDb<db->nDb; u.by.iDb++){
69649: assert( u.by.iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[u.by.iDb].pBt) );
69650: }
69651: #endif
69652:
69653: u.by.iDb = pOp->p1;
69654: assert( u.by.iDb>=0 && u.by.iDb<db->nDb );
69655: assert( DbHasProperty(db, u.by.iDb, DB_SchemaLoaded) );
69656: /* Used to be a conditional */ {
69657: u.by.zMaster = SCHEMA_TABLE(u.by.iDb);
69658: u.by.initData.db = db;
69659: u.by.initData.iDb = pOp->p1;
69660: u.by.initData.pzErrMsg = &p->zErrMsg;
69661: u.by.zSql = sqlite3MPrintf(db,
69662: "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s ORDER BY rowid",
69663: db->aDb[u.by.iDb].zName, u.by.zMaster, pOp->p4.z);
69664: if( u.by.zSql==0 ){
69665: rc = SQLITE_NOMEM;
69666: }else{
69667: assert( db->init.busy==0 );
69668: db->init.busy = 1;
69669: u.by.initData.rc = SQLITE_OK;
69670: assert( !db->mallocFailed );
69671: rc = sqlite3_exec(db, u.by.zSql, sqlite3InitCallback, &u.by.initData, 0);
69672: if( rc==SQLITE_OK ) rc = u.by.initData.rc;
69673: sqlite3DbFree(db, u.by.zSql);
69674: db->init.busy = 0;
69675: }
69676: }
69677: if( rc==SQLITE_NOMEM ){
69678: goto no_mem;
69679: }
69680: break;
69681: }
69682:
69683: #if !defined(SQLITE_OMIT_ANALYZE)
69684: /* Opcode: LoadAnalysis P1 * * * *
69685: **
69686: ** Read the sqlite_stat1 table for database P1 and load the content
69687: ** of that table into the internal index hash table. This will cause
69688: ** the analysis to be used when preparing all subsequent queries.
69689: */
69690: case OP_LoadAnalysis: {
69691: assert( pOp->p1>=0 && pOp->p1<db->nDb );
69692: rc = sqlite3AnalysisLoad(db, pOp->p1);
69693: break;
69694: }
69695: #endif /* !defined(SQLITE_OMIT_ANALYZE) */
69696:
69697: /* Opcode: DropTable P1 * * P4 *
69698: **
69699: ** Remove the internal (in-memory) data structures that describe
69700: ** the table named P4 in database P1. This is called after a table
69701: ** is dropped in order to keep the internal representation of the
69702: ** schema consistent with what is on disk.
69703: */
69704: case OP_DropTable: {
69705: sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
69706: break;
69707: }
69708:
69709: /* Opcode: DropIndex P1 * * P4 *
69710: **
69711: ** Remove the internal (in-memory) data structures that describe
69712: ** the index named P4 in database P1. This is called after an index
69713: ** is dropped in order to keep the internal representation of the
69714: ** schema consistent with what is on disk.
69715: */
69716: case OP_DropIndex: {
69717: sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
69718: break;
69719: }
69720:
69721: /* Opcode: DropTrigger P1 * * P4 *
69722: **
69723: ** Remove the internal (in-memory) data structures that describe
69724: ** the trigger named P4 in database P1. This is called after a trigger
69725: ** is dropped in order to keep the internal representation of the
69726: ** schema consistent with what is on disk.
69727: */
69728: case OP_DropTrigger: {
69729: sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
69730: break;
69731: }
69732:
69733:
69734: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
69735: /* Opcode: IntegrityCk P1 P2 P3 * P5
69736: **
69737: ** Do an analysis of the currently open database. Store in
69738: ** register P1 the text of an error message describing any problems.
69739: ** If no problems are found, store a NULL in register P1.
69740: **
69741: ** The register P3 contains the maximum number of allowed errors.
69742: ** At most reg(P3) errors will be reported.
69743: ** In other words, the analysis stops as soon as reg(P1) errors are
69744: ** seen. Reg(P1) is updated with the number of errors remaining.
69745: **
69746: ** The root page numbers of all tables in the database are integer
69747: ** stored in reg(P1), reg(P1+1), reg(P1+2), .... There are P2 tables
69748: ** total.
69749: **
69750: ** If P5 is not zero, the check is done on the auxiliary database
69751: ** file, not the main database file.
69752: **
69753: ** This opcode is used to implement the integrity_check pragma.
69754: */
69755: case OP_IntegrityCk: {
69756: #if 0 /* local variables moved into u.bz */
69757: int nRoot; /* Number of tables to check. (Number of root pages.) */
69758: int *aRoot; /* Array of rootpage numbers for tables to be checked */
69759: int j; /* Loop counter */
69760: int nErr; /* Number of errors reported */
69761: char *z; /* Text of the error report */
69762: Mem *pnErr; /* Register keeping track of errors remaining */
69763: #endif /* local variables moved into u.bz */
69764:
69765: u.bz.nRoot = pOp->p2;
69766: assert( u.bz.nRoot>0 );
69767: u.bz.aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(u.bz.nRoot+1) );
69768: if( u.bz.aRoot==0 ) goto no_mem;
69769: assert( pOp->p3>0 && pOp->p3<=p->nMem );
69770: u.bz.pnErr = &aMem[pOp->p3];
69771: assert( (u.bz.pnErr->flags & MEM_Int)!=0 );
69772: assert( (u.bz.pnErr->flags & (MEM_Str|MEM_Blob))==0 );
69773: pIn1 = &aMem[pOp->p1];
69774: for(u.bz.j=0; u.bz.j<u.bz.nRoot; u.bz.j++){
69775: u.bz.aRoot[u.bz.j] = (int)sqlite3VdbeIntValue(&pIn1[u.bz.j]);
69776: }
69777: u.bz.aRoot[u.bz.j] = 0;
69778: assert( pOp->p5<db->nDb );
69779: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p5))!=0 );
69780: u.bz.z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, u.bz.aRoot, u.bz.nRoot,
69781: (int)u.bz.pnErr->u.i, &u.bz.nErr);
69782: sqlite3DbFree(db, u.bz.aRoot);
69783: u.bz.pnErr->u.i -= u.bz.nErr;
69784: sqlite3VdbeMemSetNull(pIn1);
69785: if( u.bz.nErr==0 ){
69786: assert( u.bz.z==0 );
69787: }else if( u.bz.z==0 ){
69788: goto no_mem;
69789: }else{
69790: sqlite3VdbeMemSetStr(pIn1, u.bz.z, -1, SQLITE_UTF8, sqlite3_free);
69791: }
69792: UPDATE_MAX_BLOBSIZE(pIn1);
69793: sqlite3VdbeChangeEncoding(pIn1, encoding);
69794: break;
69795: }
69796: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
69797:
69798: /* Opcode: RowSetAdd P1 P2 * * *
69799: **
69800: ** Insert the integer value held by register P2 into a boolean index
69801: ** held in register P1.
69802: **
69803: ** An assertion fails if P2 is not an integer.
69804: */
69805: case OP_RowSetAdd: { /* in1, in2 */
69806: pIn1 = &aMem[pOp->p1];
69807: pIn2 = &aMem[pOp->p2];
69808: assert( (pIn2->flags & MEM_Int)!=0 );
69809: if( (pIn1->flags & MEM_RowSet)==0 ){
69810: sqlite3VdbeMemSetRowSet(pIn1);
69811: if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
69812: }
69813: sqlite3RowSetInsert(pIn1->u.pRowSet, pIn2->u.i);
69814: break;
69815: }
69816:
69817: /* Opcode: RowSetRead P1 P2 P3 * *
69818: **
69819: ** Extract the smallest value from boolean index P1 and put that value into
69820: ** register P3. Or, if boolean index P1 is initially empty, leave P3
69821: ** unchanged and jump to instruction P2.
69822: */
69823: case OP_RowSetRead: { /* jump, in1, out3 */
69824: #if 0 /* local variables moved into u.ca */
69825: i64 val;
69826: #endif /* local variables moved into u.ca */
69827: CHECK_FOR_INTERRUPT;
69828: pIn1 = &aMem[pOp->p1];
69829: if( (pIn1->flags & MEM_RowSet)==0
69830: || sqlite3RowSetNext(pIn1->u.pRowSet, &u.ca.val)==0
69831: ){
69832: /* The boolean index is empty */
69833: sqlite3VdbeMemSetNull(pIn1);
69834: pc = pOp->p2 - 1;
69835: }else{
69836: /* A value was pulled from the index */
69837: sqlite3VdbeMemSetInt64(&aMem[pOp->p3], u.ca.val);
69838: }
69839: break;
69840: }
69841:
69842: /* Opcode: RowSetTest P1 P2 P3 P4
69843: **
69844: ** Register P3 is assumed to hold a 64-bit integer value. If register P1
69845: ** contains a RowSet object and that RowSet object contains
69846: ** the value held in P3, jump to register P2. Otherwise, insert the
69847: ** integer in P3 into the RowSet and continue on to the
69848: ** next opcode.
69849: **
69850: ** The RowSet object is optimized for the case where successive sets
69851: ** of integers, where each set contains no duplicates. Each set
69852: ** of values is identified by a unique P4 value. The first set
69853: ** must have P4==0, the final set P4=-1. P4 must be either -1 or
69854: ** non-negative. For non-negative values of P4 only the lower 4
69855: ** bits are significant.
69856: **
69857: ** This allows optimizations: (a) when P4==0 there is no need to test
69858: ** the rowset object for P3, as it is guaranteed not to contain it,
69859: ** (b) when P4==-1 there is no need to insert the value, as it will
69860: ** never be tested for, and (c) when a value that is part of set X is
69861: ** inserted, there is no need to search to see if the same value was
69862: ** previously inserted as part of set X (only if it was previously
69863: ** inserted as part of some other set).
69864: */
69865: case OP_RowSetTest: { /* jump, in1, in3 */
69866: #if 0 /* local variables moved into u.cb */
69867: int iSet;
69868: int exists;
69869: #endif /* local variables moved into u.cb */
69870:
69871: pIn1 = &aMem[pOp->p1];
69872: pIn3 = &aMem[pOp->p3];
69873: u.cb.iSet = pOp->p4.i;
69874: assert( pIn3->flags&MEM_Int );
69875:
69876: /* If there is anything other than a rowset object in memory cell P1,
69877: ** delete it now and initialize P1 with an empty rowset
69878: */
69879: if( (pIn1->flags & MEM_RowSet)==0 ){
69880: sqlite3VdbeMemSetRowSet(pIn1);
69881: if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
69882: }
69883:
69884: assert( pOp->p4type==P4_INT32 );
69885: assert( u.cb.iSet==-1 || u.cb.iSet>=0 );
69886: if( u.cb.iSet ){
69887: u.cb.exists = sqlite3RowSetTest(pIn1->u.pRowSet,
69888: (u8)(u.cb.iSet>=0 ? u.cb.iSet & 0xf : 0xff),
69889: pIn3->u.i);
69890: if( u.cb.exists ){
69891: pc = pOp->p2 - 1;
69892: break;
69893: }
69894: }
69895: if( u.cb.iSet>=0 ){
69896: sqlite3RowSetInsert(pIn1->u.pRowSet, pIn3->u.i);
69897: }
69898: break;
69899: }
69900:
69901:
69902: #ifndef SQLITE_OMIT_TRIGGER
69903:
69904: /* Opcode: Program P1 P2 P3 P4 *
69905: **
69906: ** Execute the trigger program passed as P4 (type P4_SUBPROGRAM).
69907: **
69908: ** P1 contains the address of the memory cell that contains the first memory
69909: ** cell in an array of values used as arguments to the sub-program. P2
69910: ** contains the address to jump to if the sub-program throws an IGNORE
69911: ** exception using the RAISE() function. Register P3 contains the address
69912: ** of a memory cell in this (the parent) VM that is used to allocate the
69913: ** memory required by the sub-vdbe at runtime.
69914: **
69915: ** P4 is a pointer to the VM containing the trigger program.
69916: */
69917: case OP_Program: { /* jump */
69918: #if 0 /* local variables moved into u.cc */
69919: int nMem; /* Number of memory registers for sub-program */
69920: int nByte; /* Bytes of runtime space required for sub-program */
69921: Mem *pRt; /* Register to allocate runtime space */
69922: Mem *pMem; /* Used to iterate through memory cells */
69923: Mem *pEnd; /* Last memory cell in new array */
69924: VdbeFrame *pFrame; /* New vdbe frame to execute in */
69925: SubProgram *pProgram; /* Sub-program to execute */
69926: void *t; /* Token identifying trigger */
69927: #endif /* local variables moved into u.cc */
69928:
69929: u.cc.pProgram = pOp->p4.pProgram;
69930: u.cc.pRt = &aMem[pOp->p3];
69931: assert( u.cc.pProgram->nOp>0 );
69932:
69933: /* If the p5 flag is clear, then recursive invocation of triggers is
69934: ** disabled for backwards compatibility (p5 is set if this sub-program
69935: ** is really a trigger, not a foreign key action, and the flag set
69936: ** and cleared by the "PRAGMA recursive_triggers" command is clear).
69937: **
69938: ** It is recursive invocation of triggers, at the SQL level, that is
69939: ** disabled. In some cases a single trigger may generate more than one
69940: ** SubProgram (if the trigger may be executed with more than one different
69941: ** ON CONFLICT algorithm). SubProgram structures associated with a
69942: ** single trigger all have the same value for the SubProgram.token
69943: ** variable. */
69944: if( pOp->p5 ){
69945: u.cc.t = u.cc.pProgram->token;
69946: for(u.cc.pFrame=p->pFrame; u.cc.pFrame && u.cc.pFrame->token!=u.cc.t; u.cc.pFrame=u.cc.pFrame->pParent);
69947: if( u.cc.pFrame ) break;
69948: }
69949:
69950: if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){
69951: rc = SQLITE_ERROR;
69952: sqlite3SetString(&p->zErrMsg, db, "too many levels of trigger recursion");
69953: break;
69954: }
69955:
69956: /* Register u.cc.pRt is used to store the memory required to save the state
69957: ** of the current program, and the memory required at runtime to execute
69958: ** the trigger program. If this trigger has been fired before, then u.cc.pRt
69959: ** is already allocated. Otherwise, it must be initialized. */
69960: if( (u.cc.pRt->flags&MEM_Frame)==0 ){
69961: /* SubProgram.nMem is set to the number of memory cells used by the
69962: ** program stored in SubProgram.aOp. As well as these, one memory
69963: ** cell is required for each cursor used by the program. Set local
69964: ** variable u.cc.nMem (and later, VdbeFrame.nChildMem) to this value.
69965: */
69966: u.cc.nMem = u.cc.pProgram->nMem + u.cc.pProgram->nCsr;
69967: u.cc.nByte = ROUND8(sizeof(VdbeFrame))
69968: + u.cc.nMem * sizeof(Mem)
69969: + u.cc.pProgram->nCsr * sizeof(VdbeCursor *)
69970: + u.cc.pProgram->nOnce * sizeof(u8);
69971: u.cc.pFrame = sqlite3DbMallocZero(db, u.cc.nByte);
69972: if( !u.cc.pFrame ){
69973: goto no_mem;
69974: }
69975: sqlite3VdbeMemRelease(u.cc.pRt);
69976: u.cc.pRt->flags = MEM_Frame;
69977: u.cc.pRt->u.pFrame = u.cc.pFrame;
69978:
69979: u.cc.pFrame->v = p;
69980: u.cc.pFrame->nChildMem = u.cc.nMem;
69981: u.cc.pFrame->nChildCsr = u.cc.pProgram->nCsr;
69982: u.cc.pFrame->pc = pc;
69983: u.cc.pFrame->aMem = p->aMem;
69984: u.cc.pFrame->nMem = p->nMem;
69985: u.cc.pFrame->apCsr = p->apCsr;
69986: u.cc.pFrame->nCursor = p->nCursor;
69987: u.cc.pFrame->aOp = p->aOp;
69988: u.cc.pFrame->nOp = p->nOp;
69989: u.cc.pFrame->token = u.cc.pProgram->token;
69990: u.cc.pFrame->aOnceFlag = p->aOnceFlag;
69991: u.cc.pFrame->nOnceFlag = p->nOnceFlag;
69992:
69993: u.cc.pEnd = &VdbeFrameMem(u.cc.pFrame)[u.cc.pFrame->nChildMem];
69994: for(u.cc.pMem=VdbeFrameMem(u.cc.pFrame); u.cc.pMem!=u.cc.pEnd; u.cc.pMem++){
69995: u.cc.pMem->flags = MEM_Invalid;
69996: u.cc.pMem->db = db;
69997: }
69998: }else{
69999: u.cc.pFrame = u.cc.pRt->u.pFrame;
70000: assert( u.cc.pProgram->nMem+u.cc.pProgram->nCsr==u.cc.pFrame->nChildMem );
70001: assert( u.cc.pProgram->nCsr==u.cc.pFrame->nChildCsr );
70002: assert( pc==u.cc.pFrame->pc );
70003: }
70004:
70005: p->nFrame++;
70006: u.cc.pFrame->pParent = p->pFrame;
70007: u.cc.pFrame->lastRowid = lastRowid;
70008: u.cc.pFrame->nChange = p->nChange;
70009: p->nChange = 0;
70010: p->pFrame = u.cc.pFrame;
70011: p->aMem = aMem = &VdbeFrameMem(u.cc.pFrame)[-1];
70012: p->nMem = u.cc.pFrame->nChildMem;
70013: p->nCursor = (u16)u.cc.pFrame->nChildCsr;
70014: p->apCsr = (VdbeCursor **)&aMem[p->nMem+1];
70015: p->aOp = aOp = u.cc.pProgram->aOp;
70016: p->nOp = u.cc.pProgram->nOp;
70017: p->aOnceFlag = (u8 *)&p->apCsr[p->nCursor];
70018: p->nOnceFlag = u.cc.pProgram->nOnce;
70019: p->nOp = u.cc.pProgram->nOp;
70020: pc = -1;
70021: memset(p->aOnceFlag, 0, p->nOnceFlag);
70022:
70023: break;
70024: }
70025:
70026: /* Opcode: Param P1 P2 * * *
70027: **
70028: ** This opcode is only ever present in sub-programs called via the
70029: ** OP_Program instruction. Copy a value currently stored in a memory
70030: ** cell of the calling (parent) frame to cell P2 in the current frames
70031: ** address space. This is used by trigger programs to access the new.*
70032: ** and old.* values.
70033: **
70034: ** The address of the cell in the parent frame is determined by adding
70035: ** the value of the P1 argument to the value of the P1 argument to the
70036: ** calling OP_Program instruction.
70037: */
70038: case OP_Param: { /* out2-prerelease */
70039: #if 0 /* local variables moved into u.cd */
70040: VdbeFrame *pFrame;
70041: Mem *pIn;
70042: #endif /* local variables moved into u.cd */
70043: u.cd.pFrame = p->pFrame;
70044: u.cd.pIn = &u.cd.pFrame->aMem[pOp->p1 + u.cd.pFrame->aOp[u.cd.pFrame->pc].p1];
70045: sqlite3VdbeMemShallowCopy(pOut, u.cd.pIn, MEM_Ephem);
70046: break;
70047: }
70048:
70049: #endif /* #ifndef SQLITE_OMIT_TRIGGER */
70050:
70051: #ifndef SQLITE_OMIT_FOREIGN_KEY
70052: /* Opcode: FkCounter P1 P2 * * *
70053: **
70054: ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
70055: ** If P1 is non-zero, the database constraint counter is incremented
70056: ** (deferred foreign key constraints). Otherwise, if P1 is zero, the
70057: ** statement counter is incremented (immediate foreign key constraints).
70058: */
70059: case OP_FkCounter: {
70060: if( pOp->p1 ){
70061: db->nDeferredCons += pOp->p2;
70062: }else{
70063: p->nFkConstraint += pOp->p2;
70064: }
70065: break;
70066: }
70067:
70068: /* Opcode: FkIfZero P1 P2 * * *
70069: **
70070: ** This opcode tests if a foreign key constraint-counter is currently zero.
70071: ** If so, jump to instruction P2. Otherwise, fall through to the next
70072: ** instruction.
70073: **
70074: ** If P1 is non-zero, then the jump is taken if the database constraint-counter
70075: ** is zero (the one that counts deferred constraint violations). If P1 is
70076: ** zero, the jump is taken if the statement constraint-counter is zero
70077: ** (immediate foreign key constraint violations).
70078: */
70079: case OP_FkIfZero: { /* jump */
70080: if( pOp->p1 ){
70081: if( db->nDeferredCons==0 ) pc = pOp->p2-1;
70082: }else{
70083: if( p->nFkConstraint==0 ) pc = pOp->p2-1;
70084: }
70085: break;
70086: }
70087: #endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */
70088:
70089: #ifndef SQLITE_OMIT_AUTOINCREMENT
70090: /* Opcode: MemMax P1 P2 * * *
70091: **
70092: ** P1 is a register in the root frame of this VM (the root frame is
70093: ** different from the current frame if this instruction is being executed
70094: ** within a sub-program). Set the value of register P1 to the maximum of
70095: ** its current value and the value in register P2.
70096: **
70097: ** This instruction throws an error if the memory cell is not initially
70098: ** an integer.
70099: */
70100: case OP_MemMax: { /* in2 */
70101: #if 0 /* local variables moved into u.ce */
70102: Mem *pIn1;
70103: VdbeFrame *pFrame;
70104: #endif /* local variables moved into u.ce */
70105: if( p->pFrame ){
70106: for(u.ce.pFrame=p->pFrame; u.ce.pFrame->pParent; u.ce.pFrame=u.ce.pFrame->pParent);
70107: u.ce.pIn1 = &u.ce.pFrame->aMem[pOp->p1];
70108: }else{
70109: u.ce.pIn1 = &aMem[pOp->p1];
70110: }
70111: assert( memIsValid(u.ce.pIn1) );
70112: sqlite3VdbeMemIntegerify(u.ce.pIn1);
70113: pIn2 = &aMem[pOp->p2];
70114: sqlite3VdbeMemIntegerify(pIn2);
70115: if( u.ce.pIn1->u.i<pIn2->u.i){
70116: u.ce.pIn1->u.i = pIn2->u.i;
70117: }
70118: break;
70119: }
70120: #endif /* SQLITE_OMIT_AUTOINCREMENT */
70121:
70122: /* Opcode: IfPos P1 P2 * * *
70123: **
70124: ** If the value of register P1 is 1 or greater, jump to P2.
70125: **
70126: ** It is illegal to use this instruction on a register that does
70127: ** not contain an integer. An assertion fault will result if you try.
70128: */
70129: case OP_IfPos: { /* jump, in1 */
70130: pIn1 = &aMem[pOp->p1];
70131: assert( pIn1->flags&MEM_Int );
70132: if( pIn1->u.i>0 ){
70133: pc = pOp->p2 - 1;
70134: }
70135: break;
70136: }
70137:
70138: /* Opcode: IfNeg P1 P2 * * *
70139: **
70140: ** If the value of register P1 is less than zero, jump to P2.
70141: **
70142: ** It is illegal to use this instruction on a register that does
70143: ** not contain an integer. An assertion fault will result if you try.
70144: */
70145: case OP_IfNeg: { /* jump, in1 */
70146: pIn1 = &aMem[pOp->p1];
70147: assert( pIn1->flags&MEM_Int );
70148: if( pIn1->u.i<0 ){
70149: pc = pOp->p2 - 1;
70150: }
70151: break;
70152: }
70153:
70154: /* Opcode: IfZero P1 P2 P3 * *
70155: **
70156: ** The register P1 must contain an integer. Add literal P3 to the
70157: ** value in register P1. If the result is exactly 0, jump to P2.
70158: **
70159: ** It is illegal to use this instruction on a register that does
70160: ** not contain an integer. An assertion fault will result if you try.
70161: */
70162: case OP_IfZero: { /* jump, in1 */
70163: pIn1 = &aMem[pOp->p1];
70164: assert( pIn1->flags&MEM_Int );
70165: pIn1->u.i += pOp->p3;
70166: if( pIn1->u.i==0 ){
70167: pc = pOp->p2 - 1;
70168: }
70169: break;
70170: }
70171:
70172: /* Opcode: AggStep * P2 P3 P4 P5
70173: **
70174: ** Execute the step function for an aggregate. The
70175: ** function has P5 arguments. P4 is a pointer to the FuncDef
70176: ** structure that specifies the function. Use register
70177: ** P3 as the accumulator.
70178: **
70179: ** The P5 arguments are taken from register P2 and its
70180: ** successors.
70181: */
70182: case OP_AggStep: {
70183: #if 0 /* local variables moved into u.cf */
70184: int n;
70185: int i;
70186: Mem *pMem;
70187: Mem *pRec;
70188: sqlite3_context ctx;
70189: sqlite3_value **apVal;
70190: #endif /* local variables moved into u.cf */
70191:
70192: u.cf.n = pOp->p5;
70193: assert( u.cf.n>=0 );
70194: u.cf.pRec = &aMem[pOp->p2];
70195: u.cf.apVal = p->apArg;
70196: assert( u.cf.apVal || u.cf.n==0 );
70197: for(u.cf.i=0; u.cf.i<u.cf.n; u.cf.i++, u.cf.pRec++){
70198: assert( memIsValid(u.cf.pRec) );
70199: u.cf.apVal[u.cf.i] = u.cf.pRec;
70200: memAboutToChange(p, u.cf.pRec);
70201: sqlite3VdbeMemStoreType(u.cf.pRec);
70202: }
70203: u.cf.ctx.pFunc = pOp->p4.pFunc;
70204: assert( pOp->p3>0 && pOp->p3<=p->nMem );
70205: u.cf.ctx.pMem = u.cf.pMem = &aMem[pOp->p3];
70206: u.cf.pMem->n++;
70207: u.cf.ctx.s.flags = MEM_Null;
70208: u.cf.ctx.s.z = 0;
70209: u.cf.ctx.s.zMalloc = 0;
70210: u.cf.ctx.s.xDel = 0;
70211: u.cf.ctx.s.db = db;
70212: u.cf.ctx.isError = 0;
70213: u.cf.ctx.pColl = 0;
70214: if( u.cf.ctx.pFunc->flags & SQLITE_FUNC_NEEDCOLL ){
70215: assert( pOp>p->aOp );
70216: assert( pOp[-1].p4type==P4_COLLSEQ );
70217: assert( pOp[-1].opcode==OP_CollSeq );
70218: u.cf.ctx.pColl = pOp[-1].p4.pColl;
70219: }
70220: (u.cf.ctx.pFunc->xStep)(&u.cf.ctx, u.cf.n, u.cf.apVal); /* IMP: R-24505-23230 */
70221: if( u.cf.ctx.isError ){
70222: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&u.cf.ctx.s));
70223: rc = u.cf.ctx.isError;
70224: }
70225:
70226: sqlite3VdbeMemRelease(&u.cf.ctx.s);
70227:
70228: break;
70229: }
70230:
70231: /* Opcode: AggFinal P1 P2 * P4 *
70232: **
70233: ** Execute the finalizer function for an aggregate. P1 is
70234: ** the memory location that is the accumulator for the aggregate.
70235: **
70236: ** P2 is the number of arguments that the step function takes and
70237: ** P4 is a pointer to the FuncDef for this function. The P2
70238: ** argument is not used by this opcode. It is only there to disambiguate
70239: ** functions that can take varying numbers of arguments. The
70240: ** P4 argument is only needed for the degenerate case where
70241: ** the step function was not previously called.
70242: */
70243: case OP_AggFinal: {
70244: #if 0 /* local variables moved into u.cg */
70245: Mem *pMem;
70246: #endif /* local variables moved into u.cg */
70247: assert( pOp->p1>0 && pOp->p1<=p->nMem );
70248: u.cg.pMem = &aMem[pOp->p1];
70249: assert( (u.cg.pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
70250: rc = sqlite3VdbeMemFinalize(u.cg.pMem, pOp->p4.pFunc);
70251: if( rc ){
70252: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(u.cg.pMem));
70253: }
70254: sqlite3VdbeChangeEncoding(u.cg.pMem, encoding);
70255: UPDATE_MAX_BLOBSIZE(u.cg.pMem);
70256: if( sqlite3VdbeMemTooBig(u.cg.pMem) ){
70257: goto too_big;
70258: }
70259: break;
70260: }
70261:
70262: #ifndef SQLITE_OMIT_WAL
70263: /* Opcode: Checkpoint P1 P2 P3 * *
70264: **
70265: ** Checkpoint database P1. This is a no-op if P1 is not currently in
70266: ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL
70267: ** or RESTART. Write 1 or 0 into mem[P3] if the checkpoint returns
70268: ** SQLITE_BUSY or not, respectively. Write the number of pages in the
70269: ** WAL after the checkpoint into mem[P3+1] and the number of pages
70270: ** in the WAL that have been checkpointed after the checkpoint
70271: ** completes into mem[P3+2]. However on an error, mem[P3+1] and
70272: ** mem[P3+2] are initialized to -1.
70273: */
70274: case OP_Checkpoint: {
70275: #if 0 /* local variables moved into u.ch */
70276: int i; /* Loop counter */
70277: int aRes[3]; /* Results */
70278: Mem *pMem; /* Write results here */
70279: #endif /* local variables moved into u.ch */
70280:
70281: u.ch.aRes[0] = 0;
70282: u.ch.aRes[1] = u.ch.aRes[2] = -1;
70283: assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
70284: || pOp->p2==SQLITE_CHECKPOINT_FULL
70285: || pOp->p2==SQLITE_CHECKPOINT_RESTART
70286: );
70287: rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &u.ch.aRes[1], &u.ch.aRes[2]);
70288: if( rc==SQLITE_BUSY ){
70289: rc = SQLITE_OK;
70290: u.ch.aRes[0] = 1;
70291: }
70292: for(u.ch.i=0, u.ch.pMem = &aMem[pOp->p3]; u.ch.i<3; u.ch.i++, u.ch.pMem++){
70293: sqlite3VdbeMemSetInt64(u.ch.pMem, (i64)u.ch.aRes[u.ch.i]);
70294: }
70295: break;
70296: };
70297: #endif
70298:
70299: #ifndef SQLITE_OMIT_PRAGMA
70300: /* Opcode: JournalMode P1 P2 P3 * P5
70301: **
70302: ** Change the journal mode of database P1 to P3. P3 must be one of the
70303: ** PAGER_JOURNALMODE_XXX values. If changing between the various rollback
70304: ** modes (delete, truncate, persist, off and memory), this is a simple
70305: ** operation. No IO is required.
70306: **
70307: ** If changing into or out of WAL mode the procedure is more complicated.
70308: **
70309: ** Write a string containing the final journal-mode to register P2.
70310: */
70311: case OP_JournalMode: { /* out2-prerelease */
70312: #if 0 /* local variables moved into u.ci */
70313: Btree *pBt; /* Btree to change journal mode of */
70314: Pager *pPager; /* Pager associated with pBt */
70315: int eNew; /* New journal mode */
70316: int eOld; /* The old journal mode */
70317: const char *zFilename; /* Name of database file for pPager */
70318: #endif /* local variables moved into u.ci */
70319:
70320: u.ci.eNew = pOp->p3;
70321: assert( u.ci.eNew==PAGER_JOURNALMODE_DELETE
70322: || u.ci.eNew==PAGER_JOURNALMODE_TRUNCATE
70323: || u.ci.eNew==PAGER_JOURNALMODE_PERSIST
70324: || u.ci.eNew==PAGER_JOURNALMODE_OFF
70325: || u.ci.eNew==PAGER_JOURNALMODE_MEMORY
70326: || u.ci.eNew==PAGER_JOURNALMODE_WAL
70327: || u.ci.eNew==PAGER_JOURNALMODE_QUERY
70328: );
70329: assert( pOp->p1>=0 && pOp->p1<db->nDb );
70330:
70331: u.ci.pBt = db->aDb[pOp->p1].pBt;
70332: u.ci.pPager = sqlite3BtreePager(u.ci.pBt);
70333: u.ci.eOld = sqlite3PagerGetJournalMode(u.ci.pPager);
70334: if( u.ci.eNew==PAGER_JOURNALMODE_QUERY ) u.ci.eNew = u.ci.eOld;
70335: if( !sqlite3PagerOkToChangeJournalMode(u.ci.pPager) ) u.ci.eNew = u.ci.eOld;
70336:
70337: #ifndef SQLITE_OMIT_WAL
70338: u.ci.zFilename = sqlite3PagerFilename(u.ci.pPager);
70339:
70340: /* Do not allow a transition to journal_mode=WAL for a database
70341: ** in temporary storage or if the VFS does not support shared memory
70342: */
70343: if( u.ci.eNew==PAGER_JOURNALMODE_WAL
70344: && (sqlite3Strlen30(u.ci.zFilename)==0 /* Temp file */
70345: || !sqlite3PagerWalSupported(u.ci.pPager)) /* No shared-memory support */
70346: ){
70347: u.ci.eNew = u.ci.eOld;
70348: }
70349:
70350: if( (u.ci.eNew!=u.ci.eOld)
70351: && (u.ci.eOld==PAGER_JOURNALMODE_WAL || u.ci.eNew==PAGER_JOURNALMODE_WAL)
70352: ){
70353: if( !db->autoCommit || db->activeVdbeCnt>1 ){
70354: rc = SQLITE_ERROR;
70355: sqlite3SetString(&p->zErrMsg, db,
70356: "cannot change %s wal mode from within a transaction",
70357: (u.ci.eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
70358: );
70359: break;
70360: }else{
70361:
70362: if( u.ci.eOld==PAGER_JOURNALMODE_WAL ){
70363: /* If leaving WAL mode, close the log file. If successful, the call
70364: ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
70365: ** file. An EXCLUSIVE lock may still be held on the database file
70366: ** after a successful return.
70367: */
70368: rc = sqlite3PagerCloseWal(u.ci.pPager);
70369: if( rc==SQLITE_OK ){
70370: sqlite3PagerSetJournalMode(u.ci.pPager, u.ci.eNew);
70371: }
70372: }else if( u.ci.eOld==PAGER_JOURNALMODE_MEMORY ){
70373: /* Cannot transition directly from MEMORY to WAL. Use mode OFF
70374: ** as an intermediate */
70375: sqlite3PagerSetJournalMode(u.ci.pPager, PAGER_JOURNALMODE_OFF);
70376: }
70377:
70378: /* Open a transaction on the database file. Regardless of the journal
70379: ** mode, this transaction always uses a rollback journal.
70380: */
70381: assert( sqlite3BtreeIsInTrans(u.ci.pBt)==0 );
70382: if( rc==SQLITE_OK ){
70383: rc = sqlite3BtreeSetVersion(u.ci.pBt, (u.ci.eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
70384: }
70385: }
70386: }
70387: #endif /* ifndef SQLITE_OMIT_WAL */
70388:
70389: if( rc ){
70390: u.ci.eNew = u.ci.eOld;
70391: }
70392: u.ci.eNew = sqlite3PagerSetJournalMode(u.ci.pPager, u.ci.eNew);
70393:
70394: pOut = &aMem[pOp->p2];
70395: pOut->flags = MEM_Str|MEM_Static|MEM_Term;
70396: pOut->z = (char *)sqlite3JournalModename(u.ci.eNew);
70397: pOut->n = sqlite3Strlen30(pOut->z);
70398: pOut->enc = SQLITE_UTF8;
70399: sqlite3VdbeChangeEncoding(pOut, encoding);
70400: break;
70401: };
70402: #endif /* SQLITE_OMIT_PRAGMA */
70403:
70404: #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
70405: /* Opcode: Vacuum * * * * *
70406: **
70407: ** Vacuum the entire database. This opcode will cause other virtual
70408: ** machines to be created and run. It may not be called from within
70409: ** a transaction.
70410: */
70411: case OP_Vacuum: {
70412: rc = sqlite3RunVacuum(&p->zErrMsg, db);
70413: break;
70414: }
70415: #endif
70416:
70417: #if !defined(SQLITE_OMIT_AUTOVACUUM)
70418: /* Opcode: IncrVacuum P1 P2 * * *
70419: **
70420: ** Perform a single step of the incremental vacuum procedure on
70421: ** the P1 database. If the vacuum has finished, jump to instruction
70422: ** P2. Otherwise, fall through to the next instruction.
70423: */
70424: case OP_IncrVacuum: { /* jump */
70425: #if 0 /* local variables moved into u.cj */
70426: Btree *pBt;
70427: #endif /* local variables moved into u.cj */
70428:
70429: assert( pOp->p1>=0 && pOp->p1<db->nDb );
70430: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
70431: u.cj.pBt = db->aDb[pOp->p1].pBt;
70432: rc = sqlite3BtreeIncrVacuum(u.cj.pBt);
70433: if( rc==SQLITE_DONE ){
70434: pc = pOp->p2 - 1;
70435: rc = SQLITE_OK;
70436: }
70437: break;
70438: }
70439: #endif
70440:
70441: /* Opcode: Expire P1 * * * *
70442: **
70443: ** Cause precompiled statements to become expired. An expired statement
70444: ** fails with an error code of SQLITE_SCHEMA if it is ever executed
70445: ** (via sqlite3_step()).
70446: **
70447: ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
70448: ** then only the currently executing statement is affected.
70449: */
70450: case OP_Expire: {
70451: if( !pOp->p1 ){
70452: sqlite3ExpirePreparedStatements(db);
70453: }else{
70454: p->expired = 1;
70455: }
70456: break;
70457: }
70458:
70459: #ifndef SQLITE_OMIT_SHARED_CACHE
70460: /* Opcode: TableLock P1 P2 P3 P4 *
70461: **
70462: ** Obtain a lock on a particular table. This instruction is only used when
70463: ** the shared-cache feature is enabled.
70464: **
70465: ** P1 is the index of the database in sqlite3.aDb[] of the database
70466: ** on which the lock is acquired. A readlock is obtained if P3==0 or
70467: ** a write lock if P3==1.
70468: **
70469: ** P2 contains the root-page of the table to lock.
70470: **
70471: ** P4 contains a pointer to the name of the table being locked. This is only
70472: ** used to generate an error message if the lock cannot be obtained.
70473: */
70474: case OP_TableLock: {
70475: u8 isWriteLock = (u8)pOp->p3;
70476: if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommitted) ){
70477: int p1 = pOp->p1;
70478: assert( p1>=0 && p1<db->nDb );
70479: assert( (p->btreeMask & (((yDbMask)1)<<p1))!=0 );
70480: assert( isWriteLock==0 || isWriteLock==1 );
70481: rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
70482: if( (rc&0xFF)==SQLITE_LOCKED ){
70483: const char *z = pOp->p4.z;
70484: sqlite3SetString(&p->zErrMsg, db, "database table is locked: %s", z);
70485: }
70486: }
70487: break;
70488: }
70489: #endif /* SQLITE_OMIT_SHARED_CACHE */
70490:
70491: #ifndef SQLITE_OMIT_VIRTUALTABLE
70492: /* Opcode: VBegin * * * P4 *
70493: **
70494: ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the
70495: ** xBegin method for that table.
70496: **
70497: ** Also, whether or not P4 is set, check that this is not being called from
70498: ** within a callback to a virtual table xSync() method. If it is, the error
70499: ** code will be set to SQLITE_LOCKED.
70500: */
70501: case OP_VBegin: {
70502: #if 0 /* local variables moved into u.ck */
70503: VTable *pVTab;
70504: #endif /* local variables moved into u.ck */
70505: u.ck.pVTab = pOp->p4.pVtab;
70506: rc = sqlite3VtabBegin(db, u.ck.pVTab);
70507: if( u.ck.pVTab ) importVtabErrMsg(p, u.ck.pVTab->pVtab);
70508: break;
70509: }
70510: #endif /* SQLITE_OMIT_VIRTUALTABLE */
70511:
70512: #ifndef SQLITE_OMIT_VIRTUALTABLE
70513: /* Opcode: VCreate P1 * * P4 *
70514: **
70515: ** P4 is the name of a virtual table in database P1. Call the xCreate method
70516: ** for that table.
70517: */
70518: case OP_VCreate: {
70519: rc = sqlite3VtabCallCreate(db, pOp->p1, pOp->p4.z, &p->zErrMsg);
70520: break;
70521: }
70522: #endif /* SQLITE_OMIT_VIRTUALTABLE */
70523:
70524: #ifndef SQLITE_OMIT_VIRTUALTABLE
70525: /* Opcode: VDestroy P1 * * P4 *
70526: **
70527: ** P4 is the name of a virtual table in database P1. Call the xDestroy method
70528: ** of that table.
70529: */
70530: case OP_VDestroy: {
70531: p->inVtabMethod = 2;
70532: rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
70533: p->inVtabMethod = 0;
70534: break;
70535: }
70536: #endif /* SQLITE_OMIT_VIRTUALTABLE */
70537:
70538: #ifndef SQLITE_OMIT_VIRTUALTABLE
70539: /* Opcode: VOpen P1 * * P4 *
70540: **
70541: ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
70542: ** P1 is a cursor number. This opcode opens a cursor to the virtual
70543: ** table and stores that cursor in P1.
70544: */
70545: case OP_VOpen: {
70546: #if 0 /* local variables moved into u.cl */
70547: VdbeCursor *pCur;
70548: sqlite3_vtab_cursor *pVtabCursor;
70549: sqlite3_vtab *pVtab;
70550: sqlite3_module *pModule;
70551: #endif /* local variables moved into u.cl */
70552:
70553: u.cl.pCur = 0;
70554: u.cl.pVtabCursor = 0;
70555: u.cl.pVtab = pOp->p4.pVtab->pVtab;
70556: u.cl.pModule = (sqlite3_module *)u.cl.pVtab->pModule;
70557: assert(u.cl.pVtab && u.cl.pModule);
70558: rc = u.cl.pModule->xOpen(u.cl.pVtab, &u.cl.pVtabCursor);
70559: importVtabErrMsg(p, u.cl.pVtab);
70560: if( SQLITE_OK==rc ){
70561: /* Initialize sqlite3_vtab_cursor base class */
70562: u.cl.pVtabCursor->pVtab = u.cl.pVtab;
70563:
70564: /* Initialise vdbe cursor object */
70565: u.cl.pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
70566: if( u.cl.pCur ){
70567: u.cl.pCur->pVtabCursor = u.cl.pVtabCursor;
70568: u.cl.pCur->pModule = u.cl.pVtabCursor->pVtab->pModule;
70569: }else{
70570: db->mallocFailed = 1;
70571: u.cl.pModule->xClose(u.cl.pVtabCursor);
70572: }
70573: }
70574: break;
70575: }
70576: #endif /* SQLITE_OMIT_VIRTUALTABLE */
70577:
70578: #ifndef SQLITE_OMIT_VIRTUALTABLE
70579: /* Opcode: VFilter P1 P2 P3 P4 *
70580: **
70581: ** P1 is a cursor opened using VOpen. P2 is an address to jump to if
70582: ** the filtered result set is empty.
70583: **
70584: ** P4 is either NULL or a string that was generated by the xBestIndex
70585: ** method of the module. The interpretation of the P4 string is left
70586: ** to the module implementation.
70587: **
70588: ** This opcode invokes the xFilter method on the virtual table specified
70589: ** by P1. The integer query plan parameter to xFilter is stored in register
70590: ** P3. Register P3+1 stores the argc parameter to be passed to the
70591: ** xFilter method. Registers P3+2..P3+1+argc are the argc
70592: ** additional parameters which are passed to
70593: ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
70594: **
70595: ** A jump is made to P2 if the result set after filtering would be empty.
70596: */
70597: case OP_VFilter: { /* jump */
70598: #if 0 /* local variables moved into u.cm */
70599: int nArg;
70600: int iQuery;
70601: const sqlite3_module *pModule;
70602: Mem *pQuery;
70603: Mem *pArgc;
70604: sqlite3_vtab_cursor *pVtabCursor;
70605: sqlite3_vtab *pVtab;
70606: VdbeCursor *pCur;
70607: int res;
70608: int i;
70609: Mem **apArg;
70610: #endif /* local variables moved into u.cm */
70611:
70612: u.cm.pQuery = &aMem[pOp->p3];
70613: u.cm.pArgc = &u.cm.pQuery[1];
70614: u.cm.pCur = p->apCsr[pOp->p1];
70615: assert( memIsValid(u.cm.pQuery) );
70616: REGISTER_TRACE(pOp->p3, u.cm.pQuery);
70617: assert( u.cm.pCur->pVtabCursor );
70618: u.cm.pVtabCursor = u.cm.pCur->pVtabCursor;
70619: u.cm.pVtab = u.cm.pVtabCursor->pVtab;
70620: u.cm.pModule = u.cm.pVtab->pModule;
70621:
70622: /* Grab the index number and argc parameters */
70623: assert( (u.cm.pQuery->flags&MEM_Int)!=0 && u.cm.pArgc->flags==MEM_Int );
70624: u.cm.nArg = (int)u.cm.pArgc->u.i;
70625: u.cm.iQuery = (int)u.cm.pQuery->u.i;
70626:
70627: /* Invoke the xFilter method */
70628: {
70629: u.cm.res = 0;
70630: u.cm.apArg = p->apArg;
70631: for(u.cm.i = 0; u.cm.i<u.cm.nArg; u.cm.i++){
70632: u.cm.apArg[u.cm.i] = &u.cm.pArgc[u.cm.i+1];
70633: sqlite3VdbeMemStoreType(u.cm.apArg[u.cm.i]);
70634: }
70635:
70636: p->inVtabMethod = 1;
70637: rc = u.cm.pModule->xFilter(u.cm.pVtabCursor, u.cm.iQuery, pOp->p4.z, u.cm.nArg, u.cm.apArg);
70638: p->inVtabMethod = 0;
70639: importVtabErrMsg(p, u.cm.pVtab);
70640: if( rc==SQLITE_OK ){
70641: u.cm.res = u.cm.pModule->xEof(u.cm.pVtabCursor);
70642: }
70643:
70644: if( u.cm.res ){
70645: pc = pOp->p2 - 1;
70646: }
70647: }
70648: u.cm.pCur->nullRow = 0;
70649:
70650: break;
70651: }
70652: #endif /* SQLITE_OMIT_VIRTUALTABLE */
70653:
70654: #ifndef SQLITE_OMIT_VIRTUALTABLE
70655: /* Opcode: VColumn P1 P2 P3 * *
70656: **
70657: ** Store the value of the P2-th column of
70658: ** the row of the virtual-table that the
70659: ** P1 cursor is pointing to into register P3.
70660: */
70661: case OP_VColumn: {
70662: #if 0 /* local variables moved into u.cn */
70663: sqlite3_vtab *pVtab;
70664: const sqlite3_module *pModule;
70665: Mem *pDest;
70666: sqlite3_context sContext;
70667: #endif /* local variables moved into u.cn */
70668:
70669: VdbeCursor *pCur = p->apCsr[pOp->p1];
70670: assert( pCur->pVtabCursor );
70671: assert( pOp->p3>0 && pOp->p3<=p->nMem );
70672: u.cn.pDest = &aMem[pOp->p3];
70673: memAboutToChange(p, u.cn.pDest);
70674: if( pCur->nullRow ){
70675: sqlite3VdbeMemSetNull(u.cn.pDest);
70676: break;
70677: }
70678: u.cn.pVtab = pCur->pVtabCursor->pVtab;
70679: u.cn.pModule = u.cn.pVtab->pModule;
70680: assert( u.cn.pModule->xColumn );
70681: memset(&u.cn.sContext, 0, sizeof(u.cn.sContext));
70682:
70683: /* The output cell may already have a buffer allocated. Move
70684: ** the current contents to u.cn.sContext.s so in case the user-function
70685: ** can use the already allocated buffer instead of allocating a
70686: ** new one.
70687: */
70688: sqlite3VdbeMemMove(&u.cn.sContext.s, u.cn.pDest);
70689: MemSetTypeFlag(&u.cn.sContext.s, MEM_Null);
70690:
70691: rc = u.cn.pModule->xColumn(pCur->pVtabCursor, &u.cn.sContext, pOp->p2);
70692: importVtabErrMsg(p, u.cn.pVtab);
70693: if( u.cn.sContext.isError ){
70694: rc = u.cn.sContext.isError;
70695: }
70696:
70697: /* Copy the result of the function to the P3 register. We
70698: ** do this regardless of whether or not an error occurred to ensure any
70699: ** dynamic allocation in u.cn.sContext.s (a Mem struct) is released.
70700: */
70701: sqlite3VdbeChangeEncoding(&u.cn.sContext.s, encoding);
70702: sqlite3VdbeMemMove(u.cn.pDest, &u.cn.sContext.s);
70703: REGISTER_TRACE(pOp->p3, u.cn.pDest);
70704: UPDATE_MAX_BLOBSIZE(u.cn.pDest);
70705:
70706: if( sqlite3VdbeMemTooBig(u.cn.pDest) ){
70707: goto too_big;
70708: }
70709: break;
70710: }
70711: #endif /* SQLITE_OMIT_VIRTUALTABLE */
70712:
70713: #ifndef SQLITE_OMIT_VIRTUALTABLE
70714: /* Opcode: VNext P1 P2 * * *
70715: **
70716: ** Advance virtual table P1 to the next row in its result set and
70717: ** jump to instruction P2. Or, if the virtual table has reached
70718: ** the end of its result set, then fall through to the next instruction.
70719: */
70720: case OP_VNext: { /* jump */
70721: #if 0 /* local variables moved into u.co */
70722: sqlite3_vtab *pVtab;
70723: const sqlite3_module *pModule;
70724: int res;
70725: VdbeCursor *pCur;
70726: #endif /* local variables moved into u.co */
70727:
70728: u.co.res = 0;
70729: u.co.pCur = p->apCsr[pOp->p1];
70730: assert( u.co.pCur->pVtabCursor );
70731: if( u.co.pCur->nullRow ){
70732: break;
70733: }
70734: u.co.pVtab = u.co.pCur->pVtabCursor->pVtab;
70735: u.co.pModule = u.co.pVtab->pModule;
70736: assert( u.co.pModule->xNext );
70737:
70738: /* Invoke the xNext() method of the module. There is no way for the
70739: ** underlying implementation to return an error if one occurs during
70740: ** xNext(). Instead, if an error occurs, true is returned (indicating that
70741: ** data is available) and the error code returned when xColumn or
70742: ** some other method is next invoked on the save virtual table cursor.
70743: */
70744: p->inVtabMethod = 1;
70745: rc = u.co.pModule->xNext(u.co.pCur->pVtabCursor);
70746: p->inVtabMethod = 0;
70747: importVtabErrMsg(p, u.co.pVtab);
70748: if( rc==SQLITE_OK ){
70749: u.co.res = u.co.pModule->xEof(u.co.pCur->pVtabCursor);
70750: }
70751:
70752: if( !u.co.res ){
70753: /* If there is data, jump to P2 */
70754: pc = pOp->p2 - 1;
70755: }
70756: break;
70757: }
70758: #endif /* SQLITE_OMIT_VIRTUALTABLE */
70759:
70760: #ifndef SQLITE_OMIT_VIRTUALTABLE
70761: /* Opcode: VRename P1 * * P4 *
70762: **
70763: ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
70764: ** This opcode invokes the corresponding xRename method. The value
70765: ** in register P1 is passed as the zName argument to the xRename method.
70766: */
70767: case OP_VRename: {
70768: #if 0 /* local variables moved into u.cp */
70769: sqlite3_vtab *pVtab;
70770: Mem *pName;
70771: #endif /* local variables moved into u.cp */
70772:
70773: u.cp.pVtab = pOp->p4.pVtab->pVtab;
70774: u.cp.pName = &aMem[pOp->p1];
70775: assert( u.cp.pVtab->pModule->xRename );
70776: assert( memIsValid(u.cp.pName) );
70777: REGISTER_TRACE(pOp->p1, u.cp.pName);
70778: assert( u.cp.pName->flags & MEM_Str );
70779: testcase( u.cp.pName->enc==SQLITE_UTF8 );
70780: testcase( u.cp.pName->enc==SQLITE_UTF16BE );
70781: testcase( u.cp.pName->enc==SQLITE_UTF16LE );
70782: rc = sqlite3VdbeChangeEncoding(u.cp.pName, SQLITE_UTF8);
70783: if( rc==SQLITE_OK ){
70784: rc = u.cp.pVtab->pModule->xRename(u.cp.pVtab, u.cp.pName->z);
70785: importVtabErrMsg(p, u.cp.pVtab);
70786: p->expired = 0;
70787: }
70788: break;
70789: }
70790: #endif
70791:
70792: #ifndef SQLITE_OMIT_VIRTUALTABLE
70793: /* Opcode: VUpdate P1 P2 P3 P4 *
70794: **
70795: ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
70796: ** This opcode invokes the corresponding xUpdate method. P2 values
70797: ** are contiguous memory cells starting at P3 to pass to the xUpdate
70798: ** invocation. The value in register (P3+P2-1) corresponds to the
70799: ** p2th element of the argv array passed to xUpdate.
70800: **
70801: ** The xUpdate method will do a DELETE or an INSERT or both.
70802: ** The argv[0] element (which corresponds to memory cell P3)
70803: ** is the rowid of a row to delete. If argv[0] is NULL then no
70804: ** deletion occurs. The argv[1] element is the rowid of the new
70805: ** row. This can be NULL to have the virtual table select the new
70806: ** rowid for itself. The subsequent elements in the array are
70807: ** the values of columns in the new row.
70808: **
70809: ** If P2==1 then no insert is performed. argv[0] is the rowid of
70810: ** a row to delete.
70811: **
70812: ** P1 is a boolean flag. If it is set to true and the xUpdate call
70813: ** is successful, then the value returned by sqlite3_last_insert_rowid()
70814: ** is set to the value of the rowid for the row just inserted.
70815: */
70816: case OP_VUpdate: {
70817: #if 0 /* local variables moved into u.cq */
70818: sqlite3_vtab *pVtab;
70819: sqlite3_module *pModule;
70820: int nArg;
70821: int i;
70822: sqlite_int64 rowid;
70823: Mem **apArg;
70824: Mem *pX;
70825: #endif /* local variables moved into u.cq */
70826:
70827: assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
70828: || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
70829: );
70830: u.cq.pVtab = pOp->p4.pVtab->pVtab;
70831: u.cq.pModule = (sqlite3_module *)u.cq.pVtab->pModule;
70832: u.cq.nArg = pOp->p2;
70833: assert( pOp->p4type==P4_VTAB );
70834: if( ALWAYS(u.cq.pModule->xUpdate) ){
70835: u8 vtabOnConflict = db->vtabOnConflict;
70836: u.cq.apArg = p->apArg;
70837: u.cq.pX = &aMem[pOp->p3];
70838: for(u.cq.i=0; u.cq.i<u.cq.nArg; u.cq.i++){
70839: assert( memIsValid(u.cq.pX) );
70840: memAboutToChange(p, u.cq.pX);
70841: sqlite3VdbeMemStoreType(u.cq.pX);
70842: u.cq.apArg[u.cq.i] = u.cq.pX;
70843: u.cq.pX++;
70844: }
70845: db->vtabOnConflict = pOp->p5;
70846: rc = u.cq.pModule->xUpdate(u.cq.pVtab, u.cq.nArg, u.cq.apArg, &u.cq.rowid);
70847: db->vtabOnConflict = vtabOnConflict;
70848: importVtabErrMsg(p, u.cq.pVtab);
70849: if( rc==SQLITE_OK && pOp->p1 ){
70850: assert( u.cq.nArg>1 && u.cq.apArg[0] && (u.cq.apArg[0]->flags&MEM_Null) );
70851: db->lastRowid = lastRowid = u.cq.rowid;
70852: }
70853: if( rc==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
70854: if( pOp->p5==OE_Ignore ){
70855: rc = SQLITE_OK;
70856: }else{
70857: p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
70858: }
70859: }else{
70860: p->nChange++;
70861: }
70862: }
70863: break;
70864: }
70865: #endif /* SQLITE_OMIT_VIRTUALTABLE */
70866:
70867: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
70868: /* Opcode: Pagecount P1 P2 * * *
70869: **
70870: ** Write the current number of pages in database P1 to memory cell P2.
70871: */
70872: case OP_Pagecount: { /* out2-prerelease */
70873: pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
70874: break;
70875: }
70876: #endif
70877:
70878:
70879: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
70880: /* Opcode: MaxPgcnt P1 P2 P3 * *
70881: **
70882: ** Try to set the maximum page count for database P1 to the value in P3.
70883: ** Do not let the maximum page count fall below the current page count and
70884: ** do not change the maximum page count value if P3==0.
70885: **
70886: ** Store the maximum page count after the change in register P2.
70887: */
70888: case OP_MaxPgcnt: { /* out2-prerelease */
70889: unsigned int newMax;
70890: Btree *pBt;
70891:
70892: pBt = db->aDb[pOp->p1].pBt;
70893: newMax = 0;
70894: if( pOp->p3 ){
70895: newMax = sqlite3BtreeLastPage(pBt);
70896: if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3;
70897: }
70898: pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
70899: break;
70900: }
70901: #endif
70902:
70903:
70904: #ifndef SQLITE_OMIT_TRACE
70905: /* Opcode: Trace * * * P4 *
70906: **
70907: ** If tracing is enabled (by the sqlite3_trace()) interface, then
70908: ** the UTF-8 string contained in P4 is emitted on the trace callback.
70909: */
70910: case OP_Trace: {
70911: #if 0 /* local variables moved into u.cr */
70912: char *zTrace;
70913: char *z;
70914: #endif /* local variables moved into u.cr */
70915:
70916: if( db->xTrace && (u.cr.zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 ){
70917: u.cr.z = sqlite3VdbeExpandSql(p, u.cr.zTrace);
70918: db->xTrace(db->pTraceArg, u.cr.z);
70919: sqlite3DbFree(db, u.cr.z);
70920: }
70921: #ifdef SQLITE_DEBUG
70922: if( (db->flags & SQLITE_SqlTrace)!=0
70923: && (u.cr.zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
70924: ){
70925: sqlite3DebugPrintf("SQL-trace: %s\n", u.cr.zTrace);
70926: }
70927: #endif /* SQLITE_DEBUG */
70928: break;
70929: }
70930: #endif
70931:
70932:
70933: /* Opcode: Noop * * * * *
70934: **
70935: ** Do nothing. This instruction is often useful as a jump
70936: ** destination.
70937: */
70938: /*
70939: ** The magic Explain opcode are only inserted when explain==2 (which
70940: ** is to say when the EXPLAIN QUERY PLAN syntax is used.)
70941: ** This opcode records information from the optimizer. It is the
70942: ** the same as a no-op. This opcodesnever appears in a real VM program.
70943: */
70944: default: { /* This is really OP_Noop and OP_Explain */
70945: assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
70946: break;
70947: }
70948:
70949: /*****************************************************************************
70950: ** The cases of the switch statement above this line should all be indented
70951: ** by 6 spaces. But the left-most 6 spaces have been removed to improve the
70952: ** readability. From this point on down, the normal indentation rules are
70953: ** restored.
70954: *****************************************************************************/
70955: }
70956:
70957: #ifdef VDBE_PROFILE
70958: {
70959: u64 elapsed = sqlite3Hwtime() - start;
70960: pOp->cycles += elapsed;
70961: pOp->cnt++;
70962: #if 0
70963: fprintf(stdout, "%10llu ", elapsed);
70964: sqlite3VdbePrintOp(stdout, origPc, &aOp[origPc]);
70965: #endif
70966: }
70967: #endif
70968:
70969: /* The following code adds nothing to the actual functionality
70970: ** of the program. It is only here for testing and debugging.
70971: ** On the other hand, it does burn CPU cycles every time through
70972: ** the evaluator loop. So we can leave it out when NDEBUG is defined.
70973: */
70974: #ifndef NDEBUG
70975: assert( pc>=-1 && pc<p->nOp );
70976:
70977: #ifdef SQLITE_DEBUG
70978: if( p->trace ){
70979: if( rc!=0 ) fprintf(p->trace,"rc=%d\n",rc);
70980: if( pOp->opflags & (OPFLG_OUT2_PRERELEASE|OPFLG_OUT2) ){
70981: registerTrace(p->trace, pOp->p2, &aMem[pOp->p2]);
70982: }
70983: if( pOp->opflags & OPFLG_OUT3 ){
70984: registerTrace(p->trace, pOp->p3, &aMem[pOp->p3]);
70985: }
70986: }
70987: #endif /* SQLITE_DEBUG */
70988: #endif /* NDEBUG */
70989: } /* The end of the for(;;) loop the loops through opcodes */
70990:
70991: /* If we reach this point, it means that execution is finished with
70992: ** an error of some kind.
70993: */
70994: vdbe_error_halt:
70995: assert( rc );
70996: p->rc = rc;
70997: testcase( sqlite3GlobalConfig.xLog!=0 );
70998: sqlite3_log(rc, "statement aborts at %d: [%s] %s",
70999: pc, p->zSql, p->zErrMsg);
71000: sqlite3VdbeHalt(p);
71001: if( rc==SQLITE_IOERR_NOMEM ) db->mallocFailed = 1;
71002: rc = SQLITE_ERROR;
71003: if( resetSchemaOnFault>0 ){
71004: sqlite3ResetInternalSchema(db, resetSchemaOnFault-1);
71005: }
71006:
71007: /* This is the only way out of this procedure. We have to
71008: ** release the mutexes on btrees that were acquired at the
71009: ** top. */
71010: vdbe_return:
71011: db->lastRowid = lastRowid;
71012: sqlite3VdbeLeave(p);
71013: return rc;
71014:
71015: /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
71016: ** is encountered.
71017: */
71018: too_big:
71019: sqlite3SetString(&p->zErrMsg, db, "string or blob too big");
71020: rc = SQLITE_TOOBIG;
71021: goto vdbe_error_halt;
71022:
71023: /* Jump to here if a malloc() fails.
71024: */
71025: no_mem:
71026: db->mallocFailed = 1;
71027: sqlite3SetString(&p->zErrMsg, db, "out of memory");
71028: rc = SQLITE_NOMEM;
71029: goto vdbe_error_halt;
71030:
71031: /* Jump to here for any other kind of fatal error. The "rc" variable
71032: ** should hold the error number.
71033: */
71034: abort_due_to_error:
71035: assert( p->zErrMsg==0 );
71036: if( db->mallocFailed ) rc = SQLITE_NOMEM;
71037: if( rc!=SQLITE_IOERR_NOMEM ){
71038: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(rc));
71039: }
71040: goto vdbe_error_halt;
71041:
71042: /* Jump to here if the sqlite3_interrupt() API sets the interrupt
71043: ** flag.
71044: */
71045: abort_due_to_interrupt:
71046: assert( db->u1.isInterrupted );
71047: rc = SQLITE_INTERRUPT;
71048: p->rc = rc;
71049: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(rc));
71050: goto vdbe_error_halt;
71051: }
71052:
71053: /************** End of vdbe.c ************************************************/
71054: /************** Begin file vdbeblob.c ****************************************/
71055: /*
71056: ** 2007 May 1
71057: **
71058: ** The author disclaims copyright to this source code. In place of
71059: ** a legal notice, here is a blessing:
71060: **
71061: ** May you do good and not evil.
71062: ** May you find forgiveness for yourself and forgive others.
71063: ** May you share freely, never taking more than you give.
71064: **
71065: *************************************************************************
71066: **
71067: ** This file contains code used to implement incremental BLOB I/O.
71068: */
71069:
71070:
71071: #ifndef SQLITE_OMIT_INCRBLOB
71072:
71073: /*
71074: ** Valid sqlite3_blob* handles point to Incrblob structures.
71075: */
71076: typedef struct Incrblob Incrblob;
71077: struct Incrblob {
71078: int flags; /* Copy of "flags" passed to sqlite3_blob_open() */
71079: int nByte; /* Size of open blob, in bytes */
71080: int iOffset; /* Byte offset of blob in cursor data */
71081: int iCol; /* Table column this handle is open on */
71082: BtCursor *pCsr; /* Cursor pointing at blob row */
71083: sqlite3_stmt *pStmt; /* Statement holding cursor open */
71084: sqlite3 *db; /* The associated database */
71085: };
71086:
71087:
71088: /*
71089: ** This function is used by both blob_open() and blob_reopen(). It seeks
71090: ** the b-tree cursor associated with blob handle p to point to row iRow.
71091: ** If successful, SQLITE_OK is returned and subsequent calls to
71092: ** sqlite3_blob_read() or sqlite3_blob_write() access the specified row.
71093: **
71094: ** If an error occurs, or if the specified row does not exist or does not
71095: ** contain a value of type TEXT or BLOB in the column nominated when the
71096: ** blob handle was opened, then an error code is returned and *pzErr may
71097: ** be set to point to a buffer containing an error message. It is the
71098: ** responsibility of the caller to free the error message buffer using
71099: ** sqlite3DbFree().
71100: **
71101: ** If an error does occur, then the b-tree cursor is closed. All subsequent
71102: ** calls to sqlite3_blob_read(), blob_write() or blob_reopen() will
71103: ** immediately return SQLITE_ABORT.
71104: */
71105: static int blobSeekToRow(Incrblob *p, sqlite3_int64 iRow, char **pzErr){
71106: int rc; /* Error code */
71107: char *zErr = 0; /* Error message */
71108: Vdbe *v = (Vdbe *)p->pStmt;
71109:
71110: /* Set the value of the SQL statements only variable to integer iRow.
71111: ** This is done directly instead of using sqlite3_bind_int64() to avoid
71112: ** triggering asserts related to mutexes.
71113: */
71114: assert( v->aVar[0].flags&MEM_Int );
71115: v->aVar[0].u.i = iRow;
71116:
71117: rc = sqlite3_step(p->pStmt);
71118: if( rc==SQLITE_ROW ){
71119: u32 type = v->apCsr[0]->aType[p->iCol];
71120: if( type<12 ){
71121: zErr = sqlite3MPrintf(p->db, "cannot open value of type %s",
71122: type==0?"null": type==7?"real": "integer"
71123: );
71124: rc = SQLITE_ERROR;
71125: sqlite3_finalize(p->pStmt);
71126: p->pStmt = 0;
71127: }else{
71128: p->iOffset = v->apCsr[0]->aOffset[p->iCol];
71129: p->nByte = sqlite3VdbeSerialTypeLen(type);
71130: p->pCsr = v->apCsr[0]->pCursor;
71131: sqlite3BtreeEnterCursor(p->pCsr);
71132: sqlite3BtreeCacheOverflow(p->pCsr);
71133: sqlite3BtreeLeaveCursor(p->pCsr);
71134: }
71135: }
71136:
71137: if( rc==SQLITE_ROW ){
71138: rc = SQLITE_OK;
71139: }else if( p->pStmt ){
71140: rc = sqlite3_finalize(p->pStmt);
71141: p->pStmt = 0;
71142: if( rc==SQLITE_OK ){
71143: zErr = sqlite3MPrintf(p->db, "no such rowid: %lld", iRow);
71144: rc = SQLITE_ERROR;
71145: }else{
71146: zErr = sqlite3MPrintf(p->db, "%s", sqlite3_errmsg(p->db));
71147: }
71148: }
71149:
71150: assert( rc!=SQLITE_OK || zErr==0 );
71151: assert( rc!=SQLITE_ROW && rc!=SQLITE_DONE );
71152:
71153: *pzErr = zErr;
71154: return rc;
71155: }
71156:
71157: /*
71158: ** Open a blob handle.
71159: */
71160: SQLITE_API int sqlite3_blob_open(
71161: sqlite3* db, /* The database connection */
71162: const char *zDb, /* The attached database containing the blob */
71163: const char *zTable, /* The table containing the blob */
71164: const char *zColumn, /* The column containing the blob */
71165: sqlite_int64 iRow, /* The row containing the glob */
71166: int flags, /* True -> read/write access, false -> read-only */
71167: sqlite3_blob **ppBlob /* Handle for accessing the blob returned here */
71168: ){
71169: int nAttempt = 0;
71170: int iCol; /* Index of zColumn in row-record */
71171:
71172: /* This VDBE program seeks a btree cursor to the identified
71173: ** db/table/row entry. The reason for using a vdbe program instead
71174: ** of writing code to use the b-tree layer directly is that the
71175: ** vdbe program will take advantage of the various transaction,
71176: ** locking and error handling infrastructure built into the vdbe.
71177: **
71178: ** After seeking the cursor, the vdbe executes an OP_ResultRow.
71179: ** Code external to the Vdbe then "borrows" the b-tree cursor and
71180: ** uses it to implement the blob_read(), blob_write() and
71181: ** blob_bytes() functions.
71182: **
71183: ** The sqlite3_blob_close() function finalizes the vdbe program,
71184: ** which closes the b-tree cursor and (possibly) commits the
71185: ** transaction.
71186: */
71187: static const VdbeOpList openBlob[] = {
71188: {OP_Transaction, 0, 0, 0}, /* 0: Start a transaction */
71189: {OP_VerifyCookie, 0, 0, 0}, /* 1: Check the schema cookie */
71190: {OP_TableLock, 0, 0, 0}, /* 2: Acquire a read or write lock */
71191:
71192: /* One of the following two instructions is replaced by an OP_Noop. */
71193: {OP_OpenRead, 0, 0, 0}, /* 3: Open cursor 0 for reading */
71194: {OP_OpenWrite, 0, 0, 0}, /* 4: Open cursor 0 for read/write */
71195:
71196: {OP_Variable, 1, 1, 1}, /* 5: Push the rowid to the stack */
71197: {OP_NotExists, 0, 10, 1}, /* 6: Seek the cursor */
71198: {OP_Column, 0, 0, 1}, /* 7 */
71199: {OP_ResultRow, 1, 0, 0}, /* 8 */
71200: {OP_Goto, 0, 5, 0}, /* 9 */
71201: {OP_Close, 0, 0, 0}, /* 10 */
71202: {OP_Halt, 0, 0, 0}, /* 11 */
71203: };
71204:
71205: int rc = SQLITE_OK;
71206: char *zErr = 0;
71207: Table *pTab;
71208: Parse *pParse = 0;
71209: Incrblob *pBlob = 0;
71210:
71211: flags = !!flags; /* flags = (flags ? 1 : 0); */
71212: *ppBlob = 0;
71213:
71214: sqlite3_mutex_enter(db->mutex);
71215:
71216: pBlob = (Incrblob *)sqlite3DbMallocZero(db, sizeof(Incrblob));
71217: if( !pBlob ) goto blob_open_out;
71218: pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
71219: if( !pParse ) goto blob_open_out;
71220:
71221: do {
71222: memset(pParse, 0, sizeof(Parse));
71223: pParse->db = db;
71224: sqlite3DbFree(db, zErr);
71225: zErr = 0;
71226:
71227: sqlite3BtreeEnterAll(db);
71228: pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
71229: if( pTab && IsVirtual(pTab) ){
71230: pTab = 0;
71231: sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
71232: }
71233: #ifndef SQLITE_OMIT_VIEW
71234: if( pTab && pTab->pSelect ){
71235: pTab = 0;
71236: sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
71237: }
71238: #endif
71239: if( !pTab ){
71240: if( pParse->zErrMsg ){
71241: sqlite3DbFree(db, zErr);
71242: zErr = pParse->zErrMsg;
71243: pParse->zErrMsg = 0;
71244: }
71245: rc = SQLITE_ERROR;
71246: sqlite3BtreeLeaveAll(db);
71247: goto blob_open_out;
71248: }
71249:
71250: /* Now search pTab for the exact column. */
71251: for(iCol=0; iCol<pTab->nCol; iCol++) {
71252: if( sqlite3StrICmp(pTab->aCol[iCol].zName, zColumn)==0 ){
71253: break;
71254: }
71255: }
71256: if( iCol==pTab->nCol ){
71257: sqlite3DbFree(db, zErr);
71258: zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
71259: rc = SQLITE_ERROR;
71260: sqlite3BtreeLeaveAll(db);
71261: goto blob_open_out;
71262: }
71263:
71264: /* If the value is being opened for writing, check that the
71265: ** column is not indexed, and that it is not part of a foreign key.
71266: ** It is against the rules to open a column to which either of these
71267: ** descriptions applies for writing. */
71268: if( flags ){
71269: const char *zFault = 0;
71270: Index *pIdx;
71271: #ifndef SQLITE_OMIT_FOREIGN_KEY
71272: if( db->flags&SQLITE_ForeignKeys ){
71273: /* Check that the column is not part of an FK child key definition. It
71274: ** is not necessary to check if it is part of a parent key, as parent
71275: ** key columns must be indexed. The check below will pick up this
71276: ** case. */
71277: FKey *pFKey;
71278: for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
71279: int j;
71280: for(j=0; j<pFKey->nCol; j++){
71281: if( pFKey->aCol[j].iFrom==iCol ){
71282: zFault = "foreign key";
71283: }
71284: }
71285: }
71286: }
71287: #endif
71288: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
71289: int j;
71290: for(j=0; j<pIdx->nColumn; j++){
71291: if( pIdx->aiColumn[j]==iCol ){
71292: zFault = "indexed";
71293: }
71294: }
71295: }
71296: if( zFault ){
71297: sqlite3DbFree(db, zErr);
71298: zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
71299: rc = SQLITE_ERROR;
71300: sqlite3BtreeLeaveAll(db);
71301: goto blob_open_out;
71302: }
71303: }
71304:
71305: pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(db);
71306: assert( pBlob->pStmt || db->mallocFailed );
71307: if( pBlob->pStmt ){
71308: Vdbe *v = (Vdbe *)pBlob->pStmt;
71309: int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
71310:
71311: sqlite3VdbeAddOpList(v, sizeof(openBlob)/sizeof(VdbeOpList), openBlob);
71312:
71313:
71314: /* Configure the OP_Transaction */
71315: sqlite3VdbeChangeP1(v, 0, iDb);
71316: sqlite3VdbeChangeP2(v, 0, flags);
71317:
71318: /* Configure the OP_VerifyCookie */
71319: sqlite3VdbeChangeP1(v, 1, iDb);
71320: sqlite3VdbeChangeP2(v, 1, pTab->pSchema->schema_cookie);
71321: sqlite3VdbeChangeP3(v, 1, pTab->pSchema->iGeneration);
71322:
71323: /* Make sure a mutex is held on the table to be accessed */
71324: sqlite3VdbeUsesBtree(v, iDb);
71325:
71326: /* Configure the OP_TableLock instruction */
71327: #ifdef SQLITE_OMIT_SHARED_CACHE
71328: sqlite3VdbeChangeToNoop(v, 2);
71329: #else
71330: sqlite3VdbeChangeP1(v, 2, iDb);
71331: sqlite3VdbeChangeP2(v, 2, pTab->tnum);
71332: sqlite3VdbeChangeP3(v, 2, flags);
71333: sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
71334: #endif
71335:
71336: /* Remove either the OP_OpenWrite or OpenRead. Set the P2
71337: ** parameter of the other to pTab->tnum. */
71338: sqlite3VdbeChangeToNoop(v, 4 - flags);
71339: sqlite3VdbeChangeP2(v, 3 + flags, pTab->tnum);
71340: sqlite3VdbeChangeP3(v, 3 + flags, iDb);
71341:
71342: /* Configure the number of columns. Configure the cursor to
71343: ** think that the table has one more column than it really
71344: ** does. An OP_Column to retrieve this imaginary column will
71345: ** always return an SQL NULL. This is useful because it means
71346: ** we can invoke OP_Column to fill in the vdbe cursors type
71347: ** and offset cache without causing any IO.
71348: */
71349: sqlite3VdbeChangeP4(v, 3+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
71350: sqlite3VdbeChangeP2(v, 7, pTab->nCol);
71351: if( !db->mallocFailed ){
71352: pParse->nVar = 1;
71353: pParse->nMem = 1;
71354: pParse->nTab = 1;
71355: sqlite3VdbeMakeReady(v, pParse);
71356: }
71357: }
71358:
71359: pBlob->flags = flags;
71360: pBlob->iCol = iCol;
71361: pBlob->db = db;
71362: sqlite3BtreeLeaveAll(db);
71363: if( db->mallocFailed ){
71364: goto blob_open_out;
71365: }
71366: sqlite3_bind_int64(pBlob->pStmt, 1, iRow);
71367: rc = blobSeekToRow(pBlob, iRow, &zErr);
71368: } while( (++nAttempt)<5 && rc==SQLITE_SCHEMA );
71369:
71370: blob_open_out:
71371: if( rc==SQLITE_OK && db->mallocFailed==0 ){
71372: *ppBlob = (sqlite3_blob *)pBlob;
71373: }else{
71374: if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
71375: sqlite3DbFree(db, pBlob);
71376: }
71377: sqlite3Error(db, rc, (zErr ? "%s" : 0), zErr);
71378: sqlite3DbFree(db, zErr);
71379: sqlite3StackFree(db, pParse);
71380: rc = sqlite3ApiExit(db, rc);
71381: sqlite3_mutex_leave(db->mutex);
71382: return rc;
71383: }
71384:
71385: /*
71386: ** Close a blob handle that was previously created using
71387: ** sqlite3_blob_open().
71388: */
71389: SQLITE_API int sqlite3_blob_close(sqlite3_blob *pBlob){
71390: Incrblob *p = (Incrblob *)pBlob;
71391: int rc;
71392: sqlite3 *db;
71393:
71394: if( p ){
71395: db = p->db;
71396: sqlite3_mutex_enter(db->mutex);
71397: rc = sqlite3_finalize(p->pStmt);
71398: sqlite3DbFree(db, p);
71399: sqlite3_mutex_leave(db->mutex);
71400: }else{
71401: rc = SQLITE_OK;
71402: }
71403: return rc;
71404: }
71405:
71406: /*
71407: ** Perform a read or write operation on a blob
71408: */
71409: static int blobReadWrite(
71410: sqlite3_blob *pBlob,
71411: void *z,
71412: int n,
71413: int iOffset,
71414: int (*xCall)(BtCursor*, u32, u32, void*)
71415: ){
71416: int rc;
71417: Incrblob *p = (Incrblob *)pBlob;
71418: Vdbe *v;
71419: sqlite3 *db;
71420:
71421: if( p==0 ) return SQLITE_MISUSE_BKPT;
71422: db = p->db;
71423: sqlite3_mutex_enter(db->mutex);
71424: v = (Vdbe*)p->pStmt;
71425:
71426: if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
71427: /* Request is out of range. Return a transient error. */
71428: rc = SQLITE_ERROR;
71429: sqlite3Error(db, SQLITE_ERROR, 0);
71430: }else if( v==0 ){
71431: /* If there is no statement handle, then the blob-handle has
71432: ** already been invalidated. Return SQLITE_ABORT in this case.
71433: */
71434: rc = SQLITE_ABORT;
71435: }else{
71436: /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
71437: ** returned, clean-up the statement handle.
71438: */
71439: assert( db == v->db );
71440: sqlite3BtreeEnterCursor(p->pCsr);
71441: rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
71442: sqlite3BtreeLeaveCursor(p->pCsr);
71443: if( rc==SQLITE_ABORT ){
71444: sqlite3VdbeFinalize(v);
71445: p->pStmt = 0;
71446: }else{
71447: db->errCode = rc;
71448: v->rc = rc;
71449: }
71450: }
71451: rc = sqlite3ApiExit(db, rc);
71452: sqlite3_mutex_leave(db->mutex);
71453: return rc;
71454: }
71455:
71456: /*
71457: ** Read data from a blob handle.
71458: */
71459: SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
71460: return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
71461: }
71462:
71463: /*
71464: ** Write data to a blob handle.
71465: */
71466: SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
71467: return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
71468: }
71469:
71470: /*
71471: ** Query a blob handle for the size of the data.
71472: **
71473: ** The Incrblob.nByte field is fixed for the lifetime of the Incrblob
71474: ** so no mutex is required for access.
71475: */
71476: SQLITE_API int sqlite3_blob_bytes(sqlite3_blob *pBlob){
71477: Incrblob *p = (Incrblob *)pBlob;
71478: return (p && p->pStmt) ? p->nByte : 0;
71479: }
71480:
71481: /*
71482: ** Move an existing blob handle to point to a different row of the same
71483: ** database table.
71484: **
71485: ** If an error occurs, or if the specified row does not exist or does not
71486: ** contain a blob or text value, then an error code is returned and the
71487: ** database handle error code and message set. If this happens, then all
71488: ** subsequent calls to sqlite3_blob_xxx() functions (except blob_close())
71489: ** immediately return SQLITE_ABORT.
71490: */
71491: SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){
71492: int rc;
71493: Incrblob *p = (Incrblob *)pBlob;
71494: sqlite3 *db;
71495:
71496: if( p==0 ) return SQLITE_MISUSE_BKPT;
71497: db = p->db;
71498: sqlite3_mutex_enter(db->mutex);
71499:
71500: if( p->pStmt==0 ){
71501: /* If there is no statement handle, then the blob-handle has
71502: ** already been invalidated. Return SQLITE_ABORT in this case.
71503: */
71504: rc = SQLITE_ABORT;
71505: }else{
71506: char *zErr;
71507: rc = blobSeekToRow(p, iRow, &zErr);
71508: if( rc!=SQLITE_OK ){
71509: sqlite3Error(db, rc, (zErr ? "%s" : 0), zErr);
71510: sqlite3DbFree(db, zErr);
71511: }
71512: assert( rc!=SQLITE_SCHEMA );
71513: }
71514:
71515: rc = sqlite3ApiExit(db, rc);
71516: assert( rc==SQLITE_OK || p->pStmt==0 );
71517: sqlite3_mutex_leave(db->mutex);
71518: return rc;
71519: }
71520:
71521: #endif /* #ifndef SQLITE_OMIT_INCRBLOB */
71522:
71523: /************** End of vdbeblob.c ********************************************/
71524: /************** Begin file vdbesort.c ****************************************/
71525: /*
71526: ** 2011 July 9
71527: **
71528: ** The author disclaims copyright to this source code. In place of
71529: ** a legal notice, here is a blessing:
71530: **
71531: ** May you do good and not evil.
71532: ** May you find forgiveness for yourself and forgive others.
71533: ** May you share freely, never taking more than you give.
71534: **
71535: *************************************************************************
71536: ** This file contains code for the VdbeSorter object, used in concert with
71537: ** a VdbeCursor to sort large numbers of keys (as may be required, for
71538: ** example, by CREATE INDEX statements on tables too large to fit in main
71539: ** memory).
71540: */
71541:
71542:
71543: #ifndef SQLITE_OMIT_MERGE_SORT
71544:
71545: typedef struct VdbeSorterIter VdbeSorterIter;
71546: typedef struct SorterRecord SorterRecord;
71547:
71548: /*
71549: ** NOTES ON DATA STRUCTURE USED FOR N-WAY MERGES:
71550: **
71551: ** As keys are added to the sorter, they are written to disk in a series
71552: ** of sorted packed-memory-arrays (PMAs). The size of each PMA is roughly
71553: ** the same as the cache-size allowed for temporary databases. In order
71554: ** to allow the caller to extract keys from the sorter in sorted order,
71555: ** all PMAs currently stored on disk must be merged together. This comment
71556: ** describes the data structure used to do so. The structure supports
71557: ** merging any number of arrays in a single pass with no redundant comparison
71558: ** operations.
71559: **
71560: ** The aIter[] array contains an iterator for each of the PMAs being merged.
71561: ** An aIter[] iterator either points to a valid key or else is at EOF. For
71562: ** the purposes of the paragraphs below, we assume that the array is actually
71563: ** N elements in size, where N is the smallest power of 2 greater to or equal
71564: ** to the number of iterators being merged. The extra aIter[] elements are
71565: ** treated as if they are empty (always at EOF).
71566: **
71567: ** The aTree[] array is also N elements in size. The value of N is stored in
71568: ** the VdbeSorter.nTree variable.
71569: **
71570: ** The final (N/2) elements of aTree[] contain the results of comparing
71571: ** pairs of iterator keys together. Element i contains the result of
71572: ** comparing aIter[2*i-N] and aIter[2*i-N+1]. Whichever key is smaller, the
71573: ** aTree element is set to the index of it.
71574: **
71575: ** For the purposes of this comparison, EOF is considered greater than any
71576: ** other key value. If the keys are equal (only possible with two EOF
71577: ** values), it doesn't matter which index is stored.
71578: **
71579: ** The (N/4) elements of aTree[] that preceed the final (N/2) described
71580: ** above contains the index of the smallest of each block of 4 iterators.
71581: ** And so on. So that aTree[1] contains the index of the iterator that
71582: ** currently points to the smallest key value. aTree[0] is unused.
71583: **
71584: ** Example:
71585: **
71586: ** aIter[0] -> Banana
71587: ** aIter[1] -> Feijoa
71588: ** aIter[2] -> Elderberry
71589: ** aIter[3] -> Currant
71590: ** aIter[4] -> Grapefruit
71591: ** aIter[5] -> Apple
71592: ** aIter[6] -> Durian
71593: ** aIter[7] -> EOF
71594: **
71595: ** aTree[] = { X, 5 0, 5 0, 3, 5, 6 }
71596: **
71597: ** The current element is "Apple" (the value of the key indicated by
71598: ** iterator 5). When the Next() operation is invoked, iterator 5 will
71599: ** be advanced to the next key in its segment. Say the next key is
71600: ** "Eggplant":
71601: **
71602: ** aIter[5] -> Eggplant
71603: **
71604: ** The contents of aTree[] are updated first by comparing the new iterator
71605: ** 5 key to the current key of iterator 4 (still "Grapefruit"). The iterator
71606: ** 5 value is still smaller, so aTree[6] is set to 5. And so on up the tree.
71607: ** The value of iterator 6 - "Durian" - is now smaller than that of iterator
71608: ** 5, so aTree[3] is set to 6. Key 0 is smaller than key 6 (Banana<Durian),
71609: ** so the value written into element 1 of the array is 0. As follows:
71610: **
71611: ** aTree[] = { X, 0 0, 6 0, 3, 5, 6 }
71612: **
71613: ** In other words, each time we advance to the next sorter element, log2(N)
71614: ** key comparison operations are required, where N is the number of segments
71615: ** being merged (rounded up to the next power of 2).
71616: */
71617: struct VdbeSorter {
71618: int nInMemory; /* Current size of pRecord list as PMA */
71619: int nTree; /* Used size of aTree/aIter (power of 2) */
71620: VdbeSorterIter *aIter; /* Array of iterators to merge */
71621: int *aTree; /* Current state of incremental merge */
71622: i64 iWriteOff; /* Current write offset within file pTemp1 */
71623: i64 iReadOff; /* Current read offset within file pTemp1 */
71624: sqlite3_file *pTemp1; /* PMA file 1 */
71625: int nPMA; /* Number of PMAs stored in pTemp1 */
71626: SorterRecord *pRecord; /* Head of in-memory record list */
71627: int mnPmaSize; /* Minimum PMA size, in bytes */
71628: int mxPmaSize; /* Maximum PMA size, in bytes. 0==no limit */
71629: UnpackedRecord *pUnpacked; /* Used to unpack keys */
71630: };
71631:
71632: /*
71633: ** The following type is an iterator for a PMA. It caches the current key in
71634: ** variables nKey/aKey. If the iterator is at EOF, pFile==0.
71635: */
71636: struct VdbeSorterIter {
71637: i64 iReadOff; /* Current read offset */
71638: i64 iEof; /* 1 byte past EOF for this iterator */
71639: sqlite3_file *pFile; /* File iterator is reading from */
71640: int nAlloc; /* Bytes of space at aAlloc */
71641: u8 *aAlloc; /* Allocated space */
71642: int nKey; /* Number of bytes in key */
71643: u8 *aKey; /* Pointer to current key */
71644: };
71645:
71646: /*
71647: ** A structure to store a single record. All in-memory records are connected
71648: ** together into a linked list headed at VdbeSorter.pRecord using the
71649: ** SorterRecord.pNext pointer.
71650: */
71651: struct SorterRecord {
71652: void *pVal;
71653: int nVal;
71654: SorterRecord *pNext;
71655: };
71656:
71657: /* Minimum allowable value for the VdbeSorter.nWorking variable */
71658: #define SORTER_MIN_WORKING 10
71659:
71660: /* Maximum number of segments to merge in a single pass. */
71661: #define SORTER_MAX_MERGE_COUNT 16
71662:
71663: /*
71664: ** Free all memory belonging to the VdbeSorterIter object passed as the second
71665: ** argument. All structure fields are set to zero before returning.
71666: */
71667: static void vdbeSorterIterZero(sqlite3 *db, VdbeSorterIter *pIter){
71668: sqlite3DbFree(db, pIter->aAlloc);
71669: memset(pIter, 0, sizeof(VdbeSorterIter));
71670: }
71671:
71672: /*
71673: ** Advance iterator pIter to the next key in its PMA. Return SQLITE_OK if
71674: ** no error occurs, or an SQLite error code if one does.
71675: */
71676: static int vdbeSorterIterNext(
71677: sqlite3 *db, /* Database handle (for sqlite3DbMalloc() ) */
71678: VdbeSorterIter *pIter /* Iterator to advance */
71679: ){
71680: int rc; /* Return Code */
71681: int nRead; /* Number of bytes read */
71682: int nRec = 0; /* Size of record in bytes */
71683: int iOff = 0; /* Size of serialized size varint in bytes */
71684:
71685: assert( pIter->iEof>=pIter->iReadOff );
71686: if( pIter->iEof-pIter->iReadOff>5 ){
71687: nRead = 5;
71688: }else{
71689: nRead = (int)(pIter->iEof - pIter->iReadOff);
71690: }
71691: if( nRead<=0 ){
71692: /* This is an EOF condition */
71693: vdbeSorterIterZero(db, pIter);
71694: return SQLITE_OK;
71695: }
71696:
71697: rc = sqlite3OsRead(pIter->pFile, pIter->aAlloc, nRead, pIter->iReadOff);
71698: if( rc==SQLITE_OK ){
71699: iOff = getVarint32(pIter->aAlloc, nRec);
71700: if( (iOff+nRec)>nRead ){
71701: int nRead2; /* Number of extra bytes to read */
71702: if( (iOff+nRec)>pIter->nAlloc ){
71703: int nNew = pIter->nAlloc*2;
71704: while( (iOff+nRec)>nNew ) nNew = nNew*2;
71705: pIter->aAlloc = sqlite3DbReallocOrFree(db, pIter->aAlloc, nNew);
71706: if( !pIter->aAlloc ) return SQLITE_NOMEM;
71707: pIter->nAlloc = nNew;
71708: }
71709:
71710: nRead2 = iOff + nRec - nRead;
71711: rc = sqlite3OsRead(
71712: pIter->pFile, &pIter->aAlloc[nRead], nRead2, pIter->iReadOff+nRead
71713: );
71714: }
71715: }
71716:
71717: assert( rc!=SQLITE_OK || nRec>0 );
71718: pIter->iReadOff += iOff+nRec;
71719: pIter->nKey = nRec;
71720: pIter->aKey = &pIter->aAlloc[iOff];
71721: return rc;
71722: }
71723:
71724: /*
71725: ** Write a single varint, value iVal, to file-descriptor pFile. Return
71726: ** SQLITE_OK if successful, or an SQLite error code if some error occurs.
71727: **
71728: ** The value of *piOffset when this function is called is used as the byte
71729: ** offset in file pFile to write to. Before returning, *piOffset is
71730: ** incremented by the number of bytes written.
71731: */
71732: static int vdbeSorterWriteVarint(
71733: sqlite3_file *pFile, /* File to write to */
71734: i64 iVal, /* Value to write as a varint */
71735: i64 *piOffset /* IN/OUT: Write offset in file pFile */
71736: ){
71737: u8 aVarint[9]; /* Buffer large enough for a varint */
71738: int nVarint; /* Number of used bytes in varint */
71739: int rc; /* Result of write() call */
71740:
71741: nVarint = sqlite3PutVarint(aVarint, iVal);
71742: rc = sqlite3OsWrite(pFile, aVarint, nVarint, *piOffset);
71743: *piOffset += nVarint;
71744:
71745: return rc;
71746: }
71747:
71748: /*
71749: ** Read a single varint from file-descriptor pFile. Return SQLITE_OK if
71750: ** successful, or an SQLite error code if some error occurs.
71751: **
71752: ** The value of *piOffset when this function is called is used as the
71753: ** byte offset in file pFile from whence to read the varint. If successful
71754: ** (i.e. if no IO error occurs), then *piOffset is set to the offset of
71755: ** the first byte past the end of the varint before returning. *piVal is
71756: ** set to the integer value read. If an error occurs, the final values of
71757: ** both *piOffset and *piVal are undefined.
71758: */
71759: static int vdbeSorterReadVarint(
71760: sqlite3_file *pFile, /* File to read from */
71761: i64 *piOffset, /* IN/OUT: Read offset in pFile */
71762: i64 *piVal /* OUT: Value read from file */
71763: ){
71764: u8 aVarint[9]; /* Buffer large enough for a varint */
71765: i64 iOff = *piOffset; /* Offset in file to read from */
71766: int rc; /* Return code */
71767:
71768: rc = sqlite3OsRead(pFile, aVarint, 9, iOff);
71769: if( rc==SQLITE_OK ){
71770: *piOffset += getVarint(aVarint, (u64 *)piVal);
71771: }
71772:
71773: return rc;
71774: }
71775:
71776: /*
71777: ** Initialize iterator pIter to scan through the PMA stored in file pFile
71778: ** starting at offset iStart and ending at offset iEof-1. This function
71779: ** leaves the iterator pointing to the first key in the PMA (or EOF if the
71780: ** PMA is empty).
71781: */
71782: static int vdbeSorterIterInit(
71783: sqlite3 *db, /* Database handle */
71784: VdbeSorter *pSorter, /* Sorter object */
71785: i64 iStart, /* Start offset in pFile */
71786: VdbeSorterIter *pIter, /* Iterator to populate */
71787: i64 *pnByte /* IN/OUT: Increment this value by PMA size */
71788: ){
71789: int rc;
71790:
71791: assert( pSorter->iWriteOff>iStart );
71792: assert( pIter->aAlloc==0 );
71793: pIter->pFile = pSorter->pTemp1;
71794: pIter->iReadOff = iStart;
71795: pIter->nAlloc = 128;
71796: pIter->aAlloc = (u8 *)sqlite3DbMallocRaw(db, pIter->nAlloc);
71797: if( !pIter->aAlloc ){
71798: rc = SQLITE_NOMEM;
71799: }else{
71800: i64 nByte; /* Total size of PMA in bytes */
71801: rc = vdbeSorterReadVarint(pSorter->pTemp1, &pIter->iReadOff, &nByte);
71802: *pnByte += nByte;
71803: pIter->iEof = pIter->iReadOff + nByte;
71804: }
71805: if( rc==SQLITE_OK ){
71806: rc = vdbeSorterIterNext(db, pIter);
71807: }
71808: return rc;
71809: }
71810:
71811:
71812: /*
71813: ** Compare key1 (buffer pKey1, size nKey1 bytes) with key2 (buffer pKey2,
71814: ** size nKey2 bytes). Argument pKeyInfo supplies the collation functions
71815: ** used by the comparison. If an error occurs, return an SQLite error code.
71816: ** Otherwise, return SQLITE_OK and set *pRes to a negative, zero or positive
71817: ** value, depending on whether key1 is smaller, equal to or larger than key2.
71818: **
71819: ** If the bOmitRowid argument is non-zero, assume both keys end in a rowid
71820: ** field. For the purposes of the comparison, ignore it. Also, if bOmitRowid
71821: ** is true and key1 contains even a single NULL value, it is considered to
71822: ** be less than key2. Even if key2 also contains NULL values.
71823: **
71824: ** If pKey2 is passed a NULL pointer, then it is assumed that the pCsr->aSpace
71825: ** has been allocated and contains an unpacked record that is used as key2.
71826: */
71827: static void vdbeSorterCompare(
71828: VdbeCursor *pCsr, /* Cursor object (for pKeyInfo) */
71829: int bOmitRowid, /* Ignore rowid field at end of keys */
71830: void *pKey1, int nKey1, /* Left side of comparison */
71831: void *pKey2, int nKey2, /* Right side of comparison */
71832: int *pRes /* OUT: Result of comparison */
71833: ){
71834: KeyInfo *pKeyInfo = pCsr->pKeyInfo;
71835: VdbeSorter *pSorter = pCsr->pSorter;
71836: UnpackedRecord *r2 = pSorter->pUnpacked;
71837: int i;
71838:
71839: if( pKey2 ){
71840: sqlite3VdbeRecordUnpack(pKeyInfo, nKey2, pKey2, r2);
71841: }
71842:
71843: if( bOmitRowid ){
71844: r2->nField = pKeyInfo->nField;
71845: assert( r2->nField>0 );
71846: for(i=0; i<r2->nField; i++){
71847: if( r2->aMem[i].flags & MEM_Null ){
71848: *pRes = -1;
71849: return;
71850: }
71851: }
71852: r2->flags |= UNPACKED_PREFIX_MATCH;
71853: }
71854:
71855: *pRes = sqlite3VdbeRecordCompare(nKey1, pKey1, r2);
71856: }
71857:
71858: /*
71859: ** This function is called to compare two iterator keys when merging
71860: ** multiple b-tree segments. Parameter iOut is the index of the aTree[]
71861: ** value to recalculate.
71862: */
71863: static int vdbeSorterDoCompare(VdbeCursor *pCsr, int iOut){
71864: VdbeSorter *pSorter = pCsr->pSorter;
71865: int i1;
71866: int i2;
71867: int iRes;
71868: VdbeSorterIter *p1;
71869: VdbeSorterIter *p2;
71870:
71871: assert( iOut<pSorter->nTree && iOut>0 );
71872:
71873: if( iOut>=(pSorter->nTree/2) ){
71874: i1 = (iOut - pSorter->nTree/2) * 2;
71875: i2 = i1 + 1;
71876: }else{
71877: i1 = pSorter->aTree[iOut*2];
71878: i2 = pSorter->aTree[iOut*2+1];
71879: }
71880:
71881: p1 = &pSorter->aIter[i1];
71882: p2 = &pSorter->aIter[i2];
71883:
71884: if( p1->pFile==0 ){
71885: iRes = i2;
71886: }else if( p2->pFile==0 ){
71887: iRes = i1;
71888: }else{
71889: int res;
71890: assert( pCsr->pSorter->pUnpacked!=0 ); /* allocated in vdbeSorterMerge() */
71891: vdbeSorterCompare(
71892: pCsr, 0, p1->aKey, p1->nKey, p2->aKey, p2->nKey, &res
71893: );
71894: if( res<=0 ){
71895: iRes = i1;
71896: }else{
71897: iRes = i2;
71898: }
71899: }
71900:
71901: pSorter->aTree[iOut] = iRes;
71902: return SQLITE_OK;
71903: }
71904:
71905: /*
71906: ** Initialize the temporary index cursor just opened as a sorter cursor.
71907: */
71908: SQLITE_PRIVATE int sqlite3VdbeSorterInit(sqlite3 *db, VdbeCursor *pCsr){
71909: int pgsz; /* Page size of main database */
71910: int mxCache; /* Cache size */
71911: VdbeSorter *pSorter; /* The new sorter */
71912: char *d; /* Dummy */
71913:
71914: assert( pCsr->pKeyInfo && pCsr->pBt==0 );
71915: pCsr->pSorter = pSorter = sqlite3DbMallocZero(db, sizeof(VdbeSorter));
71916: if( pSorter==0 ){
71917: return SQLITE_NOMEM;
71918: }
71919:
71920: pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pCsr->pKeyInfo, 0, 0, &d);
71921: if( pSorter->pUnpacked==0 ) return SQLITE_NOMEM;
71922: assert( pSorter->pUnpacked==(UnpackedRecord *)d );
71923:
71924: if( !sqlite3TempInMemory(db) ){
71925: pgsz = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
71926: pSorter->mnPmaSize = SORTER_MIN_WORKING * pgsz;
71927: mxCache = db->aDb[0].pSchema->cache_size;
71928: if( mxCache<SORTER_MIN_WORKING ) mxCache = SORTER_MIN_WORKING;
71929: pSorter->mxPmaSize = mxCache * pgsz;
71930: }
71931:
71932: return SQLITE_OK;
71933: }
71934:
71935: /*
71936: ** Free the list of sorted records starting at pRecord.
71937: */
71938: static void vdbeSorterRecordFree(sqlite3 *db, SorterRecord *pRecord){
71939: SorterRecord *p;
71940: SorterRecord *pNext;
71941: for(p=pRecord; p; p=pNext){
71942: pNext = p->pNext;
71943: sqlite3DbFree(db, p);
71944: }
71945: }
71946:
71947: /*
71948: ** Free any cursor components allocated by sqlite3VdbeSorterXXX routines.
71949: */
71950: SQLITE_PRIVATE void sqlite3VdbeSorterClose(sqlite3 *db, VdbeCursor *pCsr){
71951: VdbeSorter *pSorter = pCsr->pSorter;
71952: if( pSorter ){
71953: if( pSorter->aIter ){
71954: int i;
71955: for(i=0; i<pSorter->nTree; i++){
71956: vdbeSorterIterZero(db, &pSorter->aIter[i]);
71957: }
71958: sqlite3DbFree(db, pSorter->aIter);
71959: }
71960: if( pSorter->pTemp1 ){
71961: sqlite3OsCloseFree(pSorter->pTemp1);
71962: }
71963: vdbeSorterRecordFree(db, pSorter->pRecord);
71964: sqlite3DbFree(db, pSorter->pUnpacked);
71965: sqlite3DbFree(db, pSorter);
71966: pCsr->pSorter = 0;
71967: }
71968: }
71969:
71970: /*
71971: ** Allocate space for a file-handle and open a temporary file. If successful,
71972: ** set *ppFile to point to the malloc'd file-handle and return SQLITE_OK.
71973: ** Otherwise, set *ppFile to 0 and return an SQLite error code.
71974: */
71975: static int vdbeSorterOpenTempFile(sqlite3 *db, sqlite3_file **ppFile){
71976: int dummy;
71977: return sqlite3OsOpenMalloc(db->pVfs, 0, ppFile,
71978: SQLITE_OPEN_TEMP_JOURNAL |
71979: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE |
71980: SQLITE_OPEN_EXCLUSIVE | SQLITE_OPEN_DELETEONCLOSE, &dummy
71981: );
71982: }
71983:
71984: /*
71985: ** Merge the two sorted lists p1 and p2 into a single list.
71986: ** Set *ppOut to the head of the new list.
71987: */
71988: static void vdbeSorterMerge(
71989: VdbeCursor *pCsr, /* For pKeyInfo */
71990: SorterRecord *p1, /* First list to merge */
71991: SorterRecord *p2, /* Second list to merge */
71992: SorterRecord **ppOut /* OUT: Head of merged list */
71993: ){
71994: SorterRecord *pFinal = 0;
71995: SorterRecord **pp = &pFinal;
71996: void *pVal2 = p2 ? p2->pVal : 0;
71997:
71998: while( p1 && p2 ){
71999: int res;
72000: vdbeSorterCompare(pCsr, 0, p1->pVal, p1->nVal, pVal2, p2->nVal, &res);
72001: if( res<=0 ){
72002: *pp = p1;
72003: pp = &p1->pNext;
72004: p1 = p1->pNext;
72005: pVal2 = 0;
72006: }else{
72007: *pp = p2;
72008: pp = &p2->pNext;
72009: p2 = p2->pNext;
72010: if( p2==0 ) break;
72011: pVal2 = p2->pVal;
72012: }
72013: }
72014: *pp = p1 ? p1 : p2;
72015: *ppOut = pFinal;
72016: }
72017:
72018: /*
72019: ** Sort the linked list of records headed at pCsr->pRecord. Return SQLITE_OK
72020: ** if successful, or an SQLite error code (i.e. SQLITE_NOMEM) if an error
72021: ** occurs.
72022: */
72023: static int vdbeSorterSort(VdbeCursor *pCsr){
72024: int i;
72025: SorterRecord **aSlot;
72026: SorterRecord *p;
72027: VdbeSorter *pSorter = pCsr->pSorter;
72028:
72029: aSlot = (SorterRecord **)sqlite3MallocZero(64 * sizeof(SorterRecord *));
72030: if( !aSlot ){
72031: return SQLITE_NOMEM;
72032: }
72033:
72034: p = pSorter->pRecord;
72035: while( p ){
72036: SorterRecord *pNext = p->pNext;
72037: p->pNext = 0;
72038: for(i=0; aSlot[i]; i++){
72039: vdbeSorterMerge(pCsr, p, aSlot[i], &p);
72040: aSlot[i] = 0;
72041: }
72042: aSlot[i] = p;
72043: p = pNext;
72044: }
72045:
72046: p = 0;
72047: for(i=0; i<64; i++){
72048: vdbeSorterMerge(pCsr, p, aSlot[i], &p);
72049: }
72050: pSorter->pRecord = p;
72051:
72052: sqlite3_free(aSlot);
72053: return SQLITE_OK;
72054: }
72055:
72056:
72057: /*
72058: ** Write the current contents of the in-memory linked-list to a PMA. Return
72059: ** SQLITE_OK if successful, or an SQLite error code otherwise.
72060: **
72061: ** The format of a PMA is:
72062: **
72063: ** * A varint. This varint contains the total number of bytes of content
72064: ** in the PMA (not including the varint itself).
72065: **
72066: ** * One or more records packed end-to-end in order of ascending keys.
72067: ** Each record consists of a varint followed by a blob of data (the
72068: ** key). The varint is the number of bytes in the blob of data.
72069: */
72070: static int vdbeSorterListToPMA(sqlite3 *db, VdbeCursor *pCsr){
72071: int rc = SQLITE_OK; /* Return code */
72072: VdbeSorter *pSorter = pCsr->pSorter;
72073:
72074: if( pSorter->nInMemory==0 ){
72075: assert( pSorter->pRecord==0 );
72076: return rc;
72077: }
72078:
72079: rc = vdbeSorterSort(pCsr);
72080:
72081: /* If the first temporary PMA file has not been opened, open it now. */
72082: if( rc==SQLITE_OK && pSorter->pTemp1==0 ){
72083: rc = vdbeSorterOpenTempFile(db, &pSorter->pTemp1);
72084: assert( rc!=SQLITE_OK || pSorter->pTemp1 );
72085: assert( pSorter->iWriteOff==0 );
72086: assert( pSorter->nPMA==0 );
72087: }
72088:
72089: if( rc==SQLITE_OK ){
72090: i64 iOff = pSorter->iWriteOff;
72091: SorterRecord *p;
72092: SorterRecord *pNext = 0;
72093: static const char eightZeros[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
72094:
72095: pSorter->nPMA++;
72096: rc = vdbeSorterWriteVarint(pSorter->pTemp1, pSorter->nInMemory, &iOff);
72097: for(p=pSorter->pRecord; rc==SQLITE_OK && p; p=pNext){
72098: pNext = p->pNext;
72099: rc = vdbeSorterWriteVarint(pSorter->pTemp1, p->nVal, &iOff);
72100:
72101: if( rc==SQLITE_OK ){
72102: rc = sqlite3OsWrite(pSorter->pTemp1, p->pVal, p->nVal, iOff);
72103: iOff += p->nVal;
72104: }
72105:
72106: sqlite3DbFree(db, p);
72107: }
72108:
72109: /* This assert verifies that unless an error has occurred, the size of
72110: ** the PMA on disk is the same as the expected size stored in
72111: ** pSorter->nInMemory. */
72112: assert( rc!=SQLITE_OK || pSorter->nInMemory==(
72113: iOff-pSorter->iWriteOff-sqlite3VarintLen(pSorter->nInMemory)
72114: ));
72115:
72116: pSorter->iWriteOff = iOff;
72117: if( rc==SQLITE_OK ){
72118: /* Terminate each file with 8 extra bytes so that from any offset
72119: ** in the file we can always read 9 bytes without a SHORT_READ error */
72120: rc = sqlite3OsWrite(pSorter->pTemp1, eightZeros, 8, iOff);
72121: }
72122: pSorter->pRecord = p;
72123: }
72124:
72125: return rc;
72126: }
72127:
72128: /*
72129: ** Add a record to the sorter.
72130: */
72131: SQLITE_PRIVATE int sqlite3VdbeSorterWrite(
72132: sqlite3 *db, /* Database handle */
72133: VdbeCursor *pCsr, /* Sorter cursor */
72134: Mem *pVal /* Memory cell containing record */
72135: ){
72136: VdbeSorter *pSorter = pCsr->pSorter;
72137: int rc = SQLITE_OK; /* Return Code */
72138: SorterRecord *pNew; /* New list element */
72139:
72140: assert( pSorter );
72141: pSorter->nInMemory += sqlite3VarintLen(pVal->n) + pVal->n;
72142:
72143: pNew = (SorterRecord *)sqlite3DbMallocRaw(db, pVal->n + sizeof(SorterRecord));
72144: if( pNew==0 ){
72145: rc = SQLITE_NOMEM;
72146: }else{
72147: pNew->pVal = (void *)&pNew[1];
72148: memcpy(pNew->pVal, pVal->z, pVal->n);
72149: pNew->nVal = pVal->n;
72150: pNew->pNext = pSorter->pRecord;
72151: pSorter->pRecord = pNew;
72152: }
72153:
72154: /* See if the contents of the sorter should now be written out. They
72155: ** are written out when either of the following are true:
72156: **
72157: ** * The total memory allocated for the in-memory list is greater
72158: ** than (page-size * cache-size), or
72159: **
72160: ** * The total memory allocated for the in-memory list is greater
72161: ** than (page-size * 10) and sqlite3HeapNearlyFull() returns true.
72162: */
72163: if( rc==SQLITE_OK && pSorter->mxPmaSize>0 && (
72164: (pSorter->nInMemory>pSorter->mxPmaSize)
72165: || (pSorter->nInMemory>pSorter->mnPmaSize && sqlite3HeapNearlyFull())
72166: )){
72167: rc = vdbeSorterListToPMA(db, pCsr);
72168: pSorter->nInMemory = 0;
72169: }
72170:
72171: return rc;
72172: }
72173:
72174: /*
72175: ** Helper function for sqlite3VdbeSorterRewind().
72176: */
72177: static int vdbeSorterInitMerge(
72178: sqlite3 *db, /* Database handle */
72179: VdbeCursor *pCsr, /* Cursor handle for this sorter */
72180: i64 *pnByte /* Sum of bytes in all opened PMAs */
72181: ){
72182: VdbeSorter *pSorter = pCsr->pSorter;
72183: int rc = SQLITE_OK; /* Return code */
72184: int i; /* Used to iterator through aIter[] */
72185: i64 nByte = 0; /* Total bytes in all opened PMAs */
72186:
72187: /* Initialize the iterators. */
72188: for(i=0; i<SORTER_MAX_MERGE_COUNT; i++){
72189: VdbeSorterIter *pIter = &pSorter->aIter[i];
72190: rc = vdbeSorterIterInit(db, pSorter, pSorter->iReadOff, pIter, &nByte);
72191: pSorter->iReadOff = pIter->iEof;
72192: assert( rc!=SQLITE_OK || pSorter->iReadOff<=pSorter->iWriteOff );
72193: if( rc!=SQLITE_OK || pSorter->iReadOff>=pSorter->iWriteOff ) break;
72194: }
72195:
72196: /* Initialize the aTree[] array. */
72197: for(i=pSorter->nTree-1; rc==SQLITE_OK && i>0; i--){
72198: rc = vdbeSorterDoCompare(pCsr, i);
72199: }
72200:
72201: *pnByte = nByte;
72202: return rc;
72203: }
72204:
72205: /*
72206: ** Once the sorter has been populated, this function is called to prepare
72207: ** for iterating through its contents in sorted order.
72208: */
72209: SQLITE_PRIVATE int sqlite3VdbeSorterRewind(sqlite3 *db, VdbeCursor *pCsr, int *pbEof){
72210: VdbeSorter *pSorter = pCsr->pSorter;
72211: int rc; /* Return code */
72212: sqlite3_file *pTemp2 = 0; /* Second temp file to use */
72213: i64 iWrite2 = 0; /* Write offset for pTemp2 */
72214: int nIter; /* Number of iterators used */
72215: int nByte; /* Bytes of space required for aIter/aTree */
72216: int N = 2; /* Power of 2 >= nIter */
72217:
72218: assert( pSorter );
72219:
72220: /* If no data has been written to disk, then do not do so now. Instead,
72221: ** sort the VdbeSorter.pRecord list. The vdbe layer will read data directly
72222: ** from the in-memory list. */
72223: if( pSorter->nPMA==0 ){
72224: *pbEof = !pSorter->pRecord;
72225: assert( pSorter->aTree==0 );
72226: return vdbeSorterSort(pCsr);
72227: }
72228:
72229: /* Write the current b-tree to a PMA. Close the b-tree cursor. */
72230: rc = vdbeSorterListToPMA(db, pCsr);
72231: if( rc!=SQLITE_OK ) return rc;
72232:
72233: /* Allocate space for aIter[] and aTree[]. */
72234: nIter = pSorter->nPMA;
72235: if( nIter>SORTER_MAX_MERGE_COUNT ) nIter = SORTER_MAX_MERGE_COUNT;
72236: assert( nIter>0 );
72237: while( N<nIter ) N += N;
72238: nByte = N * (sizeof(int) + sizeof(VdbeSorterIter));
72239: pSorter->aIter = (VdbeSorterIter *)sqlite3DbMallocZero(db, nByte);
72240: if( !pSorter->aIter ) return SQLITE_NOMEM;
72241: pSorter->aTree = (int *)&pSorter->aIter[N];
72242: pSorter->nTree = N;
72243:
72244: do {
72245: int iNew; /* Index of new, merged, PMA */
72246:
72247: for(iNew=0;
72248: rc==SQLITE_OK && iNew*SORTER_MAX_MERGE_COUNT<pSorter->nPMA;
72249: iNew++
72250: ){
72251: i64 nWrite; /* Number of bytes in new PMA */
72252:
72253: /* If there are SORTER_MAX_MERGE_COUNT or less PMAs in file pTemp1,
72254: ** initialize an iterator for each of them and break out of the loop.
72255: ** These iterators will be incrementally merged as the VDBE layer calls
72256: ** sqlite3VdbeSorterNext().
72257: **
72258: ** Otherwise, if pTemp1 contains more than SORTER_MAX_MERGE_COUNT PMAs,
72259: ** initialize interators for SORTER_MAX_MERGE_COUNT of them. These PMAs
72260: ** are merged into a single PMA that is written to file pTemp2.
72261: */
72262: rc = vdbeSorterInitMerge(db, pCsr, &nWrite);
72263: assert( rc!=SQLITE_OK || pSorter->aIter[ pSorter->aTree[1] ].pFile );
72264: if( rc!=SQLITE_OK || pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){
72265: break;
72266: }
72267:
72268: /* Open the second temp file, if it is not already open. */
72269: if( pTemp2==0 ){
72270: assert( iWrite2==0 );
72271: rc = vdbeSorterOpenTempFile(db, &pTemp2);
72272: }
72273:
72274: if( rc==SQLITE_OK ){
72275: rc = vdbeSorterWriteVarint(pTemp2, nWrite, &iWrite2);
72276: }
72277:
72278: if( rc==SQLITE_OK ){
72279: int bEof = 0;
72280: while( rc==SQLITE_OK && bEof==0 ){
72281: int nToWrite;
72282: VdbeSorterIter *pIter = &pSorter->aIter[ pSorter->aTree[1] ];
72283: assert( pIter->pFile );
72284: nToWrite = pIter->nKey + sqlite3VarintLen(pIter->nKey);
72285: rc = sqlite3OsWrite(pTemp2, pIter->aAlloc, nToWrite, iWrite2);
72286: iWrite2 += nToWrite;
72287: if( rc==SQLITE_OK ){
72288: rc = sqlite3VdbeSorterNext(db, pCsr, &bEof);
72289: }
72290: }
72291: }
72292: }
72293:
72294: if( pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){
72295: break;
72296: }else{
72297: sqlite3_file *pTmp = pSorter->pTemp1;
72298: pSorter->nPMA = iNew;
72299: pSorter->pTemp1 = pTemp2;
72300: pTemp2 = pTmp;
72301: pSorter->iWriteOff = iWrite2;
72302: pSorter->iReadOff = 0;
72303: iWrite2 = 0;
72304: }
72305: }while( rc==SQLITE_OK );
72306:
72307: if( pTemp2 ){
72308: sqlite3OsCloseFree(pTemp2);
72309: }
72310: *pbEof = (pSorter->aIter[pSorter->aTree[1]].pFile==0);
72311: return rc;
72312: }
72313:
72314: /*
72315: ** Advance to the next element in the sorter.
72316: */
72317: SQLITE_PRIVATE int sqlite3VdbeSorterNext(sqlite3 *db, VdbeCursor *pCsr, int *pbEof){
72318: VdbeSorter *pSorter = pCsr->pSorter;
72319: int rc; /* Return code */
72320:
72321: if( pSorter->aTree ){
72322: int iPrev = pSorter->aTree[1];/* Index of iterator to advance */
72323: int i; /* Index of aTree[] to recalculate */
72324:
72325: rc = vdbeSorterIterNext(db, &pSorter->aIter[iPrev]);
72326: for(i=(pSorter->nTree+iPrev)/2; rc==SQLITE_OK && i>0; i=i/2){
72327: rc = vdbeSorterDoCompare(pCsr, i);
72328: }
72329:
72330: *pbEof = (pSorter->aIter[pSorter->aTree[1]].pFile==0);
72331: }else{
72332: SorterRecord *pFree = pSorter->pRecord;
72333: pSorter->pRecord = pFree->pNext;
72334: pFree->pNext = 0;
72335: vdbeSorterRecordFree(db, pFree);
72336: *pbEof = !pSorter->pRecord;
72337: rc = SQLITE_OK;
72338: }
72339: return rc;
72340: }
72341:
72342: /*
72343: ** Return a pointer to a buffer owned by the sorter that contains the
72344: ** current key.
72345: */
72346: static void *vdbeSorterRowkey(
72347: VdbeSorter *pSorter, /* Sorter object */
72348: int *pnKey /* OUT: Size of current key in bytes */
72349: ){
72350: void *pKey;
72351: if( pSorter->aTree ){
72352: VdbeSorterIter *pIter;
72353: pIter = &pSorter->aIter[ pSorter->aTree[1] ];
72354: *pnKey = pIter->nKey;
72355: pKey = pIter->aKey;
72356: }else{
72357: *pnKey = pSorter->pRecord->nVal;
72358: pKey = pSorter->pRecord->pVal;
72359: }
72360: return pKey;
72361: }
72362:
72363: /*
72364: ** Copy the current sorter key into the memory cell pOut.
72365: */
72366: SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(VdbeCursor *pCsr, Mem *pOut){
72367: VdbeSorter *pSorter = pCsr->pSorter;
72368: void *pKey; int nKey; /* Sorter key to copy into pOut */
72369:
72370: pKey = vdbeSorterRowkey(pSorter, &nKey);
72371: if( sqlite3VdbeMemGrow(pOut, nKey, 0) ){
72372: return SQLITE_NOMEM;
72373: }
72374: pOut->n = nKey;
72375: MemSetTypeFlag(pOut, MEM_Blob);
72376: memcpy(pOut->z, pKey, nKey);
72377:
72378: return SQLITE_OK;
72379: }
72380:
72381: /*
72382: ** Compare the key in memory cell pVal with the key that the sorter cursor
72383: ** passed as the first argument currently points to. For the purposes of
72384: ** the comparison, ignore the rowid field at the end of each record.
72385: **
72386: ** If an error occurs, return an SQLite error code (i.e. SQLITE_NOMEM).
72387: ** Otherwise, set *pRes to a negative, zero or positive value if the
72388: ** key in pVal is smaller than, equal to or larger than the current sorter
72389: ** key.
72390: */
72391: SQLITE_PRIVATE int sqlite3VdbeSorterCompare(
72392: VdbeCursor *pCsr, /* Sorter cursor */
72393: Mem *pVal, /* Value to compare to current sorter key */
72394: int *pRes /* OUT: Result of comparison */
72395: ){
72396: VdbeSorter *pSorter = pCsr->pSorter;
72397: void *pKey; int nKey; /* Sorter key to compare pVal with */
72398:
72399: pKey = vdbeSorterRowkey(pSorter, &nKey);
72400: vdbeSorterCompare(pCsr, 1, pVal->z, pVal->n, pKey, nKey, pRes);
72401: return SQLITE_OK;
72402: }
72403:
72404: #endif /* #ifndef SQLITE_OMIT_MERGE_SORT */
72405:
72406: /************** End of vdbesort.c ********************************************/
72407: /************** Begin file journal.c *****************************************/
72408: /*
72409: ** 2007 August 22
72410: **
72411: ** The author disclaims copyright to this source code. In place of
72412: ** a legal notice, here is a blessing:
72413: **
72414: ** May you do good and not evil.
72415: ** May you find forgiveness for yourself and forgive others.
72416: ** May you share freely, never taking more than you give.
72417: **
72418: *************************************************************************
72419: **
72420: ** This file implements a special kind of sqlite3_file object used
72421: ** by SQLite to create journal files if the atomic-write optimization
72422: ** is enabled.
72423: **
72424: ** The distinctive characteristic of this sqlite3_file is that the
72425: ** actual on disk file is created lazily. When the file is created,
72426: ** the caller specifies a buffer size for an in-memory buffer to
72427: ** be used to service read() and write() requests. The actual file
72428: ** on disk is not created or populated until either:
72429: **
72430: ** 1) The in-memory representation grows too large for the allocated
72431: ** buffer, or
72432: ** 2) The sqlite3JournalCreate() function is called.
72433: */
72434: #ifdef SQLITE_ENABLE_ATOMIC_WRITE
72435:
72436:
72437: /*
72438: ** A JournalFile object is a subclass of sqlite3_file used by
72439: ** as an open file handle for journal files.
72440: */
72441: struct JournalFile {
72442: sqlite3_io_methods *pMethod; /* I/O methods on journal files */
72443: int nBuf; /* Size of zBuf[] in bytes */
72444: char *zBuf; /* Space to buffer journal writes */
72445: int iSize; /* Amount of zBuf[] currently used */
72446: int flags; /* xOpen flags */
72447: sqlite3_vfs *pVfs; /* The "real" underlying VFS */
72448: sqlite3_file *pReal; /* The "real" underlying file descriptor */
72449: const char *zJournal; /* Name of the journal file */
72450: };
72451: typedef struct JournalFile JournalFile;
72452:
72453: /*
72454: ** If it does not already exists, create and populate the on-disk file
72455: ** for JournalFile p.
72456: */
72457: static int createFile(JournalFile *p){
72458: int rc = SQLITE_OK;
72459: if( !p->pReal ){
72460: sqlite3_file *pReal = (sqlite3_file *)&p[1];
72461: rc = sqlite3OsOpen(p->pVfs, p->zJournal, pReal, p->flags, 0);
72462: if( rc==SQLITE_OK ){
72463: p->pReal = pReal;
72464: if( p->iSize>0 ){
72465: assert(p->iSize<=p->nBuf);
72466: rc = sqlite3OsWrite(p->pReal, p->zBuf, p->iSize, 0);
72467: }
72468: }
72469: }
72470: return rc;
72471: }
72472:
72473: /*
72474: ** Close the file.
72475: */
72476: static int jrnlClose(sqlite3_file *pJfd){
72477: JournalFile *p = (JournalFile *)pJfd;
72478: if( p->pReal ){
72479: sqlite3OsClose(p->pReal);
72480: }
72481: sqlite3_free(p->zBuf);
72482: return SQLITE_OK;
72483: }
72484:
72485: /*
72486: ** Read data from the file.
72487: */
72488: static int jrnlRead(
72489: sqlite3_file *pJfd, /* The journal file from which to read */
72490: void *zBuf, /* Put the results here */
72491: int iAmt, /* Number of bytes to read */
72492: sqlite_int64 iOfst /* Begin reading at this offset */
72493: ){
72494: int rc = SQLITE_OK;
72495: JournalFile *p = (JournalFile *)pJfd;
72496: if( p->pReal ){
72497: rc = sqlite3OsRead(p->pReal, zBuf, iAmt, iOfst);
72498: }else if( (iAmt+iOfst)>p->iSize ){
72499: rc = SQLITE_IOERR_SHORT_READ;
72500: }else{
72501: memcpy(zBuf, &p->zBuf[iOfst], iAmt);
72502: }
72503: return rc;
72504: }
72505:
72506: /*
72507: ** Write data to the file.
72508: */
72509: static int jrnlWrite(
72510: sqlite3_file *pJfd, /* The journal file into which to write */
72511: const void *zBuf, /* Take data to be written from here */
72512: int iAmt, /* Number of bytes to write */
72513: sqlite_int64 iOfst /* Begin writing at this offset into the file */
72514: ){
72515: int rc = SQLITE_OK;
72516: JournalFile *p = (JournalFile *)pJfd;
72517: if( !p->pReal && (iOfst+iAmt)>p->nBuf ){
72518: rc = createFile(p);
72519: }
72520: if( rc==SQLITE_OK ){
72521: if( p->pReal ){
72522: rc = sqlite3OsWrite(p->pReal, zBuf, iAmt, iOfst);
72523: }else{
72524: memcpy(&p->zBuf[iOfst], zBuf, iAmt);
72525: if( p->iSize<(iOfst+iAmt) ){
72526: p->iSize = (iOfst+iAmt);
72527: }
72528: }
72529: }
72530: return rc;
72531: }
72532:
72533: /*
72534: ** Truncate the file.
72535: */
72536: static int jrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
72537: int rc = SQLITE_OK;
72538: JournalFile *p = (JournalFile *)pJfd;
72539: if( p->pReal ){
72540: rc = sqlite3OsTruncate(p->pReal, size);
72541: }else if( size<p->iSize ){
72542: p->iSize = size;
72543: }
72544: return rc;
72545: }
72546:
72547: /*
72548: ** Sync the file.
72549: */
72550: static int jrnlSync(sqlite3_file *pJfd, int flags){
72551: int rc;
72552: JournalFile *p = (JournalFile *)pJfd;
72553: if( p->pReal ){
72554: rc = sqlite3OsSync(p->pReal, flags);
72555: }else{
72556: rc = SQLITE_OK;
72557: }
72558: return rc;
72559: }
72560:
72561: /*
72562: ** Query the size of the file in bytes.
72563: */
72564: static int jrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
72565: int rc = SQLITE_OK;
72566: JournalFile *p = (JournalFile *)pJfd;
72567: if( p->pReal ){
72568: rc = sqlite3OsFileSize(p->pReal, pSize);
72569: }else{
72570: *pSize = (sqlite_int64) p->iSize;
72571: }
72572: return rc;
72573: }
72574:
72575: /*
72576: ** Table of methods for JournalFile sqlite3_file object.
72577: */
72578: static struct sqlite3_io_methods JournalFileMethods = {
72579: 1, /* iVersion */
72580: jrnlClose, /* xClose */
72581: jrnlRead, /* xRead */
72582: jrnlWrite, /* xWrite */
72583: jrnlTruncate, /* xTruncate */
72584: jrnlSync, /* xSync */
72585: jrnlFileSize, /* xFileSize */
72586: 0, /* xLock */
72587: 0, /* xUnlock */
72588: 0, /* xCheckReservedLock */
72589: 0, /* xFileControl */
72590: 0, /* xSectorSize */
72591: 0, /* xDeviceCharacteristics */
72592: 0, /* xShmMap */
72593: 0, /* xShmLock */
72594: 0, /* xShmBarrier */
72595: 0 /* xShmUnmap */
72596: };
72597:
72598: /*
72599: ** Open a journal file.
72600: */
72601: SQLITE_PRIVATE int sqlite3JournalOpen(
72602: sqlite3_vfs *pVfs, /* The VFS to use for actual file I/O */
72603: const char *zName, /* Name of the journal file */
72604: sqlite3_file *pJfd, /* Preallocated, blank file handle */
72605: int flags, /* Opening flags */
72606: int nBuf /* Bytes buffered before opening the file */
72607: ){
72608: JournalFile *p = (JournalFile *)pJfd;
72609: memset(p, 0, sqlite3JournalSize(pVfs));
72610: if( nBuf>0 ){
72611: p->zBuf = sqlite3MallocZero(nBuf);
72612: if( !p->zBuf ){
72613: return SQLITE_NOMEM;
72614: }
72615: }else{
72616: return sqlite3OsOpen(pVfs, zName, pJfd, flags, 0);
72617: }
72618: p->pMethod = &JournalFileMethods;
72619: p->nBuf = nBuf;
72620: p->flags = flags;
72621: p->zJournal = zName;
72622: p->pVfs = pVfs;
72623: return SQLITE_OK;
72624: }
72625:
72626: /*
72627: ** If the argument p points to a JournalFile structure, and the underlying
72628: ** file has not yet been created, create it now.
72629: */
72630: SQLITE_PRIVATE int sqlite3JournalCreate(sqlite3_file *p){
72631: if( p->pMethods!=&JournalFileMethods ){
72632: return SQLITE_OK;
72633: }
72634: return createFile((JournalFile *)p);
72635: }
72636:
72637: /*
72638: ** Return the number of bytes required to store a JournalFile that uses vfs
72639: ** pVfs to create the underlying on-disk files.
72640: */
72641: SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *pVfs){
72642: return (pVfs->szOsFile+sizeof(JournalFile));
72643: }
72644: #endif
72645:
72646: /************** End of journal.c *********************************************/
72647: /************** Begin file memjournal.c **************************************/
72648: /*
72649: ** 2008 October 7
72650: **
72651: ** The author disclaims copyright to this source code. In place of
72652: ** a legal notice, here is a blessing:
72653: **
72654: ** May you do good and not evil.
72655: ** May you find forgiveness for yourself and forgive others.
72656: ** May you share freely, never taking more than you give.
72657: **
72658: *************************************************************************
72659: **
72660: ** This file contains code use to implement an in-memory rollback journal.
72661: ** The in-memory rollback journal is used to journal transactions for
72662: ** ":memory:" databases and when the journal_mode=MEMORY pragma is used.
72663: */
72664:
72665: /* Forward references to internal structures */
72666: typedef struct MemJournal MemJournal;
72667: typedef struct FilePoint FilePoint;
72668: typedef struct FileChunk FileChunk;
72669:
72670: /* Space to hold the rollback journal is allocated in increments of
72671: ** this many bytes.
72672: **
72673: ** The size chosen is a little less than a power of two. That way,
72674: ** the FileChunk object will have a size that almost exactly fills
72675: ** a power-of-two allocation. This mimimizes wasted space in power-of-two
72676: ** memory allocators.
72677: */
72678: #define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*)))
72679:
72680: /* Macro to find the minimum of two numeric values.
72681: */
72682: #ifndef MIN
72683: # define MIN(x,y) ((x)<(y)?(x):(y))
72684: #endif
72685:
72686: /*
72687: ** The rollback journal is composed of a linked list of these structures.
72688: */
72689: struct FileChunk {
72690: FileChunk *pNext; /* Next chunk in the journal */
72691: u8 zChunk[JOURNAL_CHUNKSIZE]; /* Content of this chunk */
72692: };
72693:
72694: /*
72695: ** An instance of this object serves as a cursor into the rollback journal.
72696: ** The cursor can be either for reading or writing.
72697: */
72698: struct FilePoint {
72699: sqlite3_int64 iOffset; /* Offset from the beginning of the file */
72700: FileChunk *pChunk; /* Specific chunk into which cursor points */
72701: };
72702:
72703: /*
72704: ** This subclass is a subclass of sqlite3_file. Each open memory-journal
72705: ** is an instance of this class.
72706: */
72707: struct MemJournal {
72708: sqlite3_io_methods *pMethod; /* Parent class. MUST BE FIRST */
72709: FileChunk *pFirst; /* Head of in-memory chunk-list */
72710: FilePoint endpoint; /* Pointer to the end of the file */
72711: FilePoint readpoint; /* Pointer to the end of the last xRead() */
72712: };
72713:
72714: /*
72715: ** Read data from the in-memory journal file. This is the implementation
72716: ** of the sqlite3_vfs.xRead method.
72717: */
72718: static int memjrnlRead(
72719: sqlite3_file *pJfd, /* The journal file from which to read */
72720: void *zBuf, /* Put the results here */
72721: int iAmt, /* Number of bytes to read */
72722: sqlite_int64 iOfst /* Begin reading at this offset */
72723: ){
72724: MemJournal *p = (MemJournal *)pJfd;
72725: u8 *zOut = zBuf;
72726: int nRead = iAmt;
72727: int iChunkOffset;
72728: FileChunk *pChunk;
72729:
72730: /* SQLite never tries to read past the end of a rollback journal file */
72731: assert( iOfst+iAmt<=p->endpoint.iOffset );
72732:
72733: if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
72734: sqlite3_int64 iOff = 0;
72735: for(pChunk=p->pFirst;
72736: ALWAYS(pChunk) && (iOff+JOURNAL_CHUNKSIZE)<=iOfst;
72737: pChunk=pChunk->pNext
72738: ){
72739: iOff += JOURNAL_CHUNKSIZE;
72740: }
72741: }else{
72742: pChunk = p->readpoint.pChunk;
72743: }
72744:
72745: iChunkOffset = (int)(iOfst%JOURNAL_CHUNKSIZE);
72746: do {
72747: int iSpace = JOURNAL_CHUNKSIZE - iChunkOffset;
72748: int nCopy = MIN(nRead, (JOURNAL_CHUNKSIZE - iChunkOffset));
72749: memcpy(zOut, &pChunk->zChunk[iChunkOffset], nCopy);
72750: zOut += nCopy;
72751: nRead -= iSpace;
72752: iChunkOffset = 0;
72753: } while( nRead>=0 && (pChunk=pChunk->pNext)!=0 && nRead>0 );
72754: p->readpoint.iOffset = iOfst+iAmt;
72755: p->readpoint.pChunk = pChunk;
72756:
72757: return SQLITE_OK;
72758: }
72759:
72760: /*
72761: ** Write data to the file.
72762: */
72763: static int memjrnlWrite(
72764: sqlite3_file *pJfd, /* The journal file into which to write */
72765: const void *zBuf, /* Take data to be written from here */
72766: int iAmt, /* Number of bytes to write */
72767: sqlite_int64 iOfst /* Begin writing at this offset into the file */
72768: ){
72769: MemJournal *p = (MemJournal *)pJfd;
72770: int nWrite = iAmt;
72771: u8 *zWrite = (u8 *)zBuf;
72772:
72773: /* An in-memory journal file should only ever be appended to. Random
72774: ** access writes are not required by sqlite.
72775: */
72776: assert( iOfst==p->endpoint.iOffset );
72777: UNUSED_PARAMETER(iOfst);
72778:
72779: while( nWrite>0 ){
72780: FileChunk *pChunk = p->endpoint.pChunk;
72781: int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
72782: int iSpace = MIN(nWrite, JOURNAL_CHUNKSIZE - iChunkOffset);
72783:
72784: if( iChunkOffset==0 ){
72785: /* New chunk is required to extend the file. */
72786: FileChunk *pNew = sqlite3_malloc(sizeof(FileChunk));
72787: if( !pNew ){
72788: return SQLITE_IOERR_NOMEM;
72789: }
72790: pNew->pNext = 0;
72791: if( pChunk ){
72792: assert( p->pFirst );
72793: pChunk->pNext = pNew;
72794: }else{
72795: assert( !p->pFirst );
72796: p->pFirst = pNew;
72797: }
72798: p->endpoint.pChunk = pNew;
72799: }
72800:
72801: memcpy(&p->endpoint.pChunk->zChunk[iChunkOffset], zWrite, iSpace);
72802: zWrite += iSpace;
72803: nWrite -= iSpace;
72804: p->endpoint.iOffset += iSpace;
72805: }
72806:
72807: return SQLITE_OK;
72808: }
72809:
72810: /*
72811: ** Truncate the file.
72812: */
72813: static int memjrnlTruncate(sqlite3_file *pJfd, sqlite_int64 size){
72814: MemJournal *p = (MemJournal *)pJfd;
72815: FileChunk *pChunk;
72816: assert(size==0);
72817: UNUSED_PARAMETER(size);
72818: pChunk = p->pFirst;
72819: while( pChunk ){
72820: FileChunk *pTmp = pChunk;
72821: pChunk = pChunk->pNext;
72822: sqlite3_free(pTmp);
72823: }
72824: sqlite3MemJournalOpen(pJfd);
72825: return SQLITE_OK;
72826: }
72827:
72828: /*
72829: ** Close the file.
72830: */
72831: static int memjrnlClose(sqlite3_file *pJfd){
72832: memjrnlTruncate(pJfd, 0);
72833: return SQLITE_OK;
72834: }
72835:
72836:
72837: /*
72838: ** Sync the file.
72839: **
72840: ** Syncing an in-memory journal is a no-op. And, in fact, this routine
72841: ** is never called in a working implementation. This implementation
72842: ** exists purely as a contingency, in case some malfunction in some other
72843: ** part of SQLite causes Sync to be called by mistake.
72844: */
72845: static int memjrnlSync(sqlite3_file *NotUsed, int NotUsed2){
72846: UNUSED_PARAMETER2(NotUsed, NotUsed2);
72847: return SQLITE_OK;
72848: }
72849:
72850: /*
72851: ** Query the size of the file in bytes.
72852: */
72853: static int memjrnlFileSize(sqlite3_file *pJfd, sqlite_int64 *pSize){
72854: MemJournal *p = (MemJournal *)pJfd;
72855: *pSize = (sqlite_int64) p->endpoint.iOffset;
72856: return SQLITE_OK;
72857: }
72858:
72859: /*
72860: ** Table of methods for MemJournal sqlite3_file object.
72861: */
72862: static const struct sqlite3_io_methods MemJournalMethods = {
72863: 1, /* iVersion */
72864: memjrnlClose, /* xClose */
72865: memjrnlRead, /* xRead */
72866: memjrnlWrite, /* xWrite */
72867: memjrnlTruncate, /* xTruncate */
72868: memjrnlSync, /* xSync */
72869: memjrnlFileSize, /* xFileSize */
72870: 0, /* xLock */
72871: 0, /* xUnlock */
72872: 0, /* xCheckReservedLock */
72873: 0, /* xFileControl */
72874: 0, /* xSectorSize */
72875: 0, /* xDeviceCharacteristics */
72876: 0, /* xShmMap */
72877: 0, /* xShmLock */
72878: 0, /* xShmBarrier */
72879: 0 /* xShmUnlock */
72880: };
72881:
72882: /*
72883: ** Open a journal file.
72884: */
72885: SQLITE_PRIVATE void sqlite3MemJournalOpen(sqlite3_file *pJfd){
72886: MemJournal *p = (MemJournal *)pJfd;
72887: assert( EIGHT_BYTE_ALIGNMENT(p) );
72888: memset(p, 0, sqlite3MemJournalSize());
72889: p->pMethod = (sqlite3_io_methods*)&MemJournalMethods;
72890: }
72891:
72892: /*
72893: ** Return true if the file-handle passed as an argument is
72894: ** an in-memory journal
72895: */
72896: SQLITE_PRIVATE int sqlite3IsMemJournal(sqlite3_file *pJfd){
72897: return pJfd->pMethods==&MemJournalMethods;
72898: }
72899:
72900: /*
72901: ** Return the number of bytes required to store a MemJournal file descriptor.
72902: */
72903: SQLITE_PRIVATE int sqlite3MemJournalSize(void){
72904: return sizeof(MemJournal);
72905: }
72906:
72907: /************** End of memjournal.c ******************************************/
72908: /************** Begin file walker.c ******************************************/
72909: /*
72910: ** 2008 August 16
72911: **
72912: ** The author disclaims copyright to this source code. In place of
72913: ** a legal notice, here is a blessing:
72914: **
72915: ** May you do good and not evil.
72916: ** May you find forgiveness for yourself and forgive others.
72917: ** May you share freely, never taking more than you give.
72918: **
72919: *************************************************************************
72920: ** This file contains routines used for walking the parser tree for
72921: ** an SQL statement.
72922: */
72923: /* #include <stdlib.h> */
72924: /* #include <string.h> */
72925:
72926:
72927: /*
72928: ** Walk an expression tree. Invoke the callback once for each node
72929: ** of the expression, while decending. (In other words, the callback
72930: ** is invoked before visiting children.)
72931: **
72932: ** The return value from the callback should be one of the WRC_*
72933: ** constants to specify how to proceed with the walk.
72934: **
72935: ** WRC_Continue Continue descending down the tree.
72936: **
72937: ** WRC_Prune Do not descend into child nodes. But allow
72938: ** the walk to continue with sibling nodes.
72939: **
72940: ** WRC_Abort Do no more callbacks. Unwind the stack and
72941: ** return the top-level walk call.
72942: **
72943: ** The return value from this routine is WRC_Abort to abandon the tree walk
72944: ** and WRC_Continue to continue.
72945: */
72946: SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
72947: int rc;
72948: if( pExpr==0 ) return WRC_Continue;
72949: testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
72950: testcase( ExprHasProperty(pExpr, EP_Reduced) );
72951: rc = pWalker->xExprCallback(pWalker, pExpr);
72952: if( rc==WRC_Continue
72953: && !ExprHasAnyProperty(pExpr,EP_TokenOnly) ){
72954: if( sqlite3WalkExpr(pWalker, pExpr->pLeft) ) return WRC_Abort;
72955: if( sqlite3WalkExpr(pWalker, pExpr->pRight) ) return WRC_Abort;
72956: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
72957: if( sqlite3WalkSelect(pWalker, pExpr->x.pSelect) ) return WRC_Abort;
72958: }else{
72959: if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
72960: }
72961: }
72962: return rc & WRC_Abort;
72963: }
72964:
72965: /*
72966: ** Call sqlite3WalkExpr() for every expression in list p or until
72967: ** an abort request is seen.
72968: */
72969: SQLITE_PRIVATE int sqlite3WalkExprList(Walker *pWalker, ExprList *p){
72970: int i;
72971: struct ExprList_item *pItem;
72972: if( p ){
72973: for(i=p->nExpr, pItem=p->a; i>0; i--, pItem++){
72974: if( sqlite3WalkExpr(pWalker, pItem->pExpr) ) return WRC_Abort;
72975: }
72976: }
72977: return WRC_Continue;
72978: }
72979:
72980: /*
72981: ** Walk all expressions associated with SELECT statement p. Do
72982: ** not invoke the SELECT callback on p, but do (of course) invoke
72983: ** any expr callbacks and SELECT callbacks that come from subqueries.
72984: ** Return WRC_Abort or WRC_Continue.
72985: */
72986: SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){
72987: if( sqlite3WalkExprList(pWalker, p->pEList) ) return WRC_Abort;
72988: if( sqlite3WalkExpr(pWalker, p->pWhere) ) return WRC_Abort;
72989: if( sqlite3WalkExprList(pWalker, p->pGroupBy) ) return WRC_Abort;
72990: if( sqlite3WalkExpr(pWalker, p->pHaving) ) return WRC_Abort;
72991: if( sqlite3WalkExprList(pWalker, p->pOrderBy) ) return WRC_Abort;
72992: if( sqlite3WalkExpr(pWalker, p->pLimit) ) return WRC_Abort;
72993: if( sqlite3WalkExpr(pWalker, p->pOffset) ) return WRC_Abort;
72994: return WRC_Continue;
72995: }
72996:
72997: /*
72998: ** Walk the parse trees associated with all subqueries in the
72999: ** FROM clause of SELECT statement p. Do not invoke the select
73000: ** callback on p, but do invoke it on each FROM clause subquery
73001: ** and on any subqueries further down in the tree. Return
73002: ** WRC_Abort or WRC_Continue;
73003: */
73004: SQLITE_PRIVATE int sqlite3WalkSelectFrom(Walker *pWalker, Select *p){
73005: SrcList *pSrc;
73006: int i;
73007: struct SrcList_item *pItem;
73008:
73009: pSrc = p->pSrc;
73010: if( ALWAYS(pSrc) ){
73011: for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
73012: if( sqlite3WalkSelect(pWalker, pItem->pSelect) ){
73013: return WRC_Abort;
73014: }
73015: }
73016: }
73017: return WRC_Continue;
73018: }
73019:
73020: /*
73021: ** Call sqlite3WalkExpr() for every expression in Select statement p.
73022: ** Invoke sqlite3WalkSelect() for subqueries in the FROM clause and
73023: ** on the compound select chain, p->pPrior.
73024: **
73025: ** Return WRC_Continue under normal conditions. Return WRC_Abort if
73026: ** there is an abort request.
73027: **
73028: ** If the Walker does not have an xSelectCallback() then this routine
73029: ** is a no-op returning WRC_Continue.
73030: */
73031: SQLITE_PRIVATE int sqlite3WalkSelect(Walker *pWalker, Select *p){
73032: int rc;
73033: if( p==0 || pWalker->xSelectCallback==0 ) return WRC_Continue;
73034: rc = WRC_Continue;
73035: while( p ){
73036: rc = pWalker->xSelectCallback(pWalker, p);
73037: if( rc ) break;
73038: if( sqlite3WalkSelectExpr(pWalker, p) ) return WRC_Abort;
73039: if( sqlite3WalkSelectFrom(pWalker, p) ) return WRC_Abort;
73040: p = p->pPrior;
73041: }
73042: return rc & WRC_Abort;
73043: }
73044:
73045: /************** End of walker.c **********************************************/
73046: /************** Begin file resolve.c *****************************************/
73047: /*
73048: ** 2008 August 18
73049: **
73050: ** The author disclaims copyright to this source code. In place of
73051: ** a legal notice, here is a blessing:
73052: **
73053: ** May you do good and not evil.
73054: ** May you find forgiveness for yourself and forgive others.
73055: ** May you share freely, never taking more than you give.
73056: **
73057: *************************************************************************
73058: **
73059: ** This file contains routines used for walking the parser tree and
73060: ** resolve all identifiers by associating them with a particular
73061: ** table and column.
73062: */
73063: /* #include <stdlib.h> */
73064: /* #include <string.h> */
73065:
73066: /*
73067: ** Turn the pExpr expression into an alias for the iCol-th column of the
73068: ** result set in pEList.
73069: **
73070: ** If the result set column is a simple column reference, then this routine
73071: ** makes an exact copy. But for any other kind of expression, this
73072: ** routine make a copy of the result set column as the argument to the
73073: ** TK_AS operator. The TK_AS operator causes the expression to be
73074: ** evaluated just once and then reused for each alias.
73075: **
73076: ** The reason for suppressing the TK_AS term when the expression is a simple
73077: ** column reference is so that the column reference will be recognized as
73078: ** usable by indices within the WHERE clause processing logic.
73079: **
73080: ** Hack: The TK_AS operator is inhibited if zType[0]=='G'. This means
73081: ** that in a GROUP BY clause, the expression is evaluated twice. Hence:
73082: **
73083: ** SELECT random()%5 AS x, count(*) FROM tab GROUP BY x
73084: **
73085: ** Is equivalent to:
73086: **
73087: ** SELECT random()%5 AS x, count(*) FROM tab GROUP BY random()%5
73088: **
73089: ** The result of random()%5 in the GROUP BY clause is probably different
73090: ** from the result in the result-set. We might fix this someday. Or
73091: ** then again, we might not...
73092: */
73093: static void resolveAlias(
73094: Parse *pParse, /* Parsing context */
73095: ExprList *pEList, /* A result set */
73096: int iCol, /* A column in the result set. 0..pEList->nExpr-1 */
73097: Expr *pExpr, /* Transform this into an alias to the result set */
73098: const char *zType /* "GROUP" or "ORDER" or "" */
73099: ){
73100: Expr *pOrig; /* The iCol-th column of the result set */
73101: Expr *pDup; /* Copy of pOrig */
73102: sqlite3 *db; /* The database connection */
73103:
73104: assert( iCol>=0 && iCol<pEList->nExpr );
73105: pOrig = pEList->a[iCol].pExpr;
73106: assert( pOrig!=0 );
73107: assert( pOrig->flags & EP_Resolved );
73108: db = pParse->db;
73109: if( pOrig->op!=TK_COLUMN && zType[0]!='G' ){
73110: pDup = sqlite3ExprDup(db, pOrig, 0);
73111: pDup = sqlite3PExpr(pParse, TK_AS, pDup, 0, 0);
73112: if( pDup==0 ) return;
73113: if( pEList->a[iCol].iAlias==0 ){
73114: pEList->a[iCol].iAlias = (u16)(++pParse->nAlias);
73115: }
73116: pDup->iTable = pEList->a[iCol].iAlias;
73117: }else if( ExprHasProperty(pOrig, EP_IntValue) || pOrig->u.zToken==0 ){
73118: pDup = sqlite3ExprDup(db, pOrig, 0);
73119: if( pDup==0 ) return;
73120: }else{
73121: char *zToken = pOrig->u.zToken;
73122: assert( zToken!=0 );
73123: pOrig->u.zToken = 0;
73124: pDup = sqlite3ExprDup(db, pOrig, 0);
73125: pOrig->u.zToken = zToken;
73126: if( pDup==0 ) return;
73127: assert( (pDup->flags & (EP_Reduced|EP_TokenOnly))==0 );
73128: pDup->flags2 |= EP2_MallocedToken;
73129: pDup->u.zToken = sqlite3DbStrDup(db, zToken);
73130: }
73131: if( pExpr->flags & EP_ExpCollate ){
73132: pDup->pColl = pExpr->pColl;
73133: pDup->flags |= EP_ExpCollate;
73134: }
73135:
73136: /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
73137: ** prevents ExprDelete() from deleting the Expr structure itself,
73138: ** allowing it to be repopulated by the memcpy() on the following line.
73139: */
73140: ExprSetProperty(pExpr, EP_Static);
73141: sqlite3ExprDelete(db, pExpr);
73142: memcpy(pExpr, pDup, sizeof(*pExpr));
73143: sqlite3DbFree(db, pDup);
73144: }
73145:
73146:
73147: /*
73148: ** Return TRUE if the name zCol occurs anywhere in the USING clause.
73149: **
73150: ** Return FALSE if the USING clause is NULL or if it does not contain
73151: ** zCol.
73152: */
73153: static int nameInUsingClause(IdList *pUsing, const char *zCol){
73154: if( pUsing ){
73155: int k;
73156: for(k=0; k<pUsing->nId; k++){
73157: if( sqlite3StrICmp(pUsing->a[k].zName, zCol)==0 ) return 1;
73158: }
73159: }
73160: return 0;
73161: }
73162:
73163:
73164: /*
73165: ** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up
73166: ** that name in the set of source tables in pSrcList and make the pExpr
73167: ** expression node refer back to that source column. The following changes
73168: ** are made to pExpr:
73169: **
73170: ** pExpr->iDb Set the index in db->aDb[] of the database X
73171: ** (even if X is implied).
73172: ** pExpr->iTable Set to the cursor number for the table obtained
73173: ** from pSrcList.
73174: ** pExpr->pTab Points to the Table structure of X.Y (even if
73175: ** X and/or Y are implied.)
73176: ** pExpr->iColumn Set to the column number within the table.
73177: ** pExpr->op Set to TK_COLUMN.
73178: ** pExpr->pLeft Any expression this points to is deleted
73179: ** pExpr->pRight Any expression this points to is deleted.
73180: **
73181: ** The zDb variable is the name of the database (the "X"). This value may be
73182: ** NULL meaning that name is of the form Y.Z or Z. Any available database
73183: ** can be used. The zTable variable is the name of the table (the "Y"). This
73184: ** value can be NULL if zDb is also NULL. If zTable is NULL it
73185: ** means that the form of the name is Z and that columns from any table
73186: ** can be used.
73187: **
73188: ** If the name cannot be resolved unambiguously, leave an error message
73189: ** in pParse and return WRC_Abort. Return WRC_Prune on success.
73190: */
73191: static int lookupName(
73192: Parse *pParse, /* The parsing context */
73193: const char *zDb, /* Name of the database containing table, or NULL */
73194: const char *zTab, /* Name of table containing column, or NULL */
73195: const char *zCol, /* Name of the column. */
73196: NameContext *pNC, /* The name context used to resolve the name */
73197: Expr *pExpr /* Make this EXPR node point to the selected column */
73198: ){
73199: int i, j; /* Loop counters */
73200: int cnt = 0; /* Number of matching column names */
73201: int cntTab = 0; /* Number of matching table names */
73202: sqlite3 *db = pParse->db; /* The database connection */
73203: struct SrcList_item *pItem; /* Use for looping over pSrcList items */
73204: struct SrcList_item *pMatch = 0; /* The matching pSrcList item */
73205: NameContext *pTopNC = pNC; /* First namecontext in the list */
73206: Schema *pSchema = 0; /* Schema of the expression */
73207: int isTrigger = 0;
73208:
73209: assert( pNC ); /* the name context cannot be NULL. */
73210: assert( zCol ); /* The Z in X.Y.Z cannot be NULL */
73211: assert( ~ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
73212:
73213: /* Initialize the node to no-match */
73214: pExpr->iTable = -1;
73215: pExpr->pTab = 0;
73216: ExprSetIrreducible(pExpr);
73217:
73218: /* Start at the inner-most context and move outward until a match is found */
73219: while( pNC && cnt==0 ){
73220: ExprList *pEList;
73221: SrcList *pSrcList = pNC->pSrcList;
73222:
73223: if( pSrcList ){
73224: for(i=0, pItem=pSrcList->a; i<pSrcList->nSrc; i++, pItem++){
73225: Table *pTab;
73226: int iDb;
73227: Column *pCol;
73228:
73229: pTab = pItem->pTab;
73230: assert( pTab!=0 && pTab->zName!=0 );
73231: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
73232: assert( pTab->nCol>0 );
73233: if( zTab ){
73234: if( pItem->zAlias ){
73235: char *zTabName = pItem->zAlias;
73236: if( sqlite3StrICmp(zTabName, zTab)!=0 ) continue;
73237: }else{
73238: char *zTabName = pTab->zName;
73239: if( NEVER(zTabName==0) || sqlite3StrICmp(zTabName, zTab)!=0 ){
73240: continue;
73241: }
73242: if( zDb!=0 && sqlite3StrICmp(db->aDb[iDb].zName, zDb)!=0 ){
73243: continue;
73244: }
73245: }
73246: }
73247: if( 0==(cntTab++) ){
73248: pExpr->iTable = pItem->iCursor;
73249: pExpr->pTab = pTab;
73250: pSchema = pTab->pSchema;
73251: pMatch = pItem;
73252: }
73253: for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
73254: if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
73255: /* If there has been exactly one prior match and this match
73256: ** is for the right-hand table of a NATURAL JOIN or is in a
73257: ** USING clause, then skip this match.
73258: */
73259: if( cnt==1 ){
73260: if( pItem->jointype & JT_NATURAL ) continue;
73261: if( nameInUsingClause(pItem->pUsing, zCol) ) continue;
73262: }
73263: cnt++;
73264: pExpr->iTable = pItem->iCursor;
73265: pExpr->pTab = pTab;
73266: pMatch = pItem;
73267: pSchema = pTab->pSchema;
73268: /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */
73269: pExpr->iColumn = j==pTab->iPKey ? -1 : (i16)j;
73270: break;
73271: }
73272: }
73273: }
73274: }
73275:
73276: #ifndef SQLITE_OMIT_TRIGGER
73277: /* If we have not already resolved the name, then maybe
73278: ** it is a new.* or old.* trigger argument reference
73279: */
73280: if( zDb==0 && zTab!=0 && cnt==0 && pParse->pTriggerTab!=0 ){
73281: int op = pParse->eTriggerOp;
73282: Table *pTab = 0;
73283: assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
73284: if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){
73285: pExpr->iTable = 1;
73286: pTab = pParse->pTriggerTab;
73287: }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){
73288: pExpr->iTable = 0;
73289: pTab = pParse->pTriggerTab;
73290: }
73291:
73292: if( pTab ){
73293: int iCol;
73294: pSchema = pTab->pSchema;
73295: cntTab++;
73296: for(iCol=0; iCol<pTab->nCol; iCol++){
73297: Column *pCol = &pTab->aCol[iCol];
73298: if( sqlite3StrICmp(pCol->zName, zCol)==0 ){
73299: if( iCol==pTab->iPKey ){
73300: iCol = -1;
73301: }
73302: break;
73303: }
73304: }
73305: if( iCol>=pTab->nCol && sqlite3IsRowid(zCol) ){
73306: iCol = -1; /* IMP: R-44911-55124 */
73307: }
73308: if( iCol<pTab->nCol ){
73309: cnt++;
73310: if( iCol<0 ){
73311: pExpr->affinity = SQLITE_AFF_INTEGER;
73312: }else if( pExpr->iTable==0 ){
73313: testcase( iCol==31 );
73314: testcase( iCol==32 );
73315: pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
73316: }else{
73317: testcase( iCol==31 );
73318: testcase( iCol==32 );
73319: pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
73320: }
73321: pExpr->iColumn = (i16)iCol;
73322: pExpr->pTab = pTab;
73323: isTrigger = 1;
73324: }
73325: }
73326: }
73327: #endif /* !defined(SQLITE_OMIT_TRIGGER) */
73328:
73329: /*
73330: ** Perhaps the name is a reference to the ROWID
73331: */
73332: if( cnt==0 && cntTab==1 && sqlite3IsRowid(zCol) ){
73333: cnt = 1;
73334: pExpr->iColumn = -1; /* IMP: R-44911-55124 */
73335: pExpr->affinity = SQLITE_AFF_INTEGER;
73336: }
73337:
73338: /*
73339: ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
73340: ** might refer to an result-set alias. This happens, for example, when
73341: ** we are resolving names in the WHERE clause of the following command:
73342: **
73343: ** SELECT a+b AS x FROM table WHERE x<10;
73344: **
73345: ** In cases like this, replace pExpr with a copy of the expression that
73346: ** forms the result set entry ("a+b" in the example) and return immediately.
73347: ** Note that the expression in the result set should have already been
73348: ** resolved by the time the WHERE clause is resolved.
73349: */
73350: if( cnt==0 && (pEList = pNC->pEList)!=0 && zTab==0 ){
73351: for(j=0; j<pEList->nExpr; j++){
73352: char *zAs = pEList->a[j].zName;
73353: if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
73354: Expr *pOrig;
73355: assert( pExpr->pLeft==0 && pExpr->pRight==0 );
73356: assert( pExpr->x.pList==0 );
73357: assert( pExpr->x.pSelect==0 );
73358: pOrig = pEList->a[j].pExpr;
73359: if( !pNC->allowAgg && ExprHasProperty(pOrig, EP_Agg) ){
73360: sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
73361: return WRC_Abort;
73362: }
73363: resolveAlias(pParse, pEList, j, pExpr, "");
73364: cnt = 1;
73365: pMatch = 0;
73366: assert( zTab==0 && zDb==0 );
73367: goto lookupname_end;
73368: }
73369: }
73370: }
73371:
73372: /* Advance to the next name context. The loop will exit when either
73373: ** we have a match (cnt>0) or when we run out of name contexts.
73374: */
73375: if( cnt==0 ){
73376: pNC = pNC->pNext;
73377: }
73378: }
73379:
73380: /*
73381: ** If X and Y are NULL (in other words if only the column name Z is
73382: ** supplied) and the value of Z is enclosed in double-quotes, then
73383: ** Z is a string literal if it doesn't match any column names. In that
73384: ** case, we need to return right away and not make any changes to
73385: ** pExpr.
73386: **
73387: ** Because no reference was made to outer contexts, the pNC->nRef
73388: ** fields are not changed in any context.
73389: */
73390: if( cnt==0 && zTab==0 && ExprHasProperty(pExpr,EP_DblQuoted) ){
73391: pExpr->op = TK_STRING;
73392: pExpr->pTab = 0;
73393: return WRC_Prune;
73394: }
73395:
73396: /*
73397: ** cnt==0 means there was not match. cnt>1 means there were two or
73398: ** more matches. Either way, we have an error.
73399: */
73400: if( cnt!=1 ){
73401: const char *zErr;
73402: zErr = cnt==0 ? "no such column" : "ambiguous column name";
73403: if( zDb ){
73404: sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
73405: }else if( zTab ){
73406: sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
73407: }else{
73408: sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
73409: }
73410: pParse->checkSchema = 1;
73411: pTopNC->nErr++;
73412: }
73413:
73414: /* If a column from a table in pSrcList is referenced, then record
73415: ** this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
73416: ** bit 0 to be set. Column 1 sets bit 1. And so forth. If the
73417: ** column number is greater than the number of bits in the bitmask
73418: ** then set the high-order bit of the bitmask.
73419: */
73420: if( pExpr->iColumn>=0 && pMatch!=0 ){
73421: int n = pExpr->iColumn;
73422: testcase( n==BMS-1 );
73423: if( n>=BMS ){
73424: n = BMS-1;
73425: }
73426: assert( pMatch->iCursor==pExpr->iTable );
73427: pMatch->colUsed |= ((Bitmask)1)<<n;
73428: }
73429:
73430: /* Clean up and return
73431: */
73432: sqlite3ExprDelete(db, pExpr->pLeft);
73433: pExpr->pLeft = 0;
73434: sqlite3ExprDelete(db, pExpr->pRight);
73435: pExpr->pRight = 0;
73436: pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN);
73437: lookupname_end:
73438: if( cnt==1 ){
73439: assert( pNC!=0 );
73440: sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
73441: /* Increment the nRef value on all name contexts from TopNC up to
73442: ** the point where the name matched. */
73443: for(;;){
73444: assert( pTopNC!=0 );
73445: pTopNC->nRef++;
73446: if( pTopNC==pNC ) break;
73447: pTopNC = pTopNC->pNext;
73448: }
73449: return WRC_Prune;
73450: } else {
73451: return WRC_Abort;
73452: }
73453: }
73454:
73455: /*
73456: ** Allocate and return a pointer to an expression to load the column iCol
73457: ** from datasource iSrc in SrcList pSrc.
73458: */
73459: SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSrc, int iCol){
73460: Expr *p = sqlite3ExprAlloc(db, TK_COLUMN, 0, 0);
73461: if( p ){
73462: struct SrcList_item *pItem = &pSrc->a[iSrc];
73463: p->pTab = pItem->pTab;
73464: p->iTable = pItem->iCursor;
73465: if( p->pTab->iPKey==iCol ){
73466: p->iColumn = -1;
73467: }else{
73468: p->iColumn = (ynVar)iCol;
73469: testcase( iCol==BMS );
73470: testcase( iCol==BMS-1 );
73471: pItem->colUsed |= ((Bitmask)1)<<(iCol>=BMS ? BMS-1 : iCol);
73472: }
73473: ExprSetProperty(p, EP_Resolved);
73474: }
73475: return p;
73476: }
73477:
73478: /*
73479: ** This routine is callback for sqlite3WalkExpr().
73480: **
73481: ** Resolve symbolic names into TK_COLUMN operators for the current
73482: ** node in the expression tree. Return 0 to continue the search down
73483: ** the tree or 2 to abort the tree walk.
73484: **
73485: ** This routine also does error checking and name resolution for
73486: ** function names. The operator for aggregate functions is changed
73487: ** to TK_AGG_FUNCTION.
73488: */
73489: static int resolveExprStep(Walker *pWalker, Expr *pExpr){
73490: NameContext *pNC;
73491: Parse *pParse;
73492:
73493: pNC = pWalker->u.pNC;
73494: assert( pNC!=0 );
73495: pParse = pNC->pParse;
73496: assert( pParse==pWalker->pParse );
73497:
73498: if( ExprHasAnyProperty(pExpr, EP_Resolved) ) return WRC_Prune;
73499: ExprSetProperty(pExpr, EP_Resolved);
73500: #ifndef NDEBUG
73501: if( pNC->pSrcList && pNC->pSrcList->nAlloc>0 ){
73502: SrcList *pSrcList = pNC->pSrcList;
73503: int i;
73504: for(i=0; i<pNC->pSrcList->nSrc; i++){
73505: assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
73506: }
73507: }
73508: #endif
73509: switch( pExpr->op ){
73510:
73511: #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
73512: /* The special operator TK_ROW means use the rowid for the first
73513: ** column in the FROM clause. This is used by the LIMIT and ORDER BY
73514: ** clause processing on UPDATE and DELETE statements.
73515: */
73516: case TK_ROW: {
73517: SrcList *pSrcList = pNC->pSrcList;
73518: struct SrcList_item *pItem;
73519: assert( pSrcList && pSrcList->nSrc==1 );
73520: pItem = pSrcList->a;
73521: pExpr->op = TK_COLUMN;
73522: pExpr->pTab = pItem->pTab;
73523: pExpr->iTable = pItem->iCursor;
73524: pExpr->iColumn = -1;
73525: pExpr->affinity = SQLITE_AFF_INTEGER;
73526: break;
73527: }
73528: #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
73529:
73530: /* A lone identifier is the name of a column.
73531: */
73532: case TK_ID: {
73533: return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
73534: }
73535:
73536: /* A table name and column name: ID.ID
73537: ** Or a database, table and column: ID.ID.ID
73538: */
73539: case TK_DOT: {
73540: const char *zColumn;
73541: const char *zTable;
73542: const char *zDb;
73543: Expr *pRight;
73544:
73545: /* if( pSrcList==0 ) break; */
73546: pRight = pExpr->pRight;
73547: if( pRight->op==TK_ID ){
73548: zDb = 0;
73549: zTable = pExpr->pLeft->u.zToken;
73550: zColumn = pRight->u.zToken;
73551: }else{
73552: assert( pRight->op==TK_DOT );
73553: zDb = pExpr->pLeft->u.zToken;
73554: zTable = pRight->pLeft->u.zToken;
73555: zColumn = pRight->pRight->u.zToken;
73556: }
73557: return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
73558: }
73559:
73560: /* Resolve function names
73561: */
73562: case TK_CONST_FUNC:
73563: case TK_FUNCTION: {
73564: ExprList *pList = pExpr->x.pList; /* The argument list */
73565: int n = pList ? pList->nExpr : 0; /* Number of arguments */
73566: int no_such_func = 0; /* True if no such function exists */
73567: int wrong_num_args = 0; /* True if wrong number of arguments */
73568: int is_agg = 0; /* True if is an aggregate function */
73569: int auth; /* Authorization to use the function */
73570: int nId; /* Number of characters in function name */
73571: const char *zId; /* The function name. */
73572: FuncDef *pDef; /* Information about the function */
73573: u8 enc = ENC(pParse->db); /* The database encoding */
73574:
73575: testcase( pExpr->op==TK_CONST_FUNC );
73576: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
73577: zId = pExpr->u.zToken;
73578: nId = sqlite3Strlen30(zId);
73579: pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
73580: if( pDef==0 ){
73581: pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, enc, 0);
73582: if( pDef==0 ){
73583: no_such_func = 1;
73584: }else{
73585: wrong_num_args = 1;
73586: }
73587: }else{
73588: is_agg = pDef->xFunc==0;
73589: }
73590: #ifndef SQLITE_OMIT_AUTHORIZATION
73591: if( pDef ){
73592: auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
73593: if( auth!=SQLITE_OK ){
73594: if( auth==SQLITE_DENY ){
73595: sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
73596: pDef->zName);
73597: pNC->nErr++;
73598: }
73599: pExpr->op = TK_NULL;
73600: return WRC_Prune;
73601: }
73602: }
73603: #endif
73604: if( is_agg && !pNC->allowAgg ){
73605: sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
73606: pNC->nErr++;
73607: is_agg = 0;
73608: }else if( no_such_func ){
73609: sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
73610: pNC->nErr++;
73611: }else if( wrong_num_args ){
73612: sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
73613: nId, zId);
73614: pNC->nErr++;
73615: }
73616: if( is_agg ){
73617: pExpr->op = TK_AGG_FUNCTION;
73618: pNC->hasAgg = 1;
73619: }
73620: if( is_agg ) pNC->allowAgg = 0;
73621: sqlite3WalkExprList(pWalker, pList);
73622: if( is_agg ) pNC->allowAgg = 1;
73623: /* FIX ME: Compute pExpr->affinity based on the expected return
73624: ** type of the function
73625: */
73626: return WRC_Prune;
73627: }
73628: #ifndef SQLITE_OMIT_SUBQUERY
73629: case TK_SELECT:
73630: case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
73631: #endif
73632: case TK_IN: {
73633: testcase( pExpr->op==TK_IN );
73634: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
73635: int nRef = pNC->nRef;
73636: #ifndef SQLITE_OMIT_CHECK
73637: if( pNC->isCheck ){
73638: sqlite3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints");
73639: }
73640: #endif
73641: sqlite3WalkSelect(pWalker, pExpr->x.pSelect);
73642: assert( pNC->nRef>=nRef );
73643: if( nRef!=pNC->nRef ){
73644: ExprSetProperty(pExpr, EP_VarSelect);
73645: }
73646: }
73647: break;
73648: }
73649: #ifndef SQLITE_OMIT_CHECK
73650: case TK_VARIABLE: {
73651: if( pNC->isCheck ){
73652: sqlite3ErrorMsg(pParse,"parameters prohibited in CHECK constraints");
73653: }
73654: break;
73655: }
73656: #endif
73657: }
73658: return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
73659: }
73660:
73661: /*
73662: ** pEList is a list of expressions which are really the result set of the
73663: ** a SELECT statement. pE is a term in an ORDER BY or GROUP BY clause.
73664: ** This routine checks to see if pE is a simple identifier which corresponds
73665: ** to the AS-name of one of the terms of the expression list. If it is,
73666: ** this routine return an integer between 1 and N where N is the number of
73667: ** elements in pEList, corresponding to the matching entry. If there is
73668: ** no match, or if pE is not a simple identifier, then this routine
73669: ** return 0.
73670: **
73671: ** pEList has been resolved. pE has not.
73672: */
73673: static int resolveAsName(
73674: Parse *pParse, /* Parsing context for error messages */
73675: ExprList *pEList, /* List of expressions to scan */
73676: Expr *pE /* Expression we are trying to match */
73677: ){
73678: int i; /* Loop counter */
73679:
73680: UNUSED_PARAMETER(pParse);
73681:
73682: if( pE->op==TK_ID ){
73683: char *zCol = pE->u.zToken;
73684: for(i=0; i<pEList->nExpr; i++){
73685: char *zAs = pEList->a[i].zName;
73686: if( zAs!=0 && sqlite3StrICmp(zAs, zCol)==0 ){
73687: return i+1;
73688: }
73689: }
73690: }
73691: return 0;
73692: }
73693:
73694: /*
73695: ** pE is a pointer to an expression which is a single term in the
73696: ** ORDER BY of a compound SELECT. The expression has not been
73697: ** name resolved.
73698: **
73699: ** At the point this routine is called, we already know that the
73700: ** ORDER BY term is not an integer index into the result set. That
73701: ** case is handled by the calling routine.
73702: **
73703: ** Attempt to match pE against result set columns in the left-most
73704: ** SELECT statement. Return the index i of the matching column,
73705: ** as an indication to the caller that it should sort by the i-th column.
73706: ** The left-most column is 1. In other words, the value returned is the
73707: ** same integer value that would be used in the SQL statement to indicate
73708: ** the column.
73709: **
73710: ** If there is no match, return 0. Return -1 if an error occurs.
73711: */
73712: static int resolveOrderByTermToExprList(
73713: Parse *pParse, /* Parsing context for error messages */
73714: Select *pSelect, /* The SELECT statement with the ORDER BY clause */
73715: Expr *pE /* The specific ORDER BY term */
73716: ){
73717: int i; /* Loop counter */
73718: ExprList *pEList; /* The columns of the result set */
73719: NameContext nc; /* Name context for resolving pE */
73720: sqlite3 *db; /* Database connection */
73721: int rc; /* Return code from subprocedures */
73722: u8 savedSuppErr; /* Saved value of db->suppressErr */
73723:
73724: assert( sqlite3ExprIsInteger(pE, &i)==0 );
73725: pEList = pSelect->pEList;
73726:
73727: /* Resolve all names in the ORDER BY term expression
73728: */
73729: memset(&nc, 0, sizeof(nc));
73730: nc.pParse = pParse;
73731: nc.pSrcList = pSelect->pSrc;
73732: nc.pEList = pEList;
73733: nc.allowAgg = 1;
73734: nc.nErr = 0;
73735: db = pParse->db;
73736: savedSuppErr = db->suppressErr;
73737: db->suppressErr = 1;
73738: rc = sqlite3ResolveExprNames(&nc, pE);
73739: db->suppressErr = savedSuppErr;
73740: if( rc ) return 0;
73741:
73742: /* Try to match the ORDER BY expression against an expression
73743: ** in the result set. Return an 1-based index of the matching
73744: ** result-set entry.
73745: */
73746: for(i=0; i<pEList->nExpr; i++){
73747: if( sqlite3ExprCompare(pEList->a[i].pExpr, pE)<2 ){
73748: return i+1;
73749: }
73750: }
73751:
73752: /* If no match, return 0. */
73753: return 0;
73754: }
73755:
73756: /*
73757: ** Generate an ORDER BY or GROUP BY term out-of-range error.
73758: */
73759: static void resolveOutOfRangeError(
73760: Parse *pParse, /* The error context into which to write the error */
73761: const char *zType, /* "ORDER" or "GROUP" */
73762: int i, /* The index (1-based) of the term out of range */
73763: int mx /* Largest permissible value of i */
73764: ){
73765: sqlite3ErrorMsg(pParse,
73766: "%r %s BY term out of range - should be "
73767: "between 1 and %d", i, zType, mx);
73768: }
73769:
73770: /*
73771: ** Analyze the ORDER BY clause in a compound SELECT statement. Modify
73772: ** each term of the ORDER BY clause is a constant integer between 1
73773: ** and N where N is the number of columns in the compound SELECT.
73774: **
73775: ** ORDER BY terms that are already an integer between 1 and N are
73776: ** unmodified. ORDER BY terms that are integers outside the range of
73777: ** 1 through N generate an error. ORDER BY terms that are expressions
73778: ** are matched against result set expressions of compound SELECT
73779: ** beginning with the left-most SELECT and working toward the right.
73780: ** At the first match, the ORDER BY expression is transformed into
73781: ** the integer column number.
73782: **
73783: ** Return the number of errors seen.
73784: */
73785: static int resolveCompoundOrderBy(
73786: Parse *pParse, /* Parsing context. Leave error messages here */
73787: Select *pSelect /* The SELECT statement containing the ORDER BY */
73788: ){
73789: int i;
73790: ExprList *pOrderBy;
73791: ExprList *pEList;
73792: sqlite3 *db;
73793: int moreToDo = 1;
73794:
73795: pOrderBy = pSelect->pOrderBy;
73796: if( pOrderBy==0 ) return 0;
73797: db = pParse->db;
73798: #if SQLITE_MAX_COLUMN
73799: if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
73800: sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
73801: return 1;
73802: }
73803: #endif
73804: for(i=0; i<pOrderBy->nExpr; i++){
73805: pOrderBy->a[i].done = 0;
73806: }
73807: pSelect->pNext = 0;
73808: while( pSelect->pPrior ){
73809: pSelect->pPrior->pNext = pSelect;
73810: pSelect = pSelect->pPrior;
73811: }
73812: while( pSelect && moreToDo ){
73813: struct ExprList_item *pItem;
73814: moreToDo = 0;
73815: pEList = pSelect->pEList;
73816: assert( pEList!=0 );
73817: for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
73818: int iCol = -1;
73819: Expr *pE, *pDup;
73820: if( pItem->done ) continue;
73821: pE = pItem->pExpr;
73822: if( sqlite3ExprIsInteger(pE, &iCol) ){
73823: if( iCol<=0 || iCol>pEList->nExpr ){
73824: resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
73825: return 1;
73826: }
73827: }else{
73828: iCol = resolveAsName(pParse, pEList, pE);
73829: if( iCol==0 ){
73830: pDup = sqlite3ExprDup(db, pE, 0);
73831: if( !db->mallocFailed ){
73832: assert(pDup);
73833: iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
73834: }
73835: sqlite3ExprDelete(db, pDup);
73836: }
73837: }
73838: if( iCol>0 ){
73839: CollSeq *pColl = pE->pColl;
73840: int flags = pE->flags & EP_ExpCollate;
73841: sqlite3ExprDelete(db, pE);
73842: pItem->pExpr = pE = sqlite3Expr(db, TK_INTEGER, 0);
73843: if( pE==0 ) return 1;
73844: pE->pColl = pColl;
73845: pE->flags |= EP_IntValue | flags;
73846: pE->u.iValue = iCol;
73847: pItem->iOrderByCol = (u16)iCol;
73848: pItem->done = 1;
73849: }else{
73850: moreToDo = 1;
73851: }
73852: }
73853: pSelect = pSelect->pNext;
73854: }
73855: for(i=0; i<pOrderBy->nExpr; i++){
73856: if( pOrderBy->a[i].done==0 ){
73857: sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
73858: "column in the result set", i+1);
73859: return 1;
73860: }
73861: }
73862: return 0;
73863: }
73864:
73865: /*
73866: ** Check every term in the ORDER BY or GROUP BY clause pOrderBy of
73867: ** the SELECT statement pSelect. If any term is reference to a
73868: ** result set expression (as determined by the ExprList.a.iCol field)
73869: ** then convert that term into a copy of the corresponding result set
73870: ** column.
73871: **
73872: ** If any errors are detected, add an error message to pParse and
73873: ** return non-zero. Return zero if no errors are seen.
73874: */
73875: SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(
73876: Parse *pParse, /* Parsing context. Leave error messages here */
73877: Select *pSelect, /* The SELECT statement containing the clause */
73878: ExprList *pOrderBy, /* The ORDER BY or GROUP BY clause to be processed */
73879: const char *zType /* "ORDER" or "GROUP" */
73880: ){
73881: int i;
73882: sqlite3 *db = pParse->db;
73883: ExprList *pEList;
73884: struct ExprList_item *pItem;
73885:
73886: if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
73887: #if SQLITE_MAX_COLUMN
73888: if( pOrderBy->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
73889: sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
73890: return 1;
73891: }
73892: #endif
73893: pEList = pSelect->pEList;
73894: assert( pEList!=0 ); /* sqlite3SelectNew() guarantees this */
73895: for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
73896: if( pItem->iOrderByCol ){
73897: if( pItem->iOrderByCol>pEList->nExpr ){
73898: resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
73899: return 1;
73900: }
73901: resolveAlias(pParse, pEList, pItem->iOrderByCol-1, pItem->pExpr, zType);
73902: }
73903: }
73904: return 0;
73905: }
73906:
73907: /*
73908: ** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
73909: ** The Name context of the SELECT statement is pNC. zType is either
73910: ** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
73911: **
73912: ** This routine resolves each term of the clause into an expression.
73913: ** If the order-by term is an integer I between 1 and N (where N is the
73914: ** number of columns in the result set of the SELECT) then the expression
73915: ** in the resolution is a copy of the I-th result-set expression. If
73916: ** the order-by term is an identify that corresponds to the AS-name of
73917: ** a result-set expression, then the term resolves to a copy of the
73918: ** result-set expression. Otherwise, the expression is resolved in
73919: ** the usual way - using sqlite3ResolveExprNames().
73920: **
73921: ** This routine returns the number of errors. If errors occur, then
73922: ** an appropriate error message might be left in pParse. (OOM errors
73923: ** excepted.)
73924: */
73925: static int resolveOrderGroupBy(
73926: NameContext *pNC, /* The name context of the SELECT statement */
73927: Select *pSelect, /* The SELECT statement holding pOrderBy */
73928: ExprList *pOrderBy, /* An ORDER BY or GROUP BY clause to resolve */
73929: const char *zType /* Either "ORDER" or "GROUP", as appropriate */
73930: ){
73931: int i; /* Loop counter */
73932: int iCol; /* Column number */
73933: struct ExprList_item *pItem; /* A term of the ORDER BY clause */
73934: Parse *pParse; /* Parsing context */
73935: int nResult; /* Number of terms in the result set */
73936:
73937: if( pOrderBy==0 ) return 0;
73938: nResult = pSelect->pEList->nExpr;
73939: pParse = pNC->pParse;
73940: for(i=0, pItem=pOrderBy->a; i<pOrderBy->nExpr; i++, pItem++){
73941: Expr *pE = pItem->pExpr;
73942: iCol = resolveAsName(pParse, pSelect->pEList, pE);
73943: if( iCol>0 ){
73944: /* If an AS-name match is found, mark this ORDER BY column as being
73945: ** a copy of the iCol-th result-set column. The subsequent call to
73946: ** sqlite3ResolveOrderGroupBy() will convert the expression to a
73947: ** copy of the iCol-th result-set expression. */
73948: pItem->iOrderByCol = (u16)iCol;
73949: continue;
73950: }
73951: if( sqlite3ExprIsInteger(pE, &iCol) ){
73952: /* The ORDER BY term is an integer constant. Again, set the column
73953: ** number so that sqlite3ResolveOrderGroupBy() will convert the
73954: ** order-by term to a copy of the result-set expression */
73955: if( iCol<1 ){
73956: resolveOutOfRangeError(pParse, zType, i+1, nResult);
73957: return 1;
73958: }
73959: pItem->iOrderByCol = (u16)iCol;
73960: continue;
73961: }
73962:
73963: /* Otherwise, treat the ORDER BY term as an ordinary expression */
73964: pItem->iOrderByCol = 0;
73965: if( sqlite3ResolveExprNames(pNC, pE) ){
73966: return 1;
73967: }
73968: }
73969: return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
73970: }
73971:
73972: /*
73973: ** Resolve names in the SELECT statement p and all of its descendents.
73974: */
73975: static int resolveSelectStep(Walker *pWalker, Select *p){
73976: NameContext *pOuterNC; /* Context that contains this SELECT */
73977: NameContext sNC; /* Name context of this SELECT */
73978: int isCompound; /* True if p is a compound select */
73979: int nCompound; /* Number of compound terms processed so far */
73980: Parse *pParse; /* Parsing context */
73981: ExprList *pEList; /* Result set expression list */
73982: int i; /* Loop counter */
73983: ExprList *pGroupBy; /* The GROUP BY clause */
73984: Select *pLeftmost; /* Left-most of SELECT of a compound */
73985: sqlite3 *db; /* Database connection */
73986:
73987:
73988: assert( p!=0 );
73989: if( p->selFlags & SF_Resolved ){
73990: return WRC_Prune;
73991: }
73992: pOuterNC = pWalker->u.pNC;
73993: pParse = pWalker->pParse;
73994: db = pParse->db;
73995:
73996: /* Normally sqlite3SelectExpand() will be called first and will have
73997: ** already expanded this SELECT. However, if this is a subquery within
73998: ** an expression, sqlite3ResolveExprNames() will be called without a
73999: ** prior call to sqlite3SelectExpand(). When that happens, let
74000: ** sqlite3SelectPrep() do all of the processing for this SELECT.
74001: ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
74002: ** this routine in the correct order.
74003: */
74004: if( (p->selFlags & SF_Expanded)==0 ){
74005: sqlite3SelectPrep(pParse, p, pOuterNC);
74006: return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
74007: }
74008:
74009: isCompound = p->pPrior!=0;
74010: nCompound = 0;
74011: pLeftmost = p;
74012: while( p ){
74013: assert( (p->selFlags & SF_Expanded)!=0 );
74014: assert( (p->selFlags & SF_Resolved)==0 );
74015: p->selFlags |= SF_Resolved;
74016:
74017: /* Resolve the expressions in the LIMIT and OFFSET clauses. These
74018: ** are not allowed to refer to any names, so pass an empty NameContext.
74019: */
74020: memset(&sNC, 0, sizeof(sNC));
74021: sNC.pParse = pParse;
74022: if( sqlite3ResolveExprNames(&sNC, p->pLimit) ||
74023: sqlite3ResolveExprNames(&sNC, p->pOffset) ){
74024: return WRC_Abort;
74025: }
74026:
74027: /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
74028: ** resolve the result-set expression list.
74029: */
74030: sNC.allowAgg = 1;
74031: sNC.pSrcList = p->pSrc;
74032: sNC.pNext = pOuterNC;
74033:
74034: /* Resolve names in the result set. */
74035: pEList = p->pEList;
74036: assert( pEList!=0 );
74037: for(i=0; i<pEList->nExpr; i++){
74038: Expr *pX = pEList->a[i].pExpr;
74039: if( sqlite3ResolveExprNames(&sNC, pX) ){
74040: return WRC_Abort;
74041: }
74042: }
74043:
74044: /* Recursively resolve names in all subqueries
74045: */
74046: for(i=0; i<p->pSrc->nSrc; i++){
74047: struct SrcList_item *pItem = &p->pSrc->a[i];
74048: if( pItem->pSelect ){
74049: NameContext *pNC; /* Used to iterate name contexts */
74050: int nRef = 0; /* Refcount for pOuterNC and outer contexts */
74051: const char *zSavedContext = pParse->zAuthContext;
74052:
74053: /* Count the total number of references to pOuterNC and all of its
74054: ** parent contexts. After resolving references to expressions in
74055: ** pItem->pSelect, check if this value has changed. If so, then
74056: ** SELECT statement pItem->pSelect must be correlated. Set the
74057: ** pItem->isCorrelated flag if this is the case. */
74058: for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef += pNC->nRef;
74059:
74060: if( pItem->zName ) pParse->zAuthContext = pItem->zName;
74061: sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
74062: pParse->zAuthContext = zSavedContext;
74063: if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
74064:
74065: for(pNC=pOuterNC; pNC; pNC=pNC->pNext) nRef -= pNC->nRef;
74066: assert( pItem->isCorrelated==0 && nRef<=0 );
74067: pItem->isCorrelated = (nRef!=0);
74068: }
74069: }
74070:
74071: /* If there are no aggregate functions in the result-set, and no GROUP BY
74072: ** expression, do not allow aggregates in any of the other expressions.
74073: */
74074: assert( (p->selFlags & SF_Aggregate)==0 );
74075: pGroupBy = p->pGroupBy;
74076: if( pGroupBy || sNC.hasAgg ){
74077: p->selFlags |= SF_Aggregate;
74078: }else{
74079: sNC.allowAgg = 0;
74080: }
74081:
74082: /* If a HAVING clause is present, then there must be a GROUP BY clause.
74083: */
74084: if( p->pHaving && !pGroupBy ){
74085: sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
74086: return WRC_Abort;
74087: }
74088:
74089: /* Add the expression list to the name-context before parsing the
74090: ** other expressions in the SELECT statement. This is so that
74091: ** expressions in the WHERE clause (etc.) can refer to expressions by
74092: ** aliases in the result set.
74093: **
74094: ** Minor point: If this is the case, then the expression will be
74095: ** re-evaluated for each reference to it.
74096: */
74097: sNC.pEList = p->pEList;
74098: if( sqlite3ResolveExprNames(&sNC, p->pWhere) ||
74099: sqlite3ResolveExprNames(&sNC, p->pHaving)
74100: ){
74101: return WRC_Abort;
74102: }
74103:
74104: /* The ORDER BY and GROUP BY clauses may not refer to terms in
74105: ** outer queries
74106: */
74107: sNC.pNext = 0;
74108: sNC.allowAgg = 1;
74109:
74110: /* Process the ORDER BY clause for singleton SELECT statements.
74111: ** The ORDER BY clause for compounds SELECT statements is handled
74112: ** below, after all of the result-sets for all of the elements of
74113: ** the compound have been resolved.
74114: */
74115: if( !isCompound && resolveOrderGroupBy(&sNC, p, p->pOrderBy, "ORDER") ){
74116: return WRC_Abort;
74117: }
74118: if( db->mallocFailed ){
74119: return WRC_Abort;
74120: }
74121:
74122: /* Resolve the GROUP BY clause. At the same time, make sure
74123: ** the GROUP BY clause does not contain aggregate functions.
74124: */
74125: if( pGroupBy ){
74126: struct ExprList_item *pItem;
74127:
74128: if( resolveOrderGroupBy(&sNC, p, pGroupBy, "GROUP") || db->mallocFailed ){
74129: return WRC_Abort;
74130: }
74131: for(i=0, pItem=pGroupBy->a; i<pGroupBy->nExpr; i++, pItem++){
74132: if( ExprHasProperty(pItem->pExpr, EP_Agg) ){
74133: sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
74134: "the GROUP BY clause");
74135: return WRC_Abort;
74136: }
74137: }
74138: }
74139:
74140: /* Advance to the next term of the compound
74141: */
74142: p = p->pPrior;
74143: nCompound++;
74144: }
74145:
74146: /* Resolve the ORDER BY on a compound SELECT after all terms of
74147: ** the compound have been resolved.
74148: */
74149: if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
74150: return WRC_Abort;
74151: }
74152:
74153: return WRC_Prune;
74154: }
74155:
74156: /*
74157: ** This routine walks an expression tree and resolves references to
74158: ** table columns and result-set columns. At the same time, do error
74159: ** checking on function usage and set a flag if any aggregate functions
74160: ** are seen.
74161: **
74162: ** To resolve table columns references we look for nodes (or subtrees) of the
74163: ** form X.Y.Z or Y.Z or just Z where
74164: **
74165: ** X: The name of a database. Ex: "main" or "temp" or
74166: ** the symbolic name assigned to an ATTACH-ed database.
74167: **
74168: ** Y: The name of a table in a FROM clause. Or in a trigger
74169: ** one of the special names "old" or "new".
74170: **
74171: ** Z: The name of a column in table Y.
74172: **
74173: ** The node at the root of the subtree is modified as follows:
74174: **
74175: ** Expr.op Changed to TK_COLUMN
74176: ** Expr.pTab Points to the Table object for X.Y
74177: ** Expr.iColumn The column index in X.Y. -1 for the rowid.
74178: ** Expr.iTable The VDBE cursor number for X.Y
74179: **
74180: **
74181: ** To resolve result-set references, look for expression nodes of the
74182: ** form Z (with no X and Y prefix) where the Z matches the right-hand
74183: ** size of an AS clause in the result-set of a SELECT. The Z expression
74184: ** is replaced by a copy of the left-hand side of the result-set expression.
74185: ** Table-name and function resolution occurs on the substituted expression
74186: ** tree. For example, in:
74187: **
74188: ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY x;
74189: **
74190: ** The "x" term of the order by is replaced by "a+b" to render:
74191: **
74192: ** SELECT a+b AS x, c+d AS y FROM t1 ORDER BY a+b;
74193: **
74194: ** Function calls are checked to make sure that the function is
74195: ** defined and that the correct number of arguments are specified.
74196: ** If the function is an aggregate function, then the pNC->hasAgg is
74197: ** set and the opcode is changed from TK_FUNCTION to TK_AGG_FUNCTION.
74198: ** If an expression contains aggregate functions then the EP_Agg
74199: ** property on the expression is set.
74200: **
74201: ** An error message is left in pParse if anything is amiss. The number
74202: ** if errors is returned.
74203: */
74204: SQLITE_PRIVATE int sqlite3ResolveExprNames(
74205: NameContext *pNC, /* Namespace to resolve expressions in. */
74206: Expr *pExpr /* The expression to be analyzed. */
74207: ){
74208: int savedHasAgg;
74209: Walker w;
74210:
74211: if( pExpr==0 ) return 0;
74212: #if SQLITE_MAX_EXPR_DEPTH>0
74213: {
74214: Parse *pParse = pNC->pParse;
74215: if( sqlite3ExprCheckHeight(pParse, pExpr->nHeight+pNC->pParse->nHeight) ){
74216: return 1;
74217: }
74218: pParse->nHeight += pExpr->nHeight;
74219: }
74220: #endif
74221: savedHasAgg = pNC->hasAgg;
74222: pNC->hasAgg = 0;
74223: w.xExprCallback = resolveExprStep;
74224: w.xSelectCallback = resolveSelectStep;
74225: w.pParse = pNC->pParse;
74226: w.u.pNC = pNC;
74227: sqlite3WalkExpr(&w, pExpr);
74228: #if SQLITE_MAX_EXPR_DEPTH>0
74229: pNC->pParse->nHeight -= pExpr->nHeight;
74230: #endif
74231: if( pNC->nErr>0 || w.pParse->nErr>0 ){
74232: ExprSetProperty(pExpr, EP_Error);
74233: }
74234: if( pNC->hasAgg ){
74235: ExprSetProperty(pExpr, EP_Agg);
74236: }else if( savedHasAgg ){
74237: pNC->hasAgg = 1;
74238: }
74239: return ExprHasProperty(pExpr, EP_Error);
74240: }
74241:
74242:
74243: /*
74244: ** Resolve all names in all expressions of a SELECT and in all
74245: ** decendents of the SELECT, including compounds off of p->pPrior,
74246: ** subqueries in expressions, and subqueries used as FROM clause
74247: ** terms.
74248: **
74249: ** See sqlite3ResolveExprNames() for a description of the kinds of
74250: ** transformations that occur.
74251: **
74252: ** All SELECT statements should have been expanded using
74253: ** sqlite3SelectExpand() prior to invoking this routine.
74254: */
74255: SQLITE_PRIVATE void sqlite3ResolveSelectNames(
74256: Parse *pParse, /* The parser context */
74257: Select *p, /* The SELECT statement being coded. */
74258: NameContext *pOuterNC /* Name context for parent SELECT statement */
74259: ){
74260: Walker w;
74261:
74262: assert( p!=0 );
74263: w.xExprCallback = resolveExprStep;
74264: w.xSelectCallback = resolveSelectStep;
74265: w.pParse = pParse;
74266: w.u.pNC = pOuterNC;
74267: sqlite3WalkSelect(&w, p);
74268: }
74269:
74270: /************** End of resolve.c *********************************************/
74271: /************** Begin file expr.c ********************************************/
74272: /*
74273: ** 2001 September 15
74274: **
74275: ** The author disclaims copyright to this source code. In place of
74276: ** a legal notice, here is a blessing:
74277: **
74278: ** May you do good and not evil.
74279: ** May you find forgiveness for yourself and forgive others.
74280: ** May you share freely, never taking more than you give.
74281: **
74282: *************************************************************************
74283: ** This file contains routines used for analyzing expressions and
74284: ** for generating VDBE code that evaluates expressions in SQLite.
74285: */
74286:
74287: /*
74288: ** Return the 'affinity' of the expression pExpr if any.
74289: **
74290: ** If pExpr is a column, a reference to a column via an 'AS' alias,
74291: ** or a sub-select with a column as the return value, then the
74292: ** affinity of that column is returned. Otherwise, 0x00 is returned,
74293: ** indicating no affinity for the expression.
74294: **
74295: ** i.e. the WHERE clause expresssions in the following statements all
74296: ** have an affinity:
74297: **
74298: ** CREATE TABLE t1(a);
74299: ** SELECT * FROM t1 WHERE a;
74300: ** SELECT a AS b FROM t1 WHERE b;
74301: ** SELECT * FROM t1 WHERE (select a from t1);
74302: */
74303: SQLITE_PRIVATE char sqlite3ExprAffinity(Expr *pExpr){
74304: int op = pExpr->op;
74305: if( op==TK_SELECT ){
74306: assert( pExpr->flags&EP_xIsSelect );
74307: return sqlite3ExprAffinity(pExpr->x.pSelect->pEList->a[0].pExpr);
74308: }
74309: #ifndef SQLITE_OMIT_CAST
74310: if( op==TK_CAST ){
74311: assert( !ExprHasProperty(pExpr, EP_IntValue) );
74312: return sqlite3AffinityType(pExpr->u.zToken);
74313: }
74314: #endif
74315: if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER)
74316: && pExpr->pTab!=0
74317: ){
74318: /* op==TK_REGISTER && pExpr->pTab!=0 happens when pExpr was originally
74319: ** a TK_COLUMN but was previously evaluated and cached in a register */
74320: int j = pExpr->iColumn;
74321: if( j<0 ) return SQLITE_AFF_INTEGER;
74322: assert( pExpr->pTab && j<pExpr->pTab->nCol );
74323: return pExpr->pTab->aCol[j].affinity;
74324: }
74325: return pExpr->affinity;
74326: }
74327:
74328: /*
74329: ** Set the explicit collating sequence for an expression to the
74330: ** collating sequence supplied in the second argument.
74331: */
74332: SQLITE_PRIVATE Expr *sqlite3ExprSetColl(Expr *pExpr, CollSeq *pColl){
74333: if( pExpr && pColl ){
74334: pExpr->pColl = pColl;
74335: pExpr->flags |= EP_ExpCollate;
74336: }
74337: return pExpr;
74338: }
74339:
74340: /*
74341: ** Set the collating sequence for expression pExpr to be the collating
74342: ** sequence named by pToken. Return a pointer to the revised expression.
74343: ** The collating sequence is marked as "explicit" using the EP_ExpCollate
74344: ** flag. An explicit collating sequence will override implicit
74345: ** collating sequences.
74346: */
74347: SQLITE_PRIVATE Expr *sqlite3ExprSetCollByToken(Parse *pParse, Expr *pExpr, Token *pCollName){
74348: char *zColl = 0; /* Dequoted name of collation sequence */
74349: CollSeq *pColl;
74350: sqlite3 *db = pParse->db;
74351: zColl = sqlite3NameFromToken(db, pCollName);
74352: pColl = sqlite3LocateCollSeq(pParse, zColl);
74353: sqlite3ExprSetColl(pExpr, pColl);
74354: sqlite3DbFree(db, zColl);
74355: return pExpr;
74356: }
74357:
74358: /*
74359: ** Return the default collation sequence for the expression pExpr. If
74360: ** there is no default collation type, return 0.
74361: */
74362: SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
74363: CollSeq *pColl = 0;
74364: Expr *p = pExpr;
74365: while( p ){
74366: int op;
74367: pColl = p->pColl;
74368: if( pColl ) break;
74369: op = p->op;
74370: if( p->pTab!=0 && (
74371: op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER || op==TK_TRIGGER
74372: )){
74373: /* op==TK_REGISTER && p->pTab!=0 happens when pExpr was originally
74374: ** a TK_COLUMN but was previously evaluated and cached in a register */
74375: const char *zColl;
74376: int j = p->iColumn;
74377: if( j>=0 ){
74378: sqlite3 *db = pParse->db;
74379: zColl = p->pTab->aCol[j].zColl;
74380: pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
74381: pExpr->pColl = pColl;
74382: }
74383: break;
74384: }
74385: if( op!=TK_CAST && op!=TK_UPLUS ){
74386: break;
74387: }
74388: p = p->pLeft;
74389: }
74390: if( sqlite3CheckCollSeq(pParse, pColl) ){
74391: pColl = 0;
74392: }
74393: return pColl;
74394: }
74395:
74396: /*
74397: ** pExpr is an operand of a comparison operator. aff2 is the
74398: ** type affinity of the other operand. This routine returns the
74399: ** type affinity that should be used for the comparison operator.
74400: */
74401: SQLITE_PRIVATE char sqlite3CompareAffinity(Expr *pExpr, char aff2){
74402: char aff1 = sqlite3ExprAffinity(pExpr);
74403: if( aff1 && aff2 ){
74404: /* Both sides of the comparison are columns. If one has numeric
74405: ** affinity, use that. Otherwise use no affinity.
74406: */
74407: if( sqlite3IsNumericAffinity(aff1) || sqlite3IsNumericAffinity(aff2) ){
74408: return SQLITE_AFF_NUMERIC;
74409: }else{
74410: return SQLITE_AFF_NONE;
74411: }
74412: }else if( !aff1 && !aff2 ){
74413: /* Neither side of the comparison is a column. Compare the
74414: ** results directly.
74415: */
74416: return SQLITE_AFF_NONE;
74417: }else{
74418: /* One side is a column, the other is not. Use the columns affinity. */
74419: assert( aff1==0 || aff2==0 );
74420: return (aff1 + aff2);
74421: }
74422: }
74423:
74424: /*
74425: ** pExpr is a comparison operator. Return the type affinity that should
74426: ** be applied to both operands prior to doing the comparison.
74427: */
74428: static char comparisonAffinity(Expr *pExpr){
74429: char aff;
74430: assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
74431: pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
74432: pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
74433: assert( pExpr->pLeft );
74434: aff = sqlite3ExprAffinity(pExpr->pLeft);
74435: if( pExpr->pRight ){
74436: aff = sqlite3CompareAffinity(pExpr->pRight, aff);
74437: }else if( ExprHasProperty(pExpr, EP_xIsSelect) ){
74438: aff = sqlite3CompareAffinity(pExpr->x.pSelect->pEList->a[0].pExpr, aff);
74439: }else if( !aff ){
74440: aff = SQLITE_AFF_NONE;
74441: }
74442: return aff;
74443: }
74444:
74445: /*
74446: ** pExpr is a comparison expression, eg. '=', '<', IN(...) etc.
74447: ** idx_affinity is the affinity of an indexed column. Return true
74448: ** if the index with affinity idx_affinity may be used to implement
74449: ** the comparison in pExpr.
74450: */
74451: SQLITE_PRIVATE int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity){
74452: char aff = comparisonAffinity(pExpr);
74453: switch( aff ){
74454: case SQLITE_AFF_NONE:
74455: return 1;
74456: case SQLITE_AFF_TEXT:
74457: return idx_affinity==SQLITE_AFF_TEXT;
74458: default:
74459: return sqlite3IsNumericAffinity(idx_affinity);
74460: }
74461: }
74462:
74463: /*
74464: ** Return the P5 value that should be used for a binary comparison
74465: ** opcode (OP_Eq, OP_Ge etc.) used to compare pExpr1 and pExpr2.
74466: */
74467: static u8 binaryCompareP5(Expr *pExpr1, Expr *pExpr2, int jumpIfNull){
74468: u8 aff = (char)sqlite3ExprAffinity(pExpr2);
74469: aff = (u8)sqlite3CompareAffinity(pExpr1, aff) | (u8)jumpIfNull;
74470: return aff;
74471: }
74472:
74473: /*
74474: ** Return a pointer to the collation sequence that should be used by
74475: ** a binary comparison operator comparing pLeft and pRight.
74476: **
74477: ** If the left hand expression has a collating sequence type, then it is
74478: ** used. Otherwise the collation sequence for the right hand expression
74479: ** is used, or the default (BINARY) if neither expression has a collating
74480: ** type.
74481: **
74482: ** Argument pRight (but not pLeft) may be a null pointer. In this case,
74483: ** it is not considered.
74484: */
74485: SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq(
74486: Parse *pParse,
74487: Expr *pLeft,
74488: Expr *pRight
74489: ){
74490: CollSeq *pColl;
74491: assert( pLeft );
74492: if( pLeft->flags & EP_ExpCollate ){
74493: assert( pLeft->pColl );
74494: pColl = pLeft->pColl;
74495: }else if( pRight && pRight->flags & EP_ExpCollate ){
74496: assert( pRight->pColl );
74497: pColl = pRight->pColl;
74498: }else{
74499: pColl = sqlite3ExprCollSeq(pParse, pLeft);
74500: if( !pColl ){
74501: pColl = sqlite3ExprCollSeq(pParse, pRight);
74502: }
74503: }
74504: return pColl;
74505: }
74506:
74507: /*
74508: ** Generate code for a comparison operator.
74509: */
74510: static int codeCompare(
74511: Parse *pParse, /* The parsing (and code generating) context */
74512: Expr *pLeft, /* The left operand */
74513: Expr *pRight, /* The right operand */
74514: int opcode, /* The comparison opcode */
74515: int in1, int in2, /* Register holding operands */
74516: int dest, /* Jump here if true. */
74517: int jumpIfNull /* If true, jump if either operand is NULL */
74518: ){
74519: int p5;
74520: int addr;
74521: CollSeq *p4;
74522:
74523: p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
74524: p5 = binaryCompareP5(pLeft, pRight, jumpIfNull);
74525: addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
74526: (void*)p4, P4_COLLSEQ);
74527: sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
74528: return addr;
74529: }
74530:
74531: #if SQLITE_MAX_EXPR_DEPTH>0
74532: /*
74533: ** Check that argument nHeight is less than or equal to the maximum
74534: ** expression depth allowed. If it is not, leave an error message in
74535: ** pParse.
74536: */
74537: SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
74538: int rc = SQLITE_OK;
74539: int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
74540: if( nHeight>mxHeight ){
74541: sqlite3ErrorMsg(pParse,
74542: "Expression tree is too large (maximum depth %d)", mxHeight
74543: );
74544: rc = SQLITE_ERROR;
74545: }
74546: return rc;
74547: }
74548:
74549: /* The following three functions, heightOfExpr(), heightOfExprList()
74550: ** and heightOfSelect(), are used to determine the maximum height
74551: ** of any expression tree referenced by the structure passed as the
74552: ** first argument.
74553: **
74554: ** If this maximum height is greater than the current value pointed
74555: ** to by pnHeight, the second parameter, then set *pnHeight to that
74556: ** value.
74557: */
74558: static void heightOfExpr(Expr *p, int *pnHeight){
74559: if( p ){
74560: if( p->nHeight>*pnHeight ){
74561: *pnHeight = p->nHeight;
74562: }
74563: }
74564: }
74565: static void heightOfExprList(ExprList *p, int *pnHeight){
74566: if( p ){
74567: int i;
74568: for(i=0; i<p->nExpr; i++){
74569: heightOfExpr(p->a[i].pExpr, pnHeight);
74570: }
74571: }
74572: }
74573: static void heightOfSelect(Select *p, int *pnHeight){
74574: if( p ){
74575: heightOfExpr(p->pWhere, pnHeight);
74576: heightOfExpr(p->pHaving, pnHeight);
74577: heightOfExpr(p->pLimit, pnHeight);
74578: heightOfExpr(p->pOffset, pnHeight);
74579: heightOfExprList(p->pEList, pnHeight);
74580: heightOfExprList(p->pGroupBy, pnHeight);
74581: heightOfExprList(p->pOrderBy, pnHeight);
74582: heightOfSelect(p->pPrior, pnHeight);
74583: }
74584: }
74585:
74586: /*
74587: ** Set the Expr.nHeight variable in the structure passed as an
74588: ** argument. An expression with no children, Expr.pList or
74589: ** Expr.pSelect member has a height of 1. Any other expression
74590: ** has a height equal to the maximum height of any other
74591: ** referenced Expr plus one.
74592: */
74593: static void exprSetHeight(Expr *p){
74594: int nHeight = 0;
74595: heightOfExpr(p->pLeft, &nHeight);
74596: heightOfExpr(p->pRight, &nHeight);
74597: if( ExprHasProperty(p, EP_xIsSelect) ){
74598: heightOfSelect(p->x.pSelect, &nHeight);
74599: }else{
74600: heightOfExprList(p->x.pList, &nHeight);
74601: }
74602: p->nHeight = nHeight + 1;
74603: }
74604:
74605: /*
74606: ** Set the Expr.nHeight variable using the exprSetHeight() function. If
74607: ** the height is greater than the maximum allowed expression depth,
74608: ** leave an error in pParse.
74609: */
74610: SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
74611: exprSetHeight(p);
74612: sqlite3ExprCheckHeight(pParse, p->nHeight);
74613: }
74614:
74615: /*
74616: ** Return the maximum height of any expression tree referenced
74617: ** by the select statement passed as an argument.
74618: */
74619: SQLITE_PRIVATE int sqlite3SelectExprHeight(Select *p){
74620: int nHeight = 0;
74621: heightOfSelect(p, &nHeight);
74622: return nHeight;
74623: }
74624: #else
74625: #define exprSetHeight(y)
74626: #endif /* SQLITE_MAX_EXPR_DEPTH>0 */
74627:
74628: /*
74629: ** This routine is the core allocator for Expr nodes.
74630: **
74631: ** Construct a new expression node and return a pointer to it. Memory
74632: ** for this node and for the pToken argument is a single allocation
74633: ** obtained from sqlite3DbMalloc(). The calling function
74634: ** is responsible for making sure the node eventually gets freed.
74635: **
74636: ** If dequote is true, then the token (if it exists) is dequoted.
74637: ** If dequote is false, no dequoting is performance. The deQuote
74638: ** parameter is ignored if pToken is NULL or if the token does not
74639: ** appear to be quoted. If the quotes were of the form "..." (double-quotes)
74640: ** then the EP_DblQuoted flag is set on the expression node.
74641: **
74642: ** Special case: If op==TK_INTEGER and pToken points to a string that
74643: ** can be translated into a 32-bit integer, then the token is not
74644: ** stored in u.zToken. Instead, the integer values is written
74645: ** into u.iValue and the EP_IntValue flag is set. No extra storage
74646: ** is allocated to hold the integer text and the dequote flag is ignored.
74647: */
74648: SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
74649: sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
74650: int op, /* Expression opcode */
74651: const Token *pToken, /* Token argument. Might be NULL */
74652: int dequote /* True to dequote */
74653: ){
74654: Expr *pNew;
74655: int nExtra = 0;
74656: int iValue = 0;
74657:
74658: if( pToken ){
74659: if( op!=TK_INTEGER || pToken->z==0
74660: || sqlite3GetInt32(pToken->z, &iValue)==0 ){
74661: nExtra = pToken->n+1;
74662: assert( iValue>=0 );
74663: }
74664: }
74665: pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
74666: if( pNew ){
74667: pNew->op = (u8)op;
74668: pNew->iAgg = -1;
74669: if( pToken ){
74670: if( nExtra==0 ){
74671: pNew->flags |= EP_IntValue;
74672: pNew->u.iValue = iValue;
74673: }else{
74674: int c;
74675: pNew->u.zToken = (char*)&pNew[1];
74676: assert( pToken->z!=0 || pToken->n==0 );
74677: if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
74678: pNew->u.zToken[pToken->n] = 0;
74679: if( dequote && nExtra>=3
74680: && ((c = pToken->z[0])=='\'' || c=='"' || c=='[' || c=='`') ){
74681: sqlite3Dequote(pNew->u.zToken);
74682: if( c=='"' ) pNew->flags |= EP_DblQuoted;
74683: }
74684: }
74685: }
74686: #if SQLITE_MAX_EXPR_DEPTH>0
74687: pNew->nHeight = 1;
74688: #endif
74689: }
74690: return pNew;
74691: }
74692:
74693: /*
74694: ** Allocate a new expression node from a zero-terminated token that has
74695: ** already been dequoted.
74696: */
74697: SQLITE_PRIVATE Expr *sqlite3Expr(
74698: sqlite3 *db, /* Handle for sqlite3DbMallocZero() (may be null) */
74699: int op, /* Expression opcode */
74700: const char *zToken /* Token argument. Might be NULL */
74701: ){
74702: Token x;
74703: x.z = zToken;
74704: x.n = zToken ? sqlite3Strlen30(zToken) : 0;
74705: return sqlite3ExprAlloc(db, op, &x, 0);
74706: }
74707:
74708: /*
74709: ** Attach subtrees pLeft and pRight to the Expr node pRoot.
74710: **
74711: ** If pRoot==NULL that means that a memory allocation error has occurred.
74712: ** In that case, delete the subtrees pLeft and pRight.
74713: */
74714: SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(
74715: sqlite3 *db,
74716: Expr *pRoot,
74717: Expr *pLeft,
74718: Expr *pRight
74719: ){
74720: if( pRoot==0 ){
74721: assert( db->mallocFailed );
74722: sqlite3ExprDelete(db, pLeft);
74723: sqlite3ExprDelete(db, pRight);
74724: }else{
74725: if( pRight ){
74726: pRoot->pRight = pRight;
74727: if( pRight->flags & EP_ExpCollate ){
74728: pRoot->flags |= EP_ExpCollate;
74729: pRoot->pColl = pRight->pColl;
74730: }
74731: }
74732: if( pLeft ){
74733: pRoot->pLeft = pLeft;
74734: if( pLeft->flags & EP_ExpCollate ){
74735: pRoot->flags |= EP_ExpCollate;
74736: pRoot->pColl = pLeft->pColl;
74737: }
74738: }
74739: exprSetHeight(pRoot);
74740: }
74741: }
74742:
74743: /*
74744: ** Allocate a Expr node which joins as many as two subtrees.
74745: **
74746: ** One or both of the subtrees can be NULL. Return a pointer to the new
74747: ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
74748: ** free the subtrees and return NULL.
74749: */
74750: SQLITE_PRIVATE Expr *sqlite3PExpr(
74751: Parse *pParse, /* Parsing context */
74752: int op, /* Expression opcode */
74753: Expr *pLeft, /* Left operand */
74754: Expr *pRight, /* Right operand */
74755: const Token *pToken /* Argument token */
74756: ){
74757: Expr *p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
74758: sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
74759: if( p ) {
74760: sqlite3ExprCheckHeight(pParse, p->nHeight);
74761: }
74762: return p;
74763: }
74764:
74765: /*
74766: ** Join two expressions using an AND operator. If either expression is
74767: ** NULL, then just return the other expression.
74768: */
74769: SQLITE_PRIVATE Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
74770: if( pLeft==0 ){
74771: return pRight;
74772: }else if( pRight==0 ){
74773: return pLeft;
74774: }else{
74775: Expr *pNew = sqlite3ExprAlloc(db, TK_AND, 0, 0);
74776: sqlite3ExprAttachSubtrees(db, pNew, pLeft, pRight);
74777: return pNew;
74778: }
74779: }
74780:
74781: /*
74782: ** Construct a new expression node for a function with multiple
74783: ** arguments.
74784: */
74785: SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
74786: Expr *pNew;
74787: sqlite3 *db = pParse->db;
74788: assert( pToken );
74789: pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1);
74790: if( pNew==0 ){
74791: sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */
74792: return 0;
74793: }
74794: pNew->x.pList = pList;
74795: assert( !ExprHasProperty(pNew, EP_xIsSelect) );
74796: sqlite3ExprSetHeight(pParse, pNew);
74797: return pNew;
74798: }
74799:
74800: /*
74801: ** Assign a variable number to an expression that encodes a wildcard
74802: ** in the original SQL statement.
74803: **
74804: ** Wildcards consisting of a single "?" are assigned the next sequential
74805: ** variable number.
74806: **
74807: ** Wildcards of the form "?nnn" are assigned the number "nnn". We make
74808: ** sure "nnn" is not too be to avoid a denial of service attack when
74809: ** the SQL statement comes from an external source.
74810: **
74811: ** Wildcards of the form ":aaa", "@aaa", or "$aaa" are assigned the same number
74812: ** as the previous instance of the same wildcard. Or if this is the first
74813: ** instance of the wildcard, the next sequenial variable number is
74814: ** assigned.
74815: */
74816: SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
74817: sqlite3 *db = pParse->db;
74818: const char *z;
74819:
74820: if( pExpr==0 ) return;
74821: assert( !ExprHasAnyProperty(pExpr, EP_IntValue|EP_Reduced|EP_TokenOnly) );
74822: z = pExpr->u.zToken;
74823: assert( z!=0 );
74824: assert( z[0]!=0 );
74825: if( z[1]==0 ){
74826: /* Wildcard of the form "?". Assign the next variable number */
74827: assert( z[0]=='?' );
74828: pExpr->iColumn = (ynVar)(++pParse->nVar);
74829: }else{
74830: ynVar x = 0;
74831: u32 n = sqlite3Strlen30(z);
74832: if( z[0]=='?' ){
74833: /* Wildcard of the form "?nnn". Convert "nnn" to an integer and
74834: ** use it as the variable number */
74835: i64 i;
74836: int bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8);
74837: pExpr->iColumn = x = (ynVar)i;
74838: testcase( i==0 );
74839: testcase( i==1 );
74840: testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]-1 );
74841: testcase( i==db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] );
74842: if( bOk==0 || i<1 || i>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
74843: sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
74844: db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER]);
74845: x = 0;
74846: }
74847: if( i>pParse->nVar ){
74848: pParse->nVar = (int)i;
74849: }
74850: }else{
74851: /* Wildcards like ":aaa", "$aaa" or "@aaa". Reuse the same variable
74852: ** number as the prior appearance of the same name, or if the name
74853: ** has never appeared before, reuse the same variable number
74854: */
74855: ynVar i;
74856: for(i=0; i<pParse->nzVar; i++){
74857: if( pParse->azVar[i] && memcmp(pParse->azVar[i],z,n+1)==0 ){
74858: pExpr->iColumn = x = (ynVar)i+1;
74859: break;
74860: }
74861: }
74862: if( x==0 ) x = pExpr->iColumn = (ynVar)(++pParse->nVar);
74863: }
74864: if( x>0 ){
74865: if( x>pParse->nzVar ){
74866: char **a;
74867: a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
74868: if( a==0 ) return; /* Error reported through db->mallocFailed */
74869: pParse->azVar = a;
74870: memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0]));
74871: pParse->nzVar = x;
74872: }
74873: if( z[0]!='?' || pParse->azVar[x-1]==0 ){
74874: sqlite3DbFree(db, pParse->azVar[x-1]);
74875: pParse->azVar[x-1] = sqlite3DbStrNDup(db, z, n);
74876: }
74877: }
74878: }
74879: if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
74880: sqlite3ErrorMsg(pParse, "too many SQL variables");
74881: }
74882: }
74883:
74884: /*
74885: ** Recursively delete an expression tree.
74886: */
74887: SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3 *db, Expr *p){
74888: if( p==0 ) return;
74889: /* Sanity check: Assert that the IntValue is non-negative if it exists */
74890: assert( !ExprHasProperty(p, EP_IntValue) || p->u.iValue>=0 );
74891: if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
74892: sqlite3ExprDelete(db, p->pLeft);
74893: sqlite3ExprDelete(db, p->pRight);
74894: if( !ExprHasProperty(p, EP_Reduced) && (p->flags2 & EP2_MallocedToken)!=0 ){
74895: sqlite3DbFree(db, p->u.zToken);
74896: }
74897: if( ExprHasProperty(p, EP_xIsSelect) ){
74898: sqlite3SelectDelete(db, p->x.pSelect);
74899: }else{
74900: sqlite3ExprListDelete(db, p->x.pList);
74901: }
74902: }
74903: if( !ExprHasProperty(p, EP_Static) ){
74904: sqlite3DbFree(db, p);
74905: }
74906: }
74907:
74908: /*
74909: ** Return the number of bytes allocated for the expression structure
74910: ** passed as the first argument. This is always one of EXPR_FULLSIZE,
74911: ** EXPR_REDUCEDSIZE or EXPR_TOKENONLYSIZE.
74912: */
74913: static int exprStructSize(Expr *p){
74914: if( ExprHasProperty(p, EP_TokenOnly) ) return EXPR_TOKENONLYSIZE;
74915: if( ExprHasProperty(p, EP_Reduced) ) return EXPR_REDUCEDSIZE;
74916: return EXPR_FULLSIZE;
74917: }
74918:
74919: /*
74920: ** The dupedExpr*Size() routines each return the number of bytes required
74921: ** to store a copy of an expression or expression tree. They differ in
74922: ** how much of the tree is measured.
74923: **
74924: ** dupedExprStructSize() Size of only the Expr structure
74925: ** dupedExprNodeSize() Size of Expr + space for token
74926: ** dupedExprSize() Expr + token + subtree components
74927: **
74928: ***************************************************************************
74929: **
74930: ** The dupedExprStructSize() function returns two values OR-ed together:
74931: ** (1) the space required for a copy of the Expr structure only and
74932: ** (2) the EP_xxx flags that indicate what the structure size should be.
74933: ** The return values is always one of:
74934: **
74935: ** EXPR_FULLSIZE
74936: ** EXPR_REDUCEDSIZE | EP_Reduced
74937: ** EXPR_TOKENONLYSIZE | EP_TokenOnly
74938: **
74939: ** The size of the structure can be found by masking the return value
74940: ** of this routine with 0xfff. The flags can be found by masking the
74941: ** return value with EP_Reduced|EP_TokenOnly.
74942: **
74943: ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
74944: ** (unreduced) Expr objects as they or originally constructed by the parser.
74945: ** During expression analysis, extra information is computed and moved into
74946: ** later parts of teh Expr object and that extra information might get chopped
74947: ** off if the expression is reduced. Note also that it does not work to
74948: ** make a EXPRDUP_REDUCE copy of a reduced expression. It is only legal
74949: ** to reduce a pristine expression tree from the parser. The implementation
74950: ** of dupedExprStructSize() contain multiple assert() statements that attempt
74951: ** to enforce this constraint.
74952: */
74953: static int dupedExprStructSize(Expr *p, int flags){
74954: int nSize;
74955: assert( flags==EXPRDUP_REDUCE || flags==0 ); /* Only one flag value allowed */
74956: if( 0==(flags&EXPRDUP_REDUCE) ){
74957: nSize = EXPR_FULLSIZE;
74958: }else{
74959: assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
74960: assert( !ExprHasProperty(p, EP_FromJoin) );
74961: assert( (p->flags2 & EP2_MallocedToken)==0 );
74962: assert( (p->flags2 & EP2_Irreducible)==0 );
74963: if( p->pLeft || p->pRight || p->pColl || p->x.pList ){
74964: nSize = EXPR_REDUCEDSIZE | EP_Reduced;
74965: }else{
74966: nSize = EXPR_TOKENONLYSIZE | EP_TokenOnly;
74967: }
74968: }
74969: return nSize;
74970: }
74971:
74972: /*
74973: ** This function returns the space in bytes required to store the copy
74974: ** of the Expr structure and a copy of the Expr.u.zToken string (if that
74975: ** string is defined.)
74976: */
74977: static int dupedExprNodeSize(Expr *p, int flags){
74978: int nByte = dupedExprStructSize(p, flags) & 0xfff;
74979: if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
74980: nByte += sqlite3Strlen30(p->u.zToken)+1;
74981: }
74982: return ROUND8(nByte);
74983: }
74984:
74985: /*
74986: ** Return the number of bytes required to create a duplicate of the
74987: ** expression passed as the first argument. The second argument is a
74988: ** mask containing EXPRDUP_XXX flags.
74989: **
74990: ** The value returned includes space to create a copy of the Expr struct
74991: ** itself and the buffer referred to by Expr.u.zToken, if any.
74992: **
74993: ** If the EXPRDUP_REDUCE flag is set, then the return value includes
74994: ** space to duplicate all Expr nodes in the tree formed by Expr.pLeft
74995: ** and Expr.pRight variables (but not for any structures pointed to or
74996: ** descended from the Expr.x.pList or Expr.x.pSelect variables).
74997: */
74998: static int dupedExprSize(Expr *p, int flags){
74999: int nByte = 0;
75000: if( p ){
75001: nByte = dupedExprNodeSize(p, flags);
75002: if( flags&EXPRDUP_REDUCE ){
75003: nByte += dupedExprSize(p->pLeft, flags) + dupedExprSize(p->pRight, flags);
75004: }
75005: }
75006: return nByte;
75007: }
75008:
75009: /*
75010: ** This function is similar to sqlite3ExprDup(), except that if pzBuffer
75011: ** is not NULL then *pzBuffer is assumed to point to a buffer large enough
75012: ** to store the copy of expression p, the copies of p->u.zToken
75013: ** (if applicable), and the copies of the p->pLeft and p->pRight expressions,
75014: ** if any. Before returning, *pzBuffer is set to the first byte passed the
75015: ** portion of the buffer copied into by this function.
75016: */
75017: static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
75018: Expr *pNew = 0; /* Value to return */
75019: if( p ){
75020: const int isReduced = (flags&EXPRDUP_REDUCE);
75021: u8 *zAlloc;
75022: u32 staticFlag = 0;
75023:
75024: assert( pzBuffer==0 || isReduced );
75025:
75026: /* Figure out where to write the new Expr structure. */
75027: if( pzBuffer ){
75028: zAlloc = *pzBuffer;
75029: staticFlag = EP_Static;
75030: }else{
75031: zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
75032: }
75033: pNew = (Expr *)zAlloc;
75034:
75035: if( pNew ){
75036: /* Set nNewSize to the size allocated for the structure pointed to
75037: ** by pNew. This is either EXPR_FULLSIZE, EXPR_REDUCEDSIZE or
75038: ** EXPR_TOKENONLYSIZE. nToken is set to the number of bytes consumed
75039: ** by the copy of the p->u.zToken string (if any).
75040: */
75041: const unsigned nStructSize = dupedExprStructSize(p, flags);
75042: const int nNewSize = nStructSize & 0xfff;
75043: int nToken;
75044: if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
75045: nToken = sqlite3Strlen30(p->u.zToken) + 1;
75046: }else{
75047: nToken = 0;
75048: }
75049: if( isReduced ){
75050: assert( ExprHasProperty(p, EP_Reduced)==0 );
75051: memcpy(zAlloc, p, nNewSize);
75052: }else{
75053: int nSize = exprStructSize(p);
75054: memcpy(zAlloc, p, nSize);
75055: memset(&zAlloc[nSize], 0, EXPR_FULLSIZE-nSize);
75056: }
75057:
75058: /* Set the EP_Reduced, EP_TokenOnly, and EP_Static flags appropriately. */
75059: pNew->flags &= ~(EP_Reduced|EP_TokenOnly|EP_Static);
75060: pNew->flags |= nStructSize & (EP_Reduced|EP_TokenOnly);
75061: pNew->flags |= staticFlag;
75062:
75063: /* Copy the p->u.zToken string, if any. */
75064: if( nToken ){
75065: char *zToken = pNew->u.zToken = (char*)&zAlloc[nNewSize];
75066: memcpy(zToken, p->u.zToken, nToken);
75067: }
75068:
75069: if( 0==((p->flags|pNew->flags) & EP_TokenOnly) ){
75070: /* Fill in the pNew->x.pSelect or pNew->x.pList member. */
75071: if( ExprHasProperty(p, EP_xIsSelect) ){
75072: pNew->x.pSelect = sqlite3SelectDup(db, p->x.pSelect, isReduced);
75073: }else{
75074: pNew->x.pList = sqlite3ExprListDup(db, p->x.pList, isReduced);
75075: }
75076: }
75077:
75078: /* Fill in pNew->pLeft and pNew->pRight. */
75079: if( ExprHasAnyProperty(pNew, EP_Reduced|EP_TokenOnly) ){
75080: zAlloc += dupedExprNodeSize(p, flags);
75081: if( ExprHasProperty(pNew, EP_Reduced) ){
75082: pNew->pLeft = exprDup(db, p->pLeft, EXPRDUP_REDUCE, &zAlloc);
75083: pNew->pRight = exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc);
75084: }
75085: if( pzBuffer ){
75086: *pzBuffer = zAlloc;
75087: }
75088: }else{
75089: pNew->flags2 = 0;
75090: if( !ExprHasAnyProperty(p, EP_TokenOnly) ){
75091: pNew->pLeft = sqlite3ExprDup(db, p->pLeft, 0);
75092: pNew->pRight = sqlite3ExprDup(db, p->pRight, 0);
75093: }
75094: }
75095:
75096: }
75097: }
75098: return pNew;
75099: }
75100:
75101: /*
75102: ** The following group of routines make deep copies of expressions,
75103: ** expression lists, ID lists, and select statements. The copies can
75104: ** be deleted (by being passed to their respective ...Delete() routines)
75105: ** without effecting the originals.
75106: **
75107: ** The expression list, ID, and source lists return by sqlite3ExprListDup(),
75108: ** sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded
75109: ** by subsequent calls to sqlite*ListAppend() routines.
75110: **
75111: ** Any tables that the SrcList might point to are not duplicated.
75112: **
75113: ** The flags parameter contains a combination of the EXPRDUP_XXX flags.
75114: ** If the EXPRDUP_REDUCE flag is set, then the structure returned is a
75115: ** truncated version of the usual Expr structure that will be stored as
75116: ** part of the in-memory representation of the database schema.
75117: */
75118: SQLITE_PRIVATE Expr *sqlite3ExprDup(sqlite3 *db, Expr *p, int flags){
75119: return exprDup(db, p, flags, 0);
75120: }
75121: SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags){
75122: ExprList *pNew;
75123: struct ExprList_item *pItem, *pOldItem;
75124: int i;
75125: if( p==0 ) return 0;
75126: pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
75127: if( pNew==0 ) return 0;
75128: pNew->iECursor = 0;
75129: pNew->nExpr = pNew->nAlloc = p->nExpr;
75130: pNew->a = pItem = sqlite3DbMallocRaw(db, p->nExpr*sizeof(p->a[0]) );
75131: if( pItem==0 ){
75132: sqlite3DbFree(db, pNew);
75133: return 0;
75134: }
75135: pOldItem = p->a;
75136: for(i=0; i<p->nExpr; i++, pItem++, pOldItem++){
75137: Expr *pOldExpr = pOldItem->pExpr;
75138: pItem->pExpr = sqlite3ExprDup(db, pOldExpr, flags);
75139: pItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
75140: pItem->zSpan = sqlite3DbStrDup(db, pOldItem->zSpan);
75141: pItem->sortOrder = pOldItem->sortOrder;
75142: pItem->done = 0;
75143: pItem->iOrderByCol = pOldItem->iOrderByCol;
75144: pItem->iAlias = pOldItem->iAlias;
75145: }
75146: return pNew;
75147: }
75148:
75149: /*
75150: ** If cursors, triggers, views and subqueries are all omitted from
75151: ** the build, then none of the following routines, except for
75152: ** sqlite3SelectDup(), can be called. sqlite3SelectDup() is sometimes
75153: ** called with a NULL argument.
75154: */
75155: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER) \
75156: || !defined(SQLITE_OMIT_SUBQUERY)
75157: SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
75158: SrcList *pNew;
75159: int i;
75160: int nByte;
75161: if( p==0 ) return 0;
75162: nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
75163: pNew = sqlite3DbMallocRaw(db, nByte );
75164: if( pNew==0 ) return 0;
75165: pNew->nSrc = pNew->nAlloc = p->nSrc;
75166: for(i=0; i<p->nSrc; i++){
75167: struct SrcList_item *pNewItem = &pNew->a[i];
75168: struct SrcList_item *pOldItem = &p->a[i];
75169: Table *pTab;
75170: pNewItem->zDatabase = sqlite3DbStrDup(db, pOldItem->zDatabase);
75171: pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
75172: pNewItem->zAlias = sqlite3DbStrDup(db, pOldItem->zAlias);
75173: pNewItem->jointype = pOldItem->jointype;
75174: pNewItem->iCursor = pOldItem->iCursor;
75175: pNewItem->addrFillSub = pOldItem->addrFillSub;
75176: pNewItem->regReturn = pOldItem->regReturn;
75177: pNewItem->isCorrelated = pOldItem->isCorrelated;
75178: pNewItem->zIndex = sqlite3DbStrDup(db, pOldItem->zIndex);
75179: pNewItem->notIndexed = pOldItem->notIndexed;
75180: pNewItem->pIndex = pOldItem->pIndex;
75181: pTab = pNewItem->pTab = pOldItem->pTab;
75182: if( pTab ){
75183: pTab->nRef++;
75184: }
75185: pNewItem->pSelect = sqlite3SelectDup(db, pOldItem->pSelect, flags);
75186: pNewItem->pOn = sqlite3ExprDup(db, pOldItem->pOn, flags);
75187: pNewItem->pUsing = sqlite3IdListDup(db, pOldItem->pUsing);
75188: pNewItem->colUsed = pOldItem->colUsed;
75189: }
75190: return pNew;
75191: }
75192: SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
75193: IdList *pNew;
75194: int i;
75195: if( p==0 ) return 0;
75196: pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
75197: if( pNew==0 ) return 0;
75198: pNew->nId = pNew->nAlloc = p->nId;
75199: pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
75200: if( pNew->a==0 ){
75201: sqlite3DbFree(db, pNew);
75202: return 0;
75203: }
75204: for(i=0; i<p->nId; i++){
75205: struct IdList_item *pNewItem = &pNew->a[i];
75206: struct IdList_item *pOldItem = &p->a[i];
75207: pNewItem->zName = sqlite3DbStrDup(db, pOldItem->zName);
75208: pNewItem->idx = pOldItem->idx;
75209: }
75210: return pNew;
75211: }
75212: SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
75213: Select *pNew, *pPrior;
75214: if( p==0 ) return 0;
75215: pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
75216: if( pNew==0 ) return 0;
75217: pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
75218: pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
75219: pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags);
75220: pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags);
75221: pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags);
75222: pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags);
75223: pNew->op = p->op;
75224: pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags);
75225: if( pPrior ) pPrior->pNext = pNew;
75226: pNew->pNext = 0;
75227: pNew->pLimit = sqlite3ExprDup(db, p->pLimit, flags);
75228: pNew->pOffset = sqlite3ExprDup(db, p->pOffset, flags);
75229: pNew->iLimit = 0;
75230: pNew->iOffset = 0;
75231: pNew->selFlags = p->selFlags & ~SF_UsesEphemeral;
75232: pNew->pRightmost = 0;
75233: pNew->addrOpenEphm[0] = -1;
75234: pNew->addrOpenEphm[1] = -1;
75235: pNew->addrOpenEphm[2] = -1;
75236: return pNew;
75237: }
75238: #else
75239: SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
75240: assert( p==0 );
75241: return 0;
75242: }
75243: #endif
75244:
75245:
75246: /*
75247: ** Add a new element to the end of an expression list. If pList is
75248: ** initially NULL, then create a new expression list.
75249: **
75250: ** If a memory allocation error occurs, the entire list is freed and
75251: ** NULL is returned. If non-NULL is returned, then it is guaranteed
75252: ** that the new entry was successfully appended.
75253: */
75254: SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(
75255: Parse *pParse, /* Parsing context */
75256: ExprList *pList, /* List to which to append. Might be NULL */
75257: Expr *pExpr /* Expression to be appended. Might be NULL */
75258: ){
75259: sqlite3 *db = pParse->db;
75260: if( pList==0 ){
75261: pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
75262: if( pList==0 ){
75263: goto no_mem;
75264: }
75265: assert( pList->nAlloc==0 );
75266: }
75267: if( pList->nAlloc<=pList->nExpr ){
75268: struct ExprList_item *a;
75269: int n = pList->nAlloc*2 + 4;
75270: a = sqlite3DbRealloc(db, pList->a, n*sizeof(pList->a[0]));
75271: if( a==0 ){
75272: goto no_mem;
75273: }
75274: pList->a = a;
75275: pList->nAlloc = sqlite3DbMallocSize(db, a)/sizeof(a[0]);
75276: }
75277: assert( pList->a!=0 );
75278: if( 1 ){
75279: struct ExprList_item *pItem = &pList->a[pList->nExpr++];
75280: memset(pItem, 0, sizeof(*pItem));
75281: pItem->pExpr = pExpr;
75282: }
75283: return pList;
75284:
75285: no_mem:
75286: /* Avoid leaking memory if malloc has failed. */
75287: sqlite3ExprDelete(db, pExpr);
75288: sqlite3ExprListDelete(db, pList);
75289: return 0;
75290: }
75291:
75292: /*
75293: ** Set the ExprList.a[].zName element of the most recently added item
75294: ** on the expression list.
75295: **
75296: ** pList might be NULL following an OOM error. But pName should never be
75297: ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
75298: ** is set.
75299: */
75300: SQLITE_PRIVATE void sqlite3ExprListSetName(
75301: Parse *pParse, /* Parsing context */
75302: ExprList *pList, /* List to which to add the span. */
75303: Token *pName, /* Name to be added */
75304: int dequote /* True to cause the name to be dequoted */
75305: ){
75306: assert( pList!=0 || pParse->db->mallocFailed!=0 );
75307: if( pList ){
75308: struct ExprList_item *pItem;
75309: assert( pList->nExpr>0 );
75310: pItem = &pList->a[pList->nExpr-1];
75311: assert( pItem->zName==0 );
75312: pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
75313: if( dequote && pItem->zName ) sqlite3Dequote(pItem->zName);
75314: }
75315: }
75316:
75317: /*
75318: ** Set the ExprList.a[].zSpan element of the most recently added item
75319: ** on the expression list.
75320: **
75321: ** pList might be NULL following an OOM error. But pSpan should never be
75322: ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
75323: ** is set.
75324: */
75325: SQLITE_PRIVATE void sqlite3ExprListSetSpan(
75326: Parse *pParse, /* Parsing context */
75327: ExprList *pList, /* List to which to add the span. */
75328: ExprSpan *pSpan /* The span to be added */
75329: ){
75330: sqlite3 *db = pParse->db;
75331: assert( pList!=0 || db->mallocFailed!=0 );
75332: if( pList ){
75333: struct ExprList_item *pItem = &pList->a[pList->nExpr-1];
75334: assert( pList->nExpr>0 );
75335: assert( db->mallocFailed || pItem->pExpr==pSpan->pExpr );
75336: sqlite3DbFree(db, pItem->zSpan);
75337: pItem->zSpan = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
75338: (int)(pSpan->zEnd - pSpan->zStart));
75339: }
75340: }
75341:
75342: /*
75343: ** If the expression list pEList contains more than iLimit elements,
75344: ** leave an error message in pParse.
75345: */
75346: SQLITE_PRIVATE void sqlite3ExprListCheckLength(
75347: Parse *pParse,
75348: ExprList *pEList,
75349: const char *zObject
75350: ){
75351: int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
75352: testcase( pEList && pEList->nExpr==mx );
75353: testcase( pEList && pEList->nExpr==mx+1 );
75354: if( pEList && pEList->nExpr>mx ){
75355: sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
75356: }
75357: }
75358:
75359: /*
75360: ** Delete an entire expression list.
75361: */
75362: SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3 *db, ExprList *pList){
75363: int i;
75364: struct ExprList_item *pItem;
75365: if( pList==0 ) return;
75366: assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) );
75367: assert( pList->nExpr<=pList->nAlloc );
75368: for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
75369: sqlite3ExprDelete(db, pItem->pExpr);
75370: sqlite3DbFree(db, pItem->zName);
75371: sqlite3DbFree(db, pItem->zSpan);
75372: }
75373: sqlite3DbFree(db, pList->a);
75374: sqlite3DbFree(db, pList);
75375: }
75376:
75377: /*
75378: ** These routines are Walker callbacks. Walker.u.pi is a pointer
75379: ** to an integer. These routines are checking an expression to see
75380: ** if it is a constant. Set *Walker.u.pi to 0 if the expression is
75381: ** not constant.
75382: **
75383: ** These callback routines are used to implement the following:
75384: **
75385: ** sqlite3ExprIsConstant()
75386: ** sqlite3ExprIsConstantNotJoin()
75387: ** sqlite3ExprIsConstantOrFunction()
75388: **
75389: */
75390: static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
75391:
75392: /* If pWalker->u.i is 3 then any term of the expression that comes from
75393: ** the ON or USING clauses of a join disqualifies the expression
75394: ** from being considered constant. */
75395: if( pWalker->u.i==3 && ExprHasAnyProperty(pExpr, EP_FromJoin) ){
75396: pWalker->u.i = 0;
75397: return WRC_Abort;
75398: }
75399:
75400: switch( pExpr->op ){
75401: /* Consider functions to be constant if all their arguments are constant
75402: ** and pWalker->u.i==2 */
75403: case TK_FUNCTION:
75404: if( pWalker->u.i==2 ) return 0;
75405: /* Fall through */
75406: case TK_ID:
75407: case TK_COLUMN:
75408: case TK_AGG_FUNCTION:
75409: case TK_AGG_COLUMN:
75410: testcase( pExpr->op==TK_ID );
75411: testcase( pExpr->op==TK_COLUMN );
75412: testcase( pExpr->op==TK_AGG_FUNCTION );
75413: testcase( pExpr->op==TK_AGG_COLUMN );
75414: pWalker->u.i = 0;
75415: return WRC_Abort;
75416: default:
75417: testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
75418: testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
75419: return WRC_Continue;
75420: }
75421: }
75422: static int selectNodeIsConstant(Walker *pWalker, Select *NotUsed){
75423: UNUSED_PARAMETER(NotUsed);
75424: pWalker->u.i = 0;
75425: return WRC_Abort;
75426: }
75427: static int exprIsConst(Expr *p, int initFlag){
75428: Walker w;
75429: w.u.i = initFlag;
75430: w.xExprCallback = exprNodeIsConstant;
75431: w.xSelectCallback = selectNodeIsConstant;
75432: sqlite3WalkExpr(&w, p);
75433: return w.u.i;
75434: }
75435:
75436: /*
75437: ** Walk an expression tree. Return 1 if the expression is constant
75438: ** and 0 if it involves variables or function calls.
75439: **
75440: ** For the purposes of this function, a double-quoted string (ex: "abc")
75441: ** is considered a variable but a single-quoted string (ex: 'abc') is
75442: ** a constant.
75443: */
75444: SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){
75445: return exprIsConst(p, 1);
75446: }
75447:
75448: /*
75449: ** Walk an expression tree. Return 1 if the expression is constant
75450: ** that does no originate from the ON or USING clauses of a join.
75451: ** Return 0 if it involves variables or function calls or terms from
75452: ** an ON or USING clause.
75453: */
75454: SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){
75455: return exprIsConst(p, 3);
75456: }
75457:
75458: /*
75459: ** Walk an expression tree. Return 1 if the expression is constant
75460: ** or a function call with constant arguments. Return and 0 if there
75461: ** are any variables.
75462: **
75463: ** For the purposes of this function, a double-quoted string (ex: "abc")
75464: ** is considered a variable but a single-quoted string (ex: 'abc') is
75465: ** a constant.
75466: */
75467: SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr *p){
75468: return exprIsConst(p, 2);
75469: }
75470:
75471: /*
75472: ** If the expression p codes a constant integer that is small enough
75473: ** to fit in a 32-bit integer, return 1 and put the value of the integer
75474: ** in *pValue. If the expression is not an integer or if it is too big
75475: ** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged.
75476: */
75477: SQLITE_PRIVATE int sqlite3ExprIsInteger(Expr *p, int *pValue){
75478: int rc = 0;
75479:
75480: /* If an expression is an integer literal that fits in a signed 32-bit
75481: ** integer, then the EP_IntValue flag will have already been set */
75482: assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
75483: || sqlite3GetInt32(p->u.zToken, &rc)==0 );
75484:
75485: if( p->flags & EP_IntValue ){
75486: *pValue = p->u.iValue;
75487: return 1;
75488: }
75489: switch( p->op ){
75490: case TK_UPLUS: {
75491: rc = sqlite3ExprIsInteger(p->pLeft, pValue);
75492: break;
75493: }
75494: case TK_UMINUS: {
75495: int v;
75496: if( sqlite3ExprIsInteger(p->pLeft, &v) ){
75497: *pValue = -v;
75498: rc = 1;
75499: }
75500: break;
75501: }
75502: default: break;
75503: }
75504: return rc;
75505: }
75506:
75507: /*
75508: ** Return FALSE if there is no chance that the expression can be NULL.
75509: **
75510: ** If the expression might be NULL or if the expression is too complex
75511: ** to tell return TRUE.
75512: **
75513: ** This routine is used as an optimization, to skip OP_IsNull opcodes
75514: ** when we know that a value cannot be NULL. Hence, a false positive
75515: ** (returning TRUE when in fact the expression can never be NULL) might
75516: ** be a small performance hit but is otherwise harmless. On the other
75517: ** hand, a false negative (returning FALSE when the result could be NULL)
75518: ** will likely result in an incorrect answer. So when in doubt, return
75519: ** TRUE.
75520: */
75521: SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
75522: u8 op;
75523: while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
75524: op = p->op;
75525: if( op==TK_REGISTER ) op = p->op2;
75526: switch( op ){
75527: case TK_INTEGER:
75528: case TK_STRING:
75529: case TK_FLOAT:
75530: case TK_BLOB:
75531: return 0;
75532: default:
75533: return 1;
75534: }
75535: }
75536:
75537: /*
75538: ** Generate an OP_IsNull instruction that tests register iReg and jumps
75539: ** to location iDest if the value in iReg is NULL. The value in iReg
75540: ** was computed by pExpr. If we can look at pExpr at compile-time and
75541: ** determine that it can never generate a NULL, then the OP_IsNull operation
75542: ** can be omitted.
75543: */
75544: SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(
75545: Vdbe *v, /* The VDBE under construction */
75546: const Expr *pExpr, /* Only generate OP_IsNull if this expr can be NULL */
75547: int iReg, /* Test the value in this register for NULL */
75548: int iDest /* Jump here if the value is null */
75549: ){
75550: if( sqlite3ExprCanBeNull(pExpr) ){
75551: sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iDest);
75552: }
75553: }
75554:
75555: /*
75556: ** Return TRUE if the given expression is a constant which would be
75557: ** unchanged by OP_Affinity with the affinity given in the second
75558: ** argument.
75559: **
75560: ** This routine is used to determine if the OP_Affinity operation
75561: ** can be omitted. When in doubt return FALSE. A false negative
75562: ** is harmless. A false positive, however, can result in the wrong
75563: ** answer.
75564: */
75565: SQLITE_PRIVATE int sqlite3ExprNeedsNoAffinityChange(const Expr *p, char aff){
75566: u8 op;
75567: if( aff==SQLITE_AFF_NONE ) return 1;
75568: while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
75569: op = p->op;
75570: if( op==TK_REGISTER ) op = p->op2;
75571: switch( op ){
75572: case TK_INTEGER: {
75573: return aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC;
75574: }
75575: case TK_FLOAT: {
75576: return aff==SQLITE_AFF_REAL || aff==SQLITE_AFF_NUMERIC;
75577: }
75578: case TK_STRING: {
75579: return aff==SQLITE_AFF_TEXT;
75580: }
75581: case TK_BLOB: {
75582: return 1;
75583: }
75584: case TK_COLUMN: {
75585: assert( p->iTable>=0 ); /* p cannot be part of a CHECK constraint */
75586: return p->iColumn<0
75587: && (aff==SQLITE_AFF_INTEGER || aff==SQLITE_AFF_NUMERIC);
75588: }
75589: default: {
75590: return 0;
75591: }
75592: }
75593: }
75594:
75595: /*
75596: ** Return TRUE if the given string is a row-id column name.
75597: */
75598: SQLITE_PRIVATE int sqlite3IsRowid(const char *z){
75599: if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
75600: if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
75601: if( sqlite3StrICmp(z, "OID")==0 ) return 1;
75602: return 0;
75603: }
75604:
75605: /*
75606: ** Return true if we are able to the IN operator optimization on a
75607: ** query of the form
75608: **
75609: ** x IN (SELECT ...)
75610: **
75611: ** Where the SELECT... clause is as specified by the parameter to this
75612: ** routine.
75613: **
75614: ** The Select object passed in has already been preprocessed and no
75615: ** errors have been found.
75616: */
75617: #ifndef SQLITE_OMIT_SUBQUERY
75618: static int isCandidateForInOpt(Select *p){
75619: SrcList *pSrc;
75620: ExprList *pEList;
75621: Table *pTab;
75622: if( p==0 ) return 0; /* right-hand side of IN is SELECT */
75623: if( p->pPrior ) return 0; /* Not a compound SELECT */
75624: if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
75625: testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
75626: testcase( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
75627: return 0; /* No DISTINCT keyword and no aggregate functions */
75628: }
75629: assert( p->pGroupBy==0 ); /* Has no GROUP BY clause */
75630: if( p->pLimit ) return 0; /* Has no LIMIT clause */
75631: assert( p->pOffset==0 ); /* No LIMIT means no OFFSET */
75632: if( p->pWhere ) return 0; /* Has no WHERE clause */
75633: pSrc = p->pSrc;
75634: assert( pSrc!=0 );
75635: if( pSrc->nSrc!=1 ) return 0; /* Single term in FROM clause */
75636: if( pSrc->a[0].pSelect ) return 0; /* FROM is not a subquery or view */
75637: pTab = pSrc->a[0].pTab;
75638: if( NEVER(pTab==0) ) return 0;
75639: assert( pTab->pSelect==0 ); /* FROM clause is not a view */
75640: if( IsVirtual(pTab) ) return 0; /* FROM clause not a virtual table */
75641: pEList = p->pEList;
75642: if( pEList->nExpr!=1 ) return 0; /* One column in the result set */
75643: if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
75644: return 1;
75645: }
75646: #endif /* SQLITE_OMIT_SUBQUERY */
75647:
75648: /*
75649: ** Code an OP_Once instruction and allocate space for its flag. Return the
75650: ** address of the new instruction.
75651: */
75652: SQLITE_PRIVATE int sqlite3CodeOnce(Parse *pParse){
75653: Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
75654: return sqlite3VdbeAddOp1(v, OP_Once, pParse->nOnce++);
75655: }
75656:
75657: /*
75658: ** This function is used by the implementation of the IN (...) operator.
75659: ** It's job is to find or create a b-tree structure that may be used
75660: ** either to test for membership of the (...) set or to iterate through
75661: ** its members, skipping duplicates.
75662: **
75663: ** The index of the cursor opened on the b-tree (database table, database index
75664: ** or ephermal table) is stored in pX->iTable before this function returns.
75665: ** The returned value of this function indicates the b-tree type, as follows:
75666: **
75667: ** IN_INDEX_ROWID - The cursor was opened on a database table.
75668: ** IN_INDEX_INDEX - The cursor was opened on a database index.
75669: ** IN_INDEX_EPH - The cursor was opened on a specially created and
75670: ** populated epheremal table.
75671: **
75672: ** An existing b-tree may only be used if the SELECT is of the simple
75673: ** form:
75674: **
75675: ** SELECT <column> FROM <table>
75676: **
75677: ** If the prNotFound parameter is 0, then the b-tree will be used to iterate
75678: ** through the set members, skipping any duplicates. In this case an
75679: ** epheremal table must be used unless the selected <column> is guaranteed
75680: ** to be unique - either because it is an INTEGER PRIMARY KEY or it
75681: ** has a UNIQUE constraint or UNIQUE index.
75682: **
75683: ** If the prNotFound parameter is not 0, then the b-tree will be used
75684: ** for fast set membership tests. In this case an epheremal table must
75685: ** be used unless <column> is an INTEGER PRIMARY KEY or an index can
75686: ** be found with <column> as its left-most column.
75687: **
75688: ** When the b-tree is being used for membership tests, the calling function
75689: ** needs to know whether or not the structure contains an SQL NULL
75690: ** value in order to correctly evaluate expressions like "X IN (Y, Z)".
75691: ** If there is any chance that the (...) might contain a NULL value at
75692: ** runtime, then a register is allocated and the register number written
75693: ** to *prNotFound. If there is no chance that the (...) contains a
75694: ** NULL value, then *prNotFound is left unchanged.
75695: **
75696: ** If a register is allocated and its location stored in *prNotFound, then
75697: ** its initial value is NULL. If the (...) does not remain constant
75698: ** for the duration of the query (i.e. the SELECT within the (...)
75699: ** is a correlated subquery) then the value of the allocated register is
75700: ** reset to NULL each time the subquery is rerun. This allows the
75701: ** caller to use vdbe code equivalent to the following:
75702: **
75703: ** if( register==NULL ){
75704: ** has_null = <test if data structure contains null>
75705: ** register = 1
75706: ** }
75707: **
75708: ** in order to avoid running the <test if data structure contains null>
75709: ** test more often than is necessary.
75710: */
75711: #ifndef SQLITE_OMIT_SUBQUERY
75712: SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
75713: Select *p; /* SELECT to the right of IN operator */
75714: int eType = 0; /* Type of RHS table. IN_INDEX_* */
75715: int iTab = pParse->nTab++; /* Cursor of the RHS table */
75716: int mustBeUnique = (prNotFound==0); /* True if RHS must be unique */
75717: Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
75718:
75719: assert( pX->op==TK_IN );
75720:
75721: /* Check to see if an existing table or index can be used to
75722: ** satisfy the query. This is preferable to generating a new
75723: ** ephemeral table.
75724: */
75725: p = (ExprHasProperty(pX, EP_xIsSelect) ? pX->x.pSelect : 0);
75726: if( ALWAYS(pParse->nErr==0) && isCandidateForInOpt(p) ){
75727: sqlite3 *db = pParse->db; /* Database connection */
75728: Table *pTab; /* Table <table>. */
75729: Expr *pExpr; /* Expression <column> */
75730: int iCol; /* Index of column <column> */
75731: int iDb; /* Database idx for pTab */
75732:
75733: assert( p ); /* Because of isCandidateForInOpt(p) */
75734: assert( p->pEList!=0 ); /* Because of isCandidateForInOpt(p) */
75735: assert( p->pEList->a[0].pExpr!=0 ); /* Because of isCandidateForInOpt(p) */
75736: assert( p->pSrc!=0 ); /* Because of isCandidateForInOpt(p) */
75737: pTab = p->pSrc->a[0].pTab;
75738: pExpr = p->pEList->a[0].pExpr;
75739: iCol = pExpr->iColumn;
75740:
75741: /* Code an OP_VerifyCookie and OP_TableLock for <table>. */
75742: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
75743: sqlite3CodeVerifySchema(pParse, iDb);
75744: sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
75745:
75746: /* This function is only called from two places. In both cases the vdbe
75747: ** has already been allocated. So assume sqlite3GetVdbe() is always
75748: ** successful here.
75749: */
75750: assert(v);
75751: if( iCol<0 ){
75752: int iAddr;
75753:
75754: iAddr = sqlite3CodeOnce(pParse);
75755:
75756: sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
75757: eType = IN_INDEX_ROWID;
75758:
75759: sqlite3VdbeJumpHere(v, iAddr);
75760: }else{
75761: Index *pIdx; /* Iterator variable */
75762:
75763: /* The collation sequence used by the comparison. If an index is to
75764: ** be used in place of a temp-table, it must be ordered according
75765: ** to this collation sequence. */
75766: CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
75767:
75768: /* Check that the affinity that will be used to perform the
75769: ** comparison is the same as the affinity of the column. If
75770: ** it is not, it is not possible to use any index.
75771: */
75772: char aff = comparisonAffinity(pX);
75773: int affinity_ok = (pTab->aCol[iCol].affinity==aff||aff==SQLITE_AFF_NONE);
75774:
75775: for(pIdx=pTab->pIndex; pIdx && eType==0 && affinity_ok; pIdx=pIdx->pNext){
75776: if( (pIdx->aiColumn[0]==iCol)
75777: && sqlite3FindCollSeq(db, ENC(db), pIdx->azColl[0], 0)==pReq
75778: && (!mustBeUnique || (pIdx->nColumn==1 && pIdx->onError!=OE_None))
75779: ){
75780: int iAddr;
75781: char *pKey;
75782:
75783: pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
75784: iAddr = sqlite3CodeOnce(pParse);
75785:
75786: sqlite3VdbeAddOp4(v, OP_OpenRead, iTab, pIdx->tnum, iDb,
75787: pKey,P4_KEYINFO_HANDOFF);
75788: VdbeComment((v, "%s", pIdx->zName));
75789: eType = IN_INDEX_INDEX;
75790:
75791: sqlite3VdbeJumpHere(v, iAddr);
75792: if( prNotFound && !pTab->aCol[iCol].notNull ){
75793: *prNotFound = ++pParse->nMem;
75794: sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
75795: }
75796: }
75797: }
75798: }
75799: }
75800:
75801: if( eType==0 ){
75802: /* Could not found an existing table or index to use as the RHS b-tree.
75803: ** We will have to generate an ephemeral table to do the job.
75804: */
75805: double savedNQueryLoop = pParse->nQueryLoop;
75806: int rMayHaveNull = 0;
75807: eType = IN_INDEX_EPH;
75808: if( prNotFound ){
75809: *prNotFound = rMayHaveNull = ++pParse->nMem;
75810: sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound);
75811: }else{
75812: testcase( pParse->nQueryLoop>(double)1 );
75813: pParse->nQueryLoop = (double)1;
75814: if( pX->pLeft->iColumn<0 && !ExprHasAnyProperty(pX, EP_xIsSelect) ){
75815: eType = IN_INDEX_ROWID;
75816: }
75817: }
75818: sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
75819: pParse->nQueryLoop = savedNQueryLoop;
75820: }else{
75821: pX->iTable = iTab;
75822: }
75823: return eType;
75824: }
75825: #endif
75826:
75827: /*
75828: ** Generate code for scalar subqueries used as a subquery expression, EXISTS,
75829: ** or IN operators. Examples:
75830: **
75831: ** (SELECT a FROM b) -- subquery
75832: ** EXISTS (SELECT a FROM b) -- EXISTS subquery
75833: ** x IN (4,5,11) -- IN operator with list on right-hand side
75834: ** x IN (SELECT a FROM b) -- IN operator with subquery on the right
75835: **
75836: ** The pExpr parameter describes the expression that contains the IN
75837: ** operator or subquery.
75838: **
75839: ** If parameter isRowid is non-zero, then expression pExpr is guaranteed
75840: ** to be of the form "<rowid> IN (?, ?, ?)", where <rowid> is a reference
75841: ** to some integer key column of a table B-Tree. In this case, use an
75842: ** intkey B-Tree to store the set of IN(...) values instead of the usual
75843: ** (slower) variable length keys B-Tree.
75844: **
75845: ** If rMayHaveNull is non-zero, that means that the operation is an IN
75846: ** (not a SELECT or EXISTS) and that the RHS might contains NULLs.
75847: ** Furthermore, the IN is in a WHERE clause and that we really want
75848: ** to iterate over the RHS of the IN operator in order to quickly locate
75849: ** all corresponding LHS elements. All this routine does is initialize
75850: ** the register given by rMayHaveNull to NULL. Calling routines will take
75851: ** care of changing this register value to non-NULL if the RHS is NULL-free.
75852: **
75853: ** If rMayHaveNull is zero, that means that the subquery is being used
75854: ** for membership testing only. There is no need to initialize any
75855: ** registers to indicate the presense or absence of NULLs on the RHS.
75856: **
75857: ** For a SELECT or EXISTS operator, return the register that holds the
75858: ** result. For IN operators or if an error occurs, the return value is 0.
75859: */
75860: #ifndef SQLITE_OMIT_SUBQUERY
75861: SQLITE_PRIVATE int sqlite3CodeSubselect(
75862: Parse *pParse, /* Parsing context */
75863: Expr *pExpr, /* The IN, SELECT, or EXISTS operator */
75864: int rMayHaveNull, /* Register that records whether NULLs exist in RHS */
75865: int isRowid /* If true, LHS of IN operator is a rowid */
75866: ){
75867: int testAddr = -1; /* One-time test address */
75868: int rReg = 0; /* Register storing resulting */
75869: Vdbe *v = sqlite3GetVdbe(pParse);
75870: if( NEVER(v==0) ) return 0;
75871: sqlite3ExprCachePush(pParse);
75872:
75873: /* This code must be run in its entirety every time it is encountered
75874: ** if any of the following is true:
75875: **
75876: ** * The right-hand side is a correlated subquery
75877: ** * The right-hand side is an expression list containing variables
75878: ** * We are inside a trigger
75879: **
75880: ** If all of the above are false, then we can run this code just once
75881: ** save the results, and reuse the same result on subsequent invocations.
75882: */
75883: if( !ExprHasAnyProperty(pExpr, EP_VarSelect) ){
75884: testAddr = sqlite3CodeOnce(pParse);
75885: }
75886:
75887: #ifndef SQLITE_OMIT_EXPLAIN
75888: if( pParse->explain==2 ){
75889: char *zMsg = sqlite3MPrintf(
75890: pParse->db, "EXECUTE %s%s SUBQUERY %d", testAddr>=0?"":"CORRELATED ",
75891: pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
75892: );
75893: sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
75894: }
75895: #endif
75896:
75897: switch( pExpr->op ){
75898: case TK_IN: {
75899: char affinity; /* Affinity of the LHS of the IN */
75900: KeyInfo keyInfo; /* Keyinfo for the generated table */
75901: int addr; /* Address of OP_OpenEphemeral instruction */
75902: Expr *pLeft = pExpr->pLeft; /* the LHS of the IN operator */
75903:
75904: if( rMayHaveNull ){
75905: sqlite3VdbeAddOp2(v, OP_Null, 0, rMayHaveNull);
75906: }
75907:
75908: affinity = sqlite3ExprAffinity(pLeft);
75909:
75910: /* Whether this is an 'x IN(SELECT...)' or an 'x IN(<exprlist>)'
75911: ** expression it is handled the same way. An ephemeral table is
75912: ** filled with single-field index keys representing the results
75913: ** from the SELECT or the <exprlist>.
75914: **
75915: ** If the 'x' expression is a column value, or the SELECT...
75916: ** statement returns a column value, then the affinity of that
75917: ** column is used to build the index keys. If both 'x' and the
75918: ** SELECT... statement are columns, then numeric affinity is used
75919: ** if either column has NUMERIC or INTEGER affinity. If neither
75920: ** 'x' nor the SELECT... statement are columns, then numeric affinity
75921: ** is used.
75922: */
75923: pExpr->iTable = pParse->nTab++;
75924: addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, !isRowid);
75925: if( rMayHaveNull==0 ) sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
75926: memset(&keyInfo, 0, sizeof(keyInfo));
75927: keyInfo.nField = 1;
75928:
75929: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
75930: /* Case 1: expr IN (SELECT ...)
75931: **
75932: ** Generate code to write the results of the select into the temporary
75933: ** table allocated and opened above.
75934: */
75935: SelectDest dest;
75936: ExprList *pEList;
75937:
75938: assert( !isRowid );
75939: sqlite3SelectDestInit(&dest, SRT_Set, pExpr->iTable);
75940: dest.affinity = (u8)affinity;
75941: assert( (pExpr->iTable&0x0000FFFF)==pExpr->iTable );
75942: pExpr->x.pSelect->iLimit = 0;
75943: if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
75944: return 0;
75945: }
75946: pEList = pExpr->x.pSelect->pEList;
75947: if( ALWAYS(pEList!=0 && pEList->nExpr>0) ){
75948: keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
75949: pEList->a[0].pExpr);
75950: }
75951: }else if( ALWAYS(pExpr->x.pList!=0) ){
75952: /* Case 2: expr IN (exprlist)
75953: **
75954: ** For each expression, build an index key from the evaluation and
75955: ** store it in the temporary table. If <expr> is a column, then use
75956: ** that columns affinity when building index keys. If <expr> is not
75957: ** a column, use numeric affinity.
75958: */
75959: int i;
75960: ExprList *pList = pExpr->x.pList;
75961: struct ExprList_item *pItem;
75962: int r1, r2, r3;
75963:
75964: if( !affinity ){
75965: affinity = SQLITE_AFF_NONE;
75966: }
75967: keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
75968:
75969: /* Loop through each expression in <exprlist>. */
75970: r1 = sqlite3GetTempReg(pParse);
75971: r2 = sqlite3GetTempReg(pParse);
75972: sqlite3VdbeAddOp2(v, OP_Null, 0, r2);
75973: for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
75974: Expr *pE2 = pItem->pExpr;
75975: int iValToIns;
75976:
75977: /* If the expression is not constant then we will need to
75978: ** disable the test that was generated above that makes sure
75979: ** this code only executes once. Because for a non-constant
75980: ** expression we need to rerun this code each time.
75981: */
75982: if( testAddr>=0 && !sqlite3ExprIsConstant(pE2) ){
75983: sqlite3VdbeChangeToNoop(v, testAddr);
75984: testAddr = -1;
75985: }
75986:
75987: /* Evaluate the expression and insert it into the temp table */
75988: if( isRowid && sqlite3ExprIsInteger(pE2, &iValToIns) ){
75989: sqlite3VdbeAddOp3(v, OP_InsertInt, pExpr->iTable, r2, iValToIns);
75990: }else{
75991: r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
75992: if( isRowid ){
75993: sqlite3VdbeAddOp2(v, OP_MustBeInt, r3,
75994: sqlite3VdbeCurrentAddr(v)+2);
75995: sqlite3VdbeAddOp3(v, OP_Insert, pExpr->iTable, r2, r3);
75996: }else{
75997: sqlite3VdbeAddOp4(v, OP_MakeRecord, r3, 1, r2, &affinity, 1);
75998: sqlite3ExprCacheAffinityChange(pParse, r3, 1);
75999: sqlite3VdbeAddOp2(v, OP_IdxInsert, pExpr->iTable, r2);
76000: }
76001: }
76002: }
76003: sqlite3ReleaseTempReg(pParse, r1);
76004: sqlite3ReleaseTempReg(pParse, r2);
76005: }
76006: if( !isRowid ){
76007: sqlite3VdbeChangeP4(v, addr, (void *)&keyInfo, P4_KEYINFO);
76008: }
76009: break;
76010: }
76011:
76012: case TK_EXISTS:
76013: case TK_SELECT:
76014: default: {
76015: /* If this has to be a scalar SELECT. Generate code to put the
76016: ** value of this select in a memory cell and record the number
76017: ** of the memory cell in iColumn. If this is an EXISTS, write
76018: ** an integer 0 (not exists) or 1 (exists) into a memory cell
76019: ** and record that memory cell in iColumn.
76020: */
76021: Select *pSel; /* SELECT statement to encode */
76022: SelectDest dest; /* How to deal with SELECt result */
76023:
76024: testcase( pExpr->op==TK_EXISTS );
76025: testcase( pExpr->op==TK_SELECT );
76026: assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
76027:
76028: assert( ExprHasProperty(pExpr, EP_xIsSelect) );
76029: pSel = pExpr->x.pSelect;
76030: sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
76031: if( pExpr->op==TK_SELECT ){
76032: dest.eDest = SRT_Mem;
76033: sqlite3VdbeAddOp2(v, OP_Null, 0, dest.iParm);
76034: VdbeComment((v, "Init subquery result"));
76035: }else{
76036: dest.eDest = SRT_Exists;
76037: sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iParm);
76038: VdbeComment((v, "Init EXISTS result"));
76039: }
76040: sqlite3ExprDelete(pParse->db, pSel->pLimit);
76041: pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0,
76042: &sqlite3IntTokens[1]);
76043: pSel->iLimit = 0;
76044: if( sqlite3Select(pParse, pSel, &dest) ){
76045: return 0;
76046: }
76047: rReg = dest.iParm;
76048: ExprSetIrreducible(pExpr);
76049: break;
76050: }
76051: }
76052:
76053: if( testAddr>=0 ){
76054: sqlite3VdbeJumpHere(v, testAddr);
76055: }
76056: sqlite3ExprCachePop(pParse, 1);
76057:
76058: return rReg;
76059: }
76060: #endif /* SQLITE_OMIT_SUBQUERY */
76061:
76062: #ifndef SQLITE_OMIT_SUBQUERY
76063: /*
76064: ** Generate code for an IN expression.
76065: **
76066: ** x IN (SELECT ...)
76067: ** x IN (value, value, ...)
76068: **
76069: ** The left-hand side (LHS) is a scalar expression. The right-hand side (RHS)
76070: ** is an array of zero or more values. The expression is true if the LHS is
76071: ** contained within the RHS. The value of the expression is unknown (NULL)
76072: ** if the LHS is NULL or if the LHS is not contained within the RHS and the
76073: ** RHS contains one or more NULL values.
76074: **
76075: ** This routine generates code will jump to destIfFalse if the LHS is not
76076: ** contained within the RHS. If due to NULLs we cannot determine if the LHS
76077: ** is contained in the RHS then jump to destIfNull. If the LHS is contained
76078: ** within the RHS then fall through.
76079: */
76080: static void sqlite3ExprCodeIN(
76081: Parse *pParse, /* Parsing and code generating context */
76082: Expr *pExpr, /* The IN expression */
76083: int destIfFalse, /* Jump here if LHS is not contained in the RHS */
76084: int destIfNull /* Jump here if the results are unknown due to NULLs */
76085: ){
76086: int rRhsHasNull = 0; /* Register that is true if RHS contains NULL values */
76087: char affinity; /* Comparison affinity to use */
76088: int eType; /* Type of the RHS */
76089: int r1; /* Temporary use register */
76090: Vdbe *v; /* Statement under construction */
76091:
76092: /* Compute the RHS. After this step, the table with cursor
76093: ** pExpr->iTable will contains the values that make up the RHS.
76094: */
76095: v = pParse->pVdbe;
76096: assert( v!=0 ); /* OOM detected prior to this routine */
76097: VdbeNoopComment((v, "begin IN expr"));
76098: eType = sqlite3FindInIndex(pParse, pExpr, &rRhsHasNull);
76099:
76100: /* Figure out the affinity to use to create a key from the results
76101: ** of the expression. affinityStr stores a static string suitable for
76102: ** P4 of OP_MakeRecord.
76103: */
76104: affinity = comparisonAffinity(pExpr);
76105:
76106: /* Code the LHS, the <expr> from "<expr> IN (...)".
76107: */
76108: sqlite3ExprCachePush(pParse);
76109: r1 = sqlite3GetTempReg(pParse);
76110: sqlite3ExprCode(pParse, pExpr->pLeft, r1);
76111:
76112: /* If the LHS is NULL, then the result is either false or NULL depending
76113: ** on whether the RHS is empty or not, respectively.
76114: */
76115: if( destIfNull==destIfFalse ){
76116: /* Shortcut for the common case where the false and NULL outcomes are
76117: ** the same. */
76118: sqlite3VdbeAddOp2(v, OP_IsNull, r1, destIfNull);
76119: }else{
76120: int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, r1);
76121: sqlite3VdbeAddOp2(v, OP_Rewind, pExpr->iTable, destIfFalse);
76122: sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
76123: sqlite3VdbeJumpHere(v, addr1);
76124: }
76125:
76126: if( eType==IN_INDEX_ROWID ){
76127: /* In this case, the RHS is the ROWID of table b-tree
76128: */
76129: sqlite3VdbeAddOp2(v, OP_MustBeInt, r1, destIfFalse);
76130: sqlite3VdbeAddOp3(v, OP_NotExists, pExpr->iTable, destIfFalse, r1);
76131: }else{
76132: /* In this case, the RHS is an index b-tree.
76133: */
76134: sqlite3VdbeAddOp4(v, OP_Affinity, r1, 1, 0, &affinity, 1);
76135:
76136: /* If the set membership test fails, then the result of the
76137: ** "x IN (...)" expression must be either 0 or NULL. If the set
76138: ** contains no NULL values, then the result is 0. If the set
76139: ** contains one or more NULL values, then the result of the
76140: ** expression is also NULL.
76141: */
76142: if( rRhsHasNull==0 || destIfFalse==destIfNull ){
76143: /* This branch runs if it is known at compile time that the RHS
76144: ** cannot contain NULL values. This happens as the result
76145: ** of a "NOT NULL" constraint in the database schema.
76146: **
76147: ** Also run this branch if NULL is equivalent to FALSE
76148: ** for this particular IN operator.
76149: */
76150: sqlite3VdbeAddOp4Int(v, OP_NotFound, pExpr->iTable, destIfFalse, r1, 1);
76151:
76152: }else{
76153: /* In this branch, the RHS of the IN might contain a NULL and
76154: ** the presence of a NULL on the RHS makes a difference in the
76155: ** outcome.
76156: */
76157: int j1, j2, j3;
76158:
76159: /* First check to see if the LHS is contained in the RHS. If so,
76160: ** then the presence of NULLs in the RHS does not matter, so jump
76161: ** over all of the code that follows.
76162: */
76163: j1 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, r1, 1);
76164:
76165: /* Here we begin generating code that runs if the LHS is not
76166: ** contained within the RHS. Generate additional code that
76167: ** tests the RHS for NULLs. If the RHS contains a NULL then
76168: ** jump to destIfNull. If there are no NULLs in the RHS then
76169: ** jump to destIfFalse.
76170: */
76171: j2 = sqlite3VdbeAddOp1(v, OP_NotNull, rRhsHasNull);
76172: j3 = sqlite3VdbeAddOp4Int(v, OP_Found, pExpr->iTable, 0, rRhsHasNull, 1);
76173: sqlite3VdbeAddOp2(v, OP_Integer, -1, rRhsHasNull);
76174: sqlite3VdbeJumpHere(v, j3);
76175: sqlite3VdbeAddOp2(v, OP_AddImm, rRhsHasNull, 1);
76176: sqlite3VdbeJumpHere(v, j2);
76177:
76178: /* Jump to the appropriate target depending on whether or not
76179: ** the RHS contains a NULL
76180: */
76181: sqlite3VdbeAddOp2(v, OP_If, rRhsHasNull, destIfNull);
76182: sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
76183:
76184: /* The OP_Found at the top of this branch jumps here when true,
76185: ** causing the overall IN expression evaluation to fall through.
76186: */
76187: sqlite3VdbeJumpHere(v, j1);
76188: }
76189: }
76190: sqlite3ReleaseTempReg(pParse, r1);
76191: sqlite3ExprCachePop(pParse, 1);
76192: VdbeComment((v, "end IN expr"));
76193: }
76194: #endif /* SQLITE_OMIT_SUBQUERY */
76195:
76196: /*
76197: ** Duplicate an 8-byte value
76198: */
76199: static char *dup8bytes(Vdbe *v, const char *in){
76200: char *out = sqlite3DbMallocRaw(sqlite3VdbeDb(v), 8);
76201: if( out ){
76202: memcpy(out, in, 8);
76203: }
76204: return out;
76205: }
76206:
76207: #ifndef SQLITE_OMIT_FLOATING_POINT
76208: /*
76209: ** Generate an instruction that will put the floating point
76210: ** value described by z[0..n-1] into register iMem.
76211: **
76212: ** The z[] string will probably not be zero-terminated. But the
76213: ** z[n] character is guaranteed to be something that does not look
76214: ** like the continuation of the number.
76215: */
76216: static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
76217: if( ALWAYS(z!=0) ){
76218: double value;
76219: char *zV;
76220: sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
76221: assert( !sqlite3IsNaN(value) ); /* The new AtoF never returns NaN */
76222: if( negateFlag ) value = -value;
76223: zV = dup8bytes(v, (char*)&value);
76224: sqlite3VdbeAddOp4(v, OP_Real, 0, iMem, 0, zV, P4_REAL);
76225: }
76226: }
76227: #endif
76228:
76229:
76230: /*
76231: ** Generate an instruction that will put the integer describe by
76232: ** text z[0..n-1] into register iMem.
76233: **
76234: ** Expr.u.zToken is always UTF8 and zero-terminated.
76235: */
76236: static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
76237: Vdbe *v = pParse->pVdbe;
76238: if( pExpr->flags & EP_IntValue ){
76239: int i = pExpr->u.iValue;
76240: assert( i>=0 );
76241: if( negFlag ) i = -i;
76242: sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
76243: }else{
76244: int c;
76245: i64 value;
76246: const char *z = pExpr->u.zToken;
76247: assert( z!=0 );
76248: c = sqlite3Atoi64(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
76249: if( c==0 || (c==2 && negFlag) ){
76250: char *zV;
76251: if( negFlag ){ value = c==2 ? SMALLEST_INT64 : -value; }
76252: zV = dup8bytes(v, (char*)&value);
76253: sqlite3VdbeAddOp4(v, OP_Int64, 0, iMem, 0, zV, P4_INT64);
76254: }else{
76255: #ifdef SQLITE_OMIT_FLOATING_POINT
76256: sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
76257: #else
76258: codeReal(v, z, negFlag, iMem);
76259: #endif
76260: }
76261: }
76262: }
76263:
76264: /*
76265: ** Clear a cache entry.
76266: */
76267: static void cacheEntryClear(Parse *pParse, struct yColCache *p){
76268: if( p->tempReg ){
76269: if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
76270: pParse->aTempReg[pParse->nTempReg++] = p->iReg;
76271: }
76272: p->tempReg = 0;
76273: }
76274: }
76275:
76276:
76277: /*
76278: ** Record in the column cache that a particular column from a
76279: ** particular table is stored in a particular register.
76280: */
76281: SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
76282: int i;
76283: int minLru;
76284: int idxLru;
76285: struct yColCache *p;
76286:
76287: assert( iReg>0 ); /* Register numbers are always positive */
76288: assert( iCol>=-1 && iCol<32768 ); /* Finite column numbers */
76289:
76290: /* The SQLITE_ColumnCache flag disables the column cache. This is used
76291: ** for testing only - to verify that SQLite always gets the same answer
76292: ** with and without the column cache.
76293: */
76294: if( pParse->db->flags & SQLITE_ColumnCache ) return;
76295:
76296: /* First replace any existing entry.
76297: **
76298: ** Actually, the way the column cache is currently used, we are guaranteed
76299: ** that the object will never already be in cache. Verify this guarantee.
76300: */
76301: #ifndef NDEBUG
76302: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76303: #if 0 /* This code wold remove the entry from the cache if it existed */
76304: if( p->iReg && p->iTable==iTab && p->iColumn==iCol ){
76305: cacheEntryClear(pParse, p);
76306: p->iLevel = pParse->iCacheLevel;
76307: p->iReg = iReg;
76308: p->lru = pParse->iCacheCnt++;
76309: return;
76310: }
76311: #endif
76312: assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
76313: }
76314: #endif
76315:
76316: /* Find an empty slot and replace it */
76317: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76318: if( p->iReg==0 ){
76319: p->iLevel = pParse->iCacheLevel;
76320: p->iTable = iTab;
76321: p->iColumn = iCol;
76322: p->iReg = iReg;
76323: p->tempReg = 0;
76324: p->lru = pParse->iCacheCnt++;
76325: return;
76326: }
76327: }
76328:
76329: /* Replace the last recently used */
76330: minLru = 0x7fffffff;
76331: idxLru = -1;
76332: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76333: if( p->lru<minLru ){
76334: idxLru = i;
76335: minLru = p->lru;
76336: }
76337: }
76338: if( ALWAYS(idxLru>=0) ){
76339: p = &pParse->aColCache[idxLru];
76340: p->iLevel = pParse->iCacheLevel;
76341: p->iTable = iTab;
76342: p->iColumn = iCol;
76343: p->iReg = iReg;
76344: p->tempReg = 0;
76345: p->lru = pParse->iCacheCnt++;
76346: return;
76347: }
76348: }
76349:
76350: /*
76351: ** Indicate that registers between iReg..iReg+nReg-1 are being overwritten.
76352: ** Purge the range of registers from the column cache.
76353: */
76354: SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
76355: int i;
76356: int iLast = iReg + nReg - 1;
76357: struct yColCache *p;
76358: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76359: int r = p->iReg;
76360: if( r>=iReg && r<=iLast ){
76361: cacheEntryClear(pParse, p);
76362: p->iReg = 0;
76363: }
76364: }
76365: }
76366:
76367: /*
76368: ** Remember the current column cache context. Any new entries added
76369: ** added to the column cache after this call are removed when the
76370: ** corresponding pop occurs.
76371: */
76372: SQLITE_PRIVATE void sqlite3ExprCachePush(Parse *pParse){
76373: pParse->iCacheLevel++;
76374: }
76375:
76376: /*
76377: ** Remove from the column cache any entries that were added since the
76378: ** the previous N Push operations. In other words, restore the cache
76379: ** to the state it was in N Pushes ago.
76380: */
76381: SQLITE_PRIVATE void sqlite3ExprCachePop(Parse *pParse, int N){
76382: int i;
76383: struct yColCache *p;
76384: assert( N>0 );
76385: assert( pParse->iCacheLevel>=N );
76386: pParse->iCacheLevel -= N;
76387: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76388: if( p->iReg && p->iLevel>pParse->iCacheLevel ){
76389: cacheEntryClear(pParse, p);
76390: p->iReg = 0;
76391: }
76392: }
76393: }
76394:
76395: /*
76396: ** When a cached column is reused, make sure that its register is
76397: ** no longer available as a temp register. ticket #3879: that same
76398: ** register might be in the cache in multiple places, so be sure to
76399: ** get them all.
76400: */
76401: static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
76402: int i;
76403: struct yColCache *p;
76404: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76405: if( p->iReg==iReg ){
76406: p->tempReg = 0;
76407: }
76408: }
76409: }
76410:
76411: /*
76412: ** Generate code to extract the value of the iCol-th column of a table.
76413: */
76414: SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(
76415: Vdbe *v, /* The VDBE under construction */
76416: Table *pTab, /* The table containing the value */
76417: int iTabCur, /* The cursor for this table */
76418: int iCol, /* Index of the column to extract */
76419: int regOut /* Extract the valud into this register */
76420: ){
76421: if( iCol<0 || iCol==pTab->iPKey ){
76422: sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
76423: }else{
76424: int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
76425: sqlite3VdbeAddOp3(v, op, iTabCur, iCol, regOut);
76426: }
76427: if( iCol>=0 ){
76428: sqlite3ColumnDefault(v, pTab, iCol, regOut);
76429: }
76430: }
76431:
76432: /*
76433: ** Generate code that will extract the iColumn-th column from
76434: ** table pTab and store the column value in a register. An effort
76435: ** is made to store the column value in register iReg, but this is
76436: ** not guaranteed. The location of the column value is returned.
76437: **
76438: ** There must be an open cursor to pTab in iTable when this routine
76439: ** is called. If iColumn<0 then code is generated that extracts the rowid.
76440: */
76441: SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(
76442: Parse *pParse, /* Parsing and code generating context */
76443: Table *pTab, /* Description of the table we are reading from */
76444: int iColumn, /* Index of the table column */
76445: int iTable, /* The cursor pointing to the table */
76446: int iReg /* Store results here */
76447: ){
76448: Vdbe *v = pParse->pVdbe;
76449: int i;
76450: struct yColCache *p;
76451:
76452: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76453: if( p->iReg>0 && p->iTable==iTable && p->iColumn==iColumn ){
76454: p->lru = pParse->iCacheCnt++;
76455: sqlite3ExprCachePinRegister(pParse, p->iReg);
76456: return p->iReg;
76457: }
76458: }
76459: assert( v!=0 );
76460: sqlite3ExprCodeGetColumnOfTable(v, pTab, iTable, iColumn, iReg);
76461: sqlite3ExprCacheStore(pParse, iTable, iColumn, iReg);
76462: return iReg;
76463: }
76464:
76465: /*
76466: ** Clear all column cache entries.
76467: */
76468: SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){
76469: int i;
76470: struct yColCache *p;
76471:
76472: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76473: if( p->iReg ){
76474: cacheEntryClear(pParse, p);
76475: p->iReg = 0;
76476: }
76477: }
76478: }
76479:
76480: /*
76481: ** Record the fact that an affinity change has occurred on iCount
76482: ** registers starting with iStart.
76483: */
76484: SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
76485: sqlite3ExprCacheRemove(pParse, iStart, iCount);
76486: }
76487:
76488: /*
76489: ** Generate code to move content from registers iFrom...iFrom+nReg-1
76490: ** over to iTo..iTo+nReg-1. Keep the column cache up-to-date.
76491: */
76492: SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
76493: int i;
76494: struct yColCache *p;
76495: if( NEVER(iFrom==iTo) ) return;
76496: sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
76497: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76498: int x = p->iReg;
76499: if( x>=iFrom && x<iFrom+nReg ){
76500: p->iReg += iTo-iFrom;
76501: }
76502: }
76503: }
76504:
76505: /*
76506: ** Generate code to copy content from registers iFrom...iFrom+nReg-1
76507: ** over to iTo..iTo+nReg-1.
76508: */
76509: SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
76510: int i;
76511: if( NEVER(iFrom==iTo) ) return;
76512: for(i=0; i<nReg; i++){
76513: sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
76514: }
76515: }
76516:
76517: #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
76518: /*
76519: ** Return true if any register in the range iFrom..iTo (inclusive)
76520: ** is used as part of the column cache.
76521: **
76522: ** This routine is used within assert() and testcase() macros only
76523: ** and does not appear in a normal build.
76524: */
76525: static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
76526: int i;
76527: struct yColCache *p;
76528: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
76529: int r = p->iReg;
76530: if( r>=iFrom && r<=iTo ) return 1; /*NO_TEST*/
76531: }
76532: return 0;
76533: }
76534: #endif /* SQLITE_DEBUG || SQLITE_COVERAGE_TEST */
76535:
76536: /*
76537: ** Generate code into the current Vdbe to evaluate the given
76538: ** expression. Attempt to store the results in register "target".
76539: ** Return the register where results are stored.
76540: **
76541: ** With this routine, there is no guarantee that results will
76542: ** be stored in target. The result might be stored in some other
76543: ** register if it is convenient to do so. The calling function
76544: ** must check the return code and move the results to the desired
76545: ** register.
76546: */
76547: SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
76548: Vdbe *v = pParse->pVdbe; /* The VM under construction */
76549: int op; /* The opcode being coded */
76550: int inReg = target; /* Results stored in register inReg */
76551: int regFree1 = 0; /* If non-zero free this temporary register */
76552: int regFree2 = 0; /* If non-zero free this temporary register */
76553: int r1, r2, r3, r4; /* Various register numbers */
76554: sqlite3 *db = pParse->db; /* The database connection */
76555:
76556: assert( target>0 && target<=pParse->nMem );
76557: if( v==0 ){
76558: assert( pParse->db->mallocFailed );
76559: return 0;
76560: }
76561:
76562: if( pExpr==0 ){
76563: op = TK_NULL;
76564: }else{
76565: op = pExpr->op;
76566: }
76567: switch( op ){
76568: case TK_AGG_COLUMN: {
76569: AggInfo *pAggInfo = pExpr->pAggInfo;
76570: struct AggInfo_col *pCol = &pAggInfo->aCol[pExpr->iAgg];
76571: if( !pAggInfo->directMode ){
76572: assert( pCol->iMem>0 );
76573: inReg = pCol->iMem;
76574: break;
76575: }else if( pAggInfo->useSortingIdx ){
76576: sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
76577: pCol->iSorterColumn, target);
76578: break;
76579: }
76580: /* Otherwise, fall thru into the TK_COLUMN case */
76581: }
76582: case TK_COLUMN: {
76583: if( pExpr->iTable<0 ){
76584: /* This only happens when coding check constraints */
76585: assert( pParse->ckBase>0 );
76586: inReg = pExpr->iColumn + pParse->ckBase;
76587: }else{
76588: inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
76589: pExpr->iColumn, pExpr->iTable, target);
76590: }
76591: break;
76592: }
76593: case TK_INTEGER: {
76594: codeInteger(pParse, pExpr, 0, target);
76595: break;
76596: }
76597: #ifndef SQLITE_OMIT_FLOATING_POINT
76598: case TK_FLOAT: {
76599: assert( !ExprHasProperty(pExpr, EP_IntValue) );
76600: codeReal(v, pExpr->u.zToken, 0, target);
76601: break;
76602: }
76603: #endif
76604: case TK_STRING: {
76605: assert( !ExprHasProperty(pExpr, EP_IntValue) );
76606: sqlite3VdbeAddOp4(v, OP_String8, 0, target, 0, pExpr->u.zToken, 0);
76607: break;
76608: }
76609: case TK_NULL: {
76610: sqlite3VdbeAddOp2(v, OP_Null, 0, target);
76611: break;
76612: }
76613: #ifndef SQLITE_OMIT_BLOB_LITERAL
76614: case TK_BLOB: {
76615: int n;
76616: const char *z;
76617: char *zBlob;
76618: assert( !ExprHasProperty(pExpr, EP_IntValue) );
76619: assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
76620: assert( pExpr->u.zToken[1]=='\'' );
76621: z = &pExpr->u.zToken[2];
76622: n = sqlite3Strlen30(z) - 1;
76623: assert( z[n]=='\'' );
76624: zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
76625: sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
76626: break;
76627: }
76628: #endif
76629: case TK_VARIABLE: {
76630: assert( !ExprHasProperty(pExpr, EP_IntValue) );
76631: assert( pExpr->u.zToken!=0 );
76632: assert( pExpr->u.zToken[0]!=0 );
76633: sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
76634: if( pExpr->u.zToken[1]!=0 ){
76635: assert( pExpr->u.zToken[0]=='?'
76636: || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 );
76637: sqlite3VdbeChangeP4(v, -1, pParse->azVar[pExpr->iColumn-1], P4_STATIC);
76638: }
76639: break;
76640: }
76641: case TK_REGISTER: {
76642: inReg = pExpr->iTable;
76643: break;
76644: }
76645: case TK_AS: {
76646: inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
76647: break;
76648: }
76649: #ifndef SQLITE_OMIT_CAST
76650: case TK_CAST: {
76651: /* Expressions of the form: CAST(pLeft AS token) */
76652: int aff, to_op;
76653: inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
76654: assert( !ExprHasProperty(pExpr, EP_IntValue) );
76655: aff = sqlite3AffinityType(pExpr->u.zToken);
76656: to_op = aff - SQLITE_AFF_TEXT + OP_ToText;
76657: assert( to_op==OP_ToText || aff!=SQLITE_AFF_TEXT );
76658: assert( to_op==OP_ToBlob || aff!=SQLITE_AFF_NONE );
76659: assert( to_op==OP_ToNumeric || aff!=SQLITE_AFF_NUMERIC );
76660: assert( to_op==OP_ToInt || aff!=SQLITE_AFF_INTEGER );
76661: assert( to_op==OP_ToReal || aff!=SQLITE_AFF_REAL );
76662: testcase( to_op==OP_ToText );
76663: testcase( to_op==OP_ToBlob );
76664: testcase( to_op==OP_ToNumeric );
76665: testcase( to_op==OP_ToInt );
76666: testcase( to_op==OP_ToReal );
76667: if( inReg!=target ){
76668: sqlite3VdbeAddOp2(v, OP_SCopy, inReg, target);
76669: inReg = target;
76670: }
76671: sqlite3VdbeAddOp1(v, to_op, inReg);
76672: testcase( usedAsColumnCache(pParse, inReg, inReg) );
76673: sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
76674: break;
76675: }
76676: #endif /* SQLITE_OMIT_CAST */
76677: case TK_LT:
76678: case TK_LE:
76679: case TK_GT:
76680: case TK_GE:
76681: case TK_NE:
76682: case TK_EQ: {
76683: assert( TK_LT==OP_Lt );
76684: assert( TK_LE==OP_Le );
76685: assert( TK_GT==OP_Gt );
76686: assert( TK_GE==OP_Ge );
76687: assert( TK_EQ==OP_Eq );
76688: assert( TK_NE==OP_Ne );
76689: testcase( op==TK_LT );
76690: testcase( op==TK_LE );
76691: testcase( op==TK_GT );
76692: testcase( op==TK_GE );
76693: testcase( op==TK_EQ );
76694: testcase( op==TK_NE );
76695: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76696: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
76697: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
76698: r1, r2, inReg, SQLITE_STOREP2);
76699: testcase( regFree1==0 );
76700: testcase( regFree2==0 );
76701: break;
76702: }
76703: case TK_IS:
76704: case TK_ISNOT: {
76705: testcase( op==TK_IS );
76706: testcase( op==TK_ISNOT );
76707: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76708: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
76709: op = (op==TK_IS) ? TK_EQ : TK_NE;
76710: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
76711: r1, r2, inReg, SQLITE_STOREP2 | SQLITE_NULLEQ);
76712: testcase( regFree1==0 );
76713: testcase( regFree2==0 );
76714: break;
76715: }
76716: case TK_AND:
76717: case TK_OR:
76718: case TK_PLUS:
76719: case TK_STAR:
76720: case TK_MINUS:
76721: case TK_REM:
76722: case TK_BITAND:
76723: case TK_BITOR:
76724: case TK_SLASH:
76725: case TK_LSHIFT:
76726: case TK_RSHIFT:
76727: case TK_CONCAT: {
76728: assert( TK_AND==OP_And );
76729: assert( TK_OR==OP_Or );
76730: assert( TK_PLUS==OP_Add );
76731: assert( TK_MINUS==OP_Subtract );
76732: assert( TK_REM==OP_Remainder );
76733: assert( TK_BITAND==OP_BitAnd );
76734: assert( TK_BITOR==OP_BitOr );
76735: assert( TK_SLASH==OP_Divide );
76736: assert( TK_LSHIFT==OP_ShiftLeft );
76737: assert( TK_RSHIFT==OP_ShiftRight );
76738: assert( TK_CONCAT==OP_Concat );
76739: testcase( op==TK_AND );
76740: testcase( op==TK_OR );
76741: testcase( op==TK_PLUS );
76742: testcase( op==TK_MINUS );
76743: testcase( op==TK_REM );
76744: testcase( op==TK_BITAND );
76745: testcase( op==TK_BITOR );
76746: testcase( op==TK_SLASH );
76747: testcase( op==TK_LSHIFT );
76748: testcase( op==TK_RSHIFT );
76749: testcase( op==TK_CONCAT );
76750: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76751: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
76752: sqlite3VdbeAddOp3(v, op, r2, r1, target);
76753: testcase( regFree1==0 );
76754: testcase( regFree2==0 );
76755: break;
76756: }
76757: case TK_UMINUS: {
76758: Expr *pLeft = pExpr->pLeft;
76759: assert( pLeft );
76760: if( pLeft->op==TK_INTEGER ){
76761: codeInteger(pParse, pLeft, 1, target);
76762: #ifndef SQLITE_OMIT_FLOATING_POINT
76763: }else if( pLeft->op==TK_FLOAT ){
76764: assert( !ExprHasProperty(pExpr, EP_IntValue) );
76765: codeReal(v, pLeft->u.zToken, 1, target);
76766: #endif
76767: }else{
76768: regFree1 = r1 = sqlite3GetTempReg(pParse);
76769: sqlite3VdbeAddOp2(v, OP_Integer, 0, r1);
76770: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
76771: sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
76772: testcase( regFree2==0 );
76773: }
76774: inReg = target;
76775: break;
76776: }
76777: case TK_BITNOT:
76778: case TK_NOT: {
76779: assert( TK_BITNOT==OP_BitNot );
76780: assert( TK_NOT==OP_Not );
76781: testcase( op==TK_BITNOT );
76782: testcase( op==TK_NOT );
76783: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76784: testcase( regFree1==0 );
76785: inReg = target;
76786: sqlite3VdbeAddOp2(v, op, r1, inReg);
76787: break;
76788: }
76789: case TK_ISNULL:
76790: case TK_NOTNULL: {
76791: int addr;
76792: assert( TK_ISNULL==OP_IsNull );
76793: assert( TK_NOTNULL==OP_NotNull );
76794: testcase( op==TK_ISNULL );
76795: testcase( op==TK_NOTNULL );
76796: sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
76797: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
76798: testcase( regFree1==0 );
76799: addr = sqlite3VdbeAddOp1(v, op, r1);
76800: sqlite3VdbeAddOp2(v, OP_AddImm, target, -1);
76801: sqlite3VdbeJumpHere(v, addr);
76802: break;
76803: }
76804: case TK_AGG_FUNCTION: {
76805: AggInfo *pInfo = pExpr->pAggInfo;
76806: if( pInfo==0 ){
76807: assert( !ExprHasProperty(pExpr, EP_IntValue) );
76808: sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
76809: }else{
76810: inReg = pInfo->aFunc[pExpr->iAgg].iMem;
76811: }
76812: break;
76813: }
76814: case TK_CONST_FUNC:
76815: case TK_FUNCTION: {
76816: ExprList *pFarg; /* List of function arguments */
76817: int nFarg; /* Number of function arguments */
76818: FuncDef *pDef; /* The function definition object */
76819: int nId; /* Length of the function name in bytes */
76820: const char *zId; /* The function name */
76821: int constMask = 0; /* Mask of function arguments that are constant */
76822: int i; /* Loop counter */
76823: u8 enc = ENC(db); /* The text encoding used by this database */
76824: CollSeq *pColl = 0; /* A collating sequence */
76825:
76826: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
76827: testcase( op==TK_CONST_FUNC );
76828: testcase( op==TK_FUNCTION );
76829: if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
76830: pFarg = 0;
76831: }else{
76832: pFarg = pExpr->x.pList;
76833: }
76834: nFarg = pFarg ? pFarg->nExpr : 0;
76835: assert( !ExprHasProperty(pExpr, EP_IntValue) );
76836: zId = pExpr->u.zToken;
76837: nId = sqlite3Strlen30(zId);
76838: pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0);
76839: if( pDef==0 ){
76840: sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
76841: break;
76842: }
76843:
76844: /* Attempt a direct implementation of the built-in COALESCE() and
76845: ** IFNULL() functions. This avoids unnecessary evalation of
76846: ** arguments past the first non-NULL argument.
76847: */
76848: if( pDef->flags & SQLITE_FUNC_COALESCE ){
76849: int endCoalesce = sqlite3VdbeMakeLabel(v);
76850: assert( nFarg>=2 );
76851: sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
76852: for(i=1; i<nFarg; i++){
76853: sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
76854: sqlite3ExprCacheRemove(pParse, target, 1);
76855: sqlite3ExprCachePush(pParse);
76856: sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
76857: sqlite3ExprCachePop(pParse, 1);
76858: }
76859: sqlite3VdbeResolveLabel(v, endCoalesce);
76860: break;
76861: }
76862:
76863:
76864: if( pFarg ){
76865: r1 = sqlite3GetTempRange(pParse, nFarg);
76866: sqlite3ExprCachePush(pParse); /* Ticket 2ea2425d34be */
76867: sqlite3ExprCodeExprList(pParse, pFarg, r1, 1);
76868: sqlite3ExprCachePop(pParse, 1); /* Ticket 2ea2425d34be */
76869: }else{
76870: r1 = 0;
76871: }
76872: #ifndef SQLITE_OMIT_VIRTUALTABLE
76873: /* Possibly overload the function if the first argument is
76874: ** a virtual table column.
76875: **
76876: ** For infix functions (LIKE, GLOB, REGEXP, and MATCH) use the
76877: ** second argument, not the first, as the argument to test to
76878: ** see if it is a column in a virtual table. This is done because
76879: ** the left operand of infix functions (the operand we want to
76880: ** control overloading) ends up as the second argument to the
76881: ** function. The expression "A glob B" is equivalent to
76882: ** "glob(B,A). We want to use the A in "A glob B" to test
76883: ** for function overloading. But we use the B term in "glob(B,A)".
76884: */
76885: if( nFarg>=2 && (pExpr->flags & EP_InfixFunc) ){
76886: pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
76887: }else if( nFarg>0 ){
76888: pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
76889: }
76890: #endif
76891: for(i=0; i<nFarg; i++){
76892: if( i<32 && sqlite3ExprIsConstant(pFarg->a[i].pExpr) ){
76893: constMask |= (1<<i);
76894: }
76895: if( (pDef->flags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
76896: pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
76897: }
76898: }
76899: if( pDef->flags & SQLITE_FUNC_NEEDCOLL ){
76900: if( !pColl ) pColl = db->pDfltColl;
76901: sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
76902: }
76903: sqlite3VdbeAddOp4(v, OP_Function, constMask, r1, target,
76904: (char*)pDef, P4_FUNCDEF);
76905: sqlite3VdbeChangeP5(v, (u8)nFarg);
76906: if( nFarg ){
76907: sqlite3ReleaseTempRange(pParse, r1, nFarg);
76908: }
76909: break;
76910: }
76911: #ifndef SQLITE_OMIT_SUBQUERY
76912: case TK_EXISTS:
76913: case TK_SELECT: {
76914: testcase( op==TK_EXISTS );
76915: testcase( op==TK_SELECT );
76916: inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
76917: break;
76918: }
76919: case TK_IN: {
76920: int destIfFalse = sqlite3VdbeMakeLabel(v);
76921: int destIfNull = sqlite3VdbeMakeLabel(v);
76922: sqlite3VdbeAddOp2(v, OP_Null, 0, target);
76923: sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
76924: sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
76925: sqlite3VdbeResolveLabel(v, destIfFalse);
76926: sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
76927: sqlite3VdbeResolveLabel(v, destIfNull);
76928: break;
76929: }
76930: #endif /* SQLITE_OMIT_SUBQUERY */
76931:
76932:
76933: /*
76934: ** x BETWEEN y AND z
76935: **
76936: ** This is equivalent to
76937: **
76938: ** x>=y AND x<=z
76939: **
76940: ** X is stored in pExpr->pLeft.
76941: ** Y is stored in pExpr->pList->a[0].pExpr.
76942: ** Z is stored in pExpr->pList->a[1].pExpr.
76943: */
76944: case TK_BETWEEN: {
76945: Expr *pLeft = pExpr->pLeft;
76946: struct ExprList_item *pLItem = pExpr->x.pList->a;
76947: Expr *pRight = pLItem->pExpr;
76948:
76949: r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1);
76950: r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2);
76951: testcase( regFree1==0 );
76952: testcase( regFree2==0 );
76953: r3 = sqlite3GetTempReg(pParse);
76954: r4 = sqlite3GetTempReg(pParse);
76955: codeCompare(pParse, pLeft, pRight, OP_Ge,
76956: r1, r2, r3, SQLITE_STOREP2);
76957: pLItem++;
76958: pRight = pLItem->pExpr;
76959: sqlite3ReleaseTempReg(pParse, regFree2);
76960: r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2);
76961: testcase( regFree2==0 );
76962: codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
76963: sqlite3VdbeAddOp3(v, OP_And, r3, r4, target);
76964: sqlite3ReleaseTempReg(pParse, r3);
76965: sqlite3ReleaseTempReg(pParse, r4);
76966: break;
76967: }
76968: case TK_UPLUS: {
76969: inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
76970: break;
76971: }
76972:
76973: case TK_TRIGGER: {
76974: /* If the opcode is TK_TRIGGER, then the expression is a reference
76975: ** to a column in the new.* or old.* pseudo-tables available to
76976: ** trigger programs. In this case Expr.iTable is set to 1 for the
76977: ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
76978: ** is set to the column of the pseudo-table to read, or to -1 to
76979: ** read the rowid field.
76980: **
76981: ** The expression is implemented using an OP_Param opcode. The p1
76982: ** parameter is set to 0 for an old.rowid reference, or to (i+1)
76983: ** to reference another column of the old.* pseudo-table, where
76984: ** i is the index of the column. For a new.rowid reference, p1 is
76985: ** set to (n+1), where n is the number of columns in each pseudo-table.
76986: ** For a reference to any other column in the new.* pseudo-table, p1
76987: ** is set to (n+2+i), where n and i are as defined previously. For
76988: ** example, if the table on which triggers are being fired is
76989: ** declared as:
76990: **
76991: ** CREATE TABLE t1(a, b);
76992: **
76993: ** Then p1 is interpreted as follows:
76994: **
76995: ** p1==0 -> old.rowid p1==3 -> new.rowid
76996: ** p1==1 -> old.a p1==4 -> new.a
76997: ** p1==2 -> old.b p1==5 -> new.b
76998: */
76999: Table *pTab = pExpr->pTab;
77000: int p1 = pExpr->iTable * (pTab->nCol+1) + 1 + pExpr->iColumn;
77001:
77002: assert( pExpr->iTable==0 || pExpr->iTable==1 );
77003: assert( pExpr->iColumn>=-1 && pExpr->iColumn<pTab->nCol );
77004: assert( pTab->iPKey<0 || pExpr->iColumn!=pTab->iPKey );
77005: assert( p1>=0 && p1<(pTab->nCol*2+2) );
77006:
77007: sqlite3VdbeAddOp2(v, OP_Param, p1, target);
77008: VdbeComment((v, "%s.%s -> $%d",
77009: (pExpr->iTable ? "new" : "old"),
77010: (pExpr->iColumn<0 ? "rowid" : pExpr->pTab->aCol[pExpr->iColumn].zName),
77011: target
77012: ));
77013:
77014: #ifndef SQLITE_OMIT_FLOATING_POINT
77015: /* If the column has REAL affinity, it may currently be stored as an
77016: ** integer. Use OP_RealAffinity to make sure it is really real. */
77017: if( pExpr->iColumn>=0
77018: && pTab->aCol[pExpr->iColumn].affinity==SQLITE_AFF_REAL
77019: ){
77020: sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
77021: }
77022: #endif
77023: break;
77024: }
77025:
77026:
77027: /*
77028: ** Form A:
77029: ** CASE x WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
77030: **
77031: ** Form B:
77032: ** CASE WHEN e1 THEN r1 WHEN e2 THEN r2 ... WHEN eN THEN rN ELSE y END
77033: **
77034: ** Form A is can be transformed into the equivalent form B as follows:
77035: ** CASE WHEN x=e1 THEN r1 WHEN x=e2 THEN r2 ...
77036: ** WHEN x=eN THEN rN ELSE y END
77037: **
77038: ** X (if it exists) is in pExpr->pLeft.
77039: ** Y is in pExpr->pRight. The Y is also optional. If there is no
77040: ** ELSE clause and no other term matches, then the result of the
77041: ** exprssion is NULL.
77042: ** Ei is in pExpr->pList->a[i*2] and Ri is pExpr->pList->a[i*2+1].
77043: **
77044: ** The result of the expression is the Ri for the first matching Ei,
77045: ** or if there is no matching Ei, the ELSE term Y, or if there is
77046: ** no ELSE term, NULL.
77047: */
77048: default: assert( op==TK_CASE ); {
77049: int endLabel; /* GOTO label for end of CASE stmt */
77050: int nextCase; /* GOTO label for next WHEN clause */
77051: int nExpr; /* 2x number of WHEN terms */
77052: int i; /* Loop counter */
77053: ExprList *pEList; /* List of WHEN terms */
77054: struct ExprList_item *aListelem; /* Array of WHEN terms */
77055: Expr opCompare; /* The X==Ei expression */
77056: Expr cacheX; /* Cached expression X */
77057: Expr *pX; /* The X expression */
77058: Expr *pTest = 0; /* X==Ei (form A) or just Ei (form B) */
77059: VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )
77060:
77061: assert( !ExprHasProperty(pExpr, EP_xIsSelect) && pExpr->x.pList );
77062: assert((pExpr->x.pList->nExpr % 2) == 0);
77063: assert(pExpr->x.pList->nExpr > 0);
77064: pEList = pExpr->x.pList;
77065: aListelem = pEList->a;
77066: nExpr = pEList->nExpr;
77067: endLabel = sqlite3VdbeMakeLabel(v);
77068: if( (pX = pExpr->pLeft)!=0 ){
77069: cacheX = *pX;
77070: testcase( pX->op==TK_COLUMN );
77071: testcase( pX->op==TK_REGISTER );
77072: cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, ®Free1);
77073: testcase( regFree1==0 );
77074: cacheX.op = TK_REGISTER;
77075: opCompare.op = TK_EQ;
77076: opCompare.pLeft = &cacheX;
77077: pTest = &opCompare;
77078: /* Ticket b351d95f9cd5ef17e9d9dbae18f5ca8611190001:
77079: ** The value in regFree1 might get SCopy-ed into the file result.
77080: ** So make sure that the regFree1 register is not reused for other
77081: ** purposes and possibly overwritten. */
77082: regFree1 = 0;
77083: }
77084: for(i=0; i<nExpr; i=i+2){
77085: sqlite3ExprCachePush(pParse);
77086: if( pX ){
77087: assert( pTest!=0 );
77088: opCompare.pRight = aListelem[i].pExpr;
77089: }else{
77090: pTest = aListelem[i].pExpr;
77091: }
77092: nextCase = sqlite3VdbeMakeLabel(v);
77093: testcase( pTest->op==TK_COLUMN );
77094: sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
77095: testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
77096: testcase( aListelem[i+1].pExpr->op==TK_REGISTER );
77097: sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
77098: sqlite3VdbeAddOp2(v, OP_Goto, 0, endLabel);
77099: sqlite3ExprCachePop(pParse, 1);
77100: sqlite3VdbeResolveLabel(v, nextCase);
77101: }
77102: if( pExpr->pRight ){
77103: sqlite3ExprCachePush(pParse);
77104: sqlite3ExprCode(pParse, pExpr->pRight, target);
77105: sqlite3ExprCachePop(pParse, 1);
77106: }else{
77107: sqlite3VdbeAddOp2(v, OP_Null, 0, target);
77108: }
77109: assert( db->mallocFailed || pParse->nErr>0
77110: || pParse->iCacheLevel==iCacheLevel );
77111: sqlite3VdbeResolveLabel(v, endLabel);
77112: break;
77113: }
77114: #ifndef SQLITE_OMIT_TRIGGER
77115: case TK_RAISE: {
77116: assert( pExpr->affinity==OE_Rollback
77117: || pExpr->affinity==OE_Abort
77118: || pExpr->affinity==OE_Fail
77119: || pExpr->affinity==OE_Ignore
77120: );
77121: if( !pParse->pTriggerTab ){
77122: sqlite3ErrorMsg(pParse,
77123: "RAISE() may only be used within a trigger-program");
77124: return 0;
77125: }
77126: if( pExpr->affinity==OE_Abort ){
77127: sqlite3MayAbort(pParse);
77128: }
77129: assert( !ExprHasProperty(pExpr, EP_IntValue) );
77130: if( pExpr->affinity==OE_Ignore ){
77131: sqlite3VdbeAddOp4(
77132: v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
77133: }else{
77134: sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
77135: }
77136:
77137: break;
77138: }
77139: #endif
77140: }
77141: sqlite3ReleaseTempReg(pParse, regFree1);
77142: sqlite3ReleaseTempReg(pParse, regFree2);
77143: return inReg;
77144: }
77145:
77146: /*
77147: ** Generate code to evaluate an expression and store the results
77148: ** into a register. Return the register number where the results
77149: ** are stored.
77150: **
77151: ** If the register is a temporary register that can be deallocated,
77152: ** then write its number into *pReg. If the result register is not
77153: ** a temporary, then set *pReg to zero.
77154: */
77155: SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
77156: int r1 = sqlite3GetTempReg(pParse);
77157: int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
77158: if( r2==r1 ){
77159: *pReg = r1;
77160: }else{
77161: sqlite3ReleaseTempReg(pParse, r1);
77162: *pReg = 0;
77163: }
77164: return r2;
77165: }
77166:
77167: /*
77168: ** Generate code that will evaluate expression pExpr and store the
77169: ** results in register target. The results are guaranteed to appear
77170: ** in register target.
77171: */
77172: SQLITE_PRIVATE int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
77173: int inReg;
77174:
77175: assert( target>0 && target<=pParse->nMem );
77176: if( pExpr && pExpr->op==TK_REGISTER ){
77177: sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
77178: }else{
77179: inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
77180: assert( pParse->pVdbe || pParse->db->mallocFailed );
77181: if( inReg!=target && pParse->pVdbe ){
77182: sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
77183: }
77184: }
77185: return target;
77186: }
77187:
77188: /*
77189: ** Generate code that evalutes the given expression and puts the result
77190: ** in register target.
77191: **
77192: ** Also make a copy of the expression results into another "cache" register
77193: ** and modify the expression so that the next time it is evaluated,
77194: ** the result is a copy of the cache register.
77195: **
77196: ** This routine is used for expressions that are used multiple
77197: ** times. They are evaluated once and the results of the expression
77198: ** are reused.
77199: */
77200: SQLITE_PRIVATE int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
77201: Vdbe *v = pParse->pVdbe;
77202: int inReg;
77203: inReg = sqlite3ExprCode(pParse, pExpr, target);
77204: assert( target>0 );
77205: /* This routine is called for terms to INSERT or UPDATE. And the only
77206: ** other place where expressions can be converted into TK_REGISTER is
77207: ** in WHERE clause processing. So as currently implemented, there is
77208: ** no way for a TK_REGISTER to exist here. But it seems prudent to
77209: ** keep the ALWAYS() in case the conditions above change with future
77210: ** modifications or enhancements. */
77211: if( ALWAYS(pExpr->op!=TK_REGISTER) ){
77212: int iMem;
77213: iMem = ++pParse->nMem;
77214: sqlite3VdbeAddOp2(v, OP_Copy, inReg, iMem);
77215: pExpr->iTable = iMem;
77216: pExpr->op2 = pExpr->op;
77217: pExpr->op = TK_REGISTER;
77218: }
77219: return inReg;
77220: }
77221:
77222: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
77223: /*
77224: ** Generate a human-readable explanation of an expression tree.
77225: */
77226: SQLITE_PRIVATE void sqlite3ExplainExpr(Vdbe *pOut, Expr *pExpr){
77227: int op; /* The opcode being coded */
77228: const char *zBinOp = 0; /* Binary operator */
77229: const char *zUniOp = 0; /* Unary operator */
77230: if( pExpr==0 ){
77231: op = TK_NULL;
77232: }else{
77233: op = pExpr->op;
77234: }
77235: switch( op ){
77236: case TK_AGG_COLUMN: {
77237: sqlite3ExplainPrintf(pOut, "AGG{%d:%d}",
77238: pExpr->iTable, pExpr->iColumn);
77239: break;
77240: }
77241: case TK_COLUMN: {
77242: if( pExpr->iTable<0 ){
77243: /* This only happens when coding check constraints */
77244: sqlite3ExplainPrintf(pOut, "COLUMN(%d)", pExpr->iColumn);
77245: }else{
77246: sqlite3ExplainPrintf(pOut, "{%d:%d}",
77247: pExpr->iTable, pExpr->iColumn);
77248: }
77249: break;
77250: }
77251: case TK_INTEGER: {
77252: if( pExpr->flags & EP_IntValue ){
77253: sqlite3ExplainPrintf(pOut, "%d", pExpr->u.iValue);
77254: }else{
77255: sqlite3ExplainPrintf(pOut, "%s", pExpr->u.zToken);
77256: }
77257: break;
77258: }
77259: #ifndef SQLITE_OMIT_FLOATING_POINT
77260: case TK_FLOAT: {
77261: sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
77262: break;
77263: }
77264: #endif
77265: case TK_STRING: {
77266: sqlite3ExplainPrintf(pOut,"%Q", pExpr->u.zToken);
77267: break;
77268: }
77269: case TK_NULL: {
77270: sqlite3ExplainPrintf(pOut,"NULL");
77271: break;
77272: }
77273: #ifndef SQLITE_OMIT_BLOB_LITERAL
77274: case TK_BLOB: {
77275: sqlite3ExplainPrintf(pOut,"%s", pExpr->u.zToken);
77276: break;
77277: }
77278: #endif
77279: case TK_VARIABLE: {
77280: sqlite3ExplainPrintf(pOut,"VARIABLE(%s,%d)",
77281: pExpr->u.zToken, pExpr->iColumn);
77282: break;
77283: }
77284: case TK_REGISTER: {
77285: sqlite3ExplainPrintf(pOut,"REGISTER(%d)", pExpr->iTable);
77286: break;
77287: }
77288: case TK_AS: {
77289: sqlite3ExplainExpr(pOut, pExpr->pLeft);
77290: break;
77291: }
77292: #ifndef SQLITE_OMIT_CAST
77293: case TK_CAST: {
77294: /* Expressions of the form: CAST(pLeft AS token) */
77295: const char *zAff = "unk";
77296: switch( sqlite3AffinityType(pExpr->u.zToken) ){
77297: case SQLITE_AFF_TEXT: zAff = "TEXT"; break;
77298: case SQLITE_AFF_NONE: zAff = "NONE"; break;
77299: case SQLITE_AFF_NUMERIC: zAff = "NUMERIC"; break;
77300: case SQLITE_AFF_INTEGER: zAff = "INTEGER"; break;
77301: case SQLITE_AFF_REAL: zAff = "REAL"; break;
77302: }
77303: sqlite3ExplainPrintf(pOut, "CAST-%s(", zAff);
77304: sqlite3ExplainExpr(pOut, pExpr->pLeft);
77305: sqlite3ExplainPrintf(pOut, ")");
77306: break;
77307: }
77308: #endif /* SQLITE_OMIT_CAST */
77309: case TK_LT: zBinOp = "LT"; break;
77310: case TK_LE: zBinOp = "LE"; break;
77311: case TK_GT: zBinOp = "GT"; break;
77312: case TK_GE: zBinOp = "GE"; break;
77313: case TK_NE: zBinOp = "NE"; break;
77314: case TK_EQ: zBinOp = "EQ"; break;
77315: case TK_IS: zBinOp = "IS"; break;
77316: case TK_ISNOT: zBinOp = "ISNOT"; break;
77317: case TK_AND: zBinOp = "AND"; break;
77318: case TK_OR: zBinOp = "OR"; break;
77319: case TK_PLUS: zBinOp = "ADD"; break;
77320: case TK_STAR: zBinOp = "MUL"; break;
77321: case TK_MINUS: zBinOp = "SUB"; break;
77322: case TK_REM: zBinOp = "REM"; break;
77323: case TK_BITAND: zBinOp = "BITAND"; break;
77324: case TK_BITOR: zBinOp = "BITOR"; break;
77325: case TK_SLASH: zBinOp = "DIV"; break;
77326: case TK_LSHIFT: zBinOp = "LSHIFT"; break;
77327: case TK_RSHIFT: zBinOp = "RSHIFT"; break;
77328: case TK_CONCAT: zBinOp = "CONCAT"; break;
77329:
77330: case TK_UMINUS: zUniOp = "UMINUS"; break;
77331: case TK_UPLUS: zUniOp = "UPLUS"; break;
77332: case TK_BITNOT: zUniOp = "BITNOT"; break;
77333: case TK_NOT: zUniOp = "NOT"; break;
77334: case TK_ISNULL: zUniOp = "ISNULL"; break;
77335: case TK_NOTNULL: zUniOp = "NOTNULL"; break;
77336:
77337: case TK_AGG_FUNCTION:
77338: case TK_CONST_FUNC:
77339: case TK_FUNCTION: {
77340: ExprList *pFarg; /* List of function arguments */
77341: if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ){
77342: pFarg = 0;
77343: }else{
77344: pFarg = pExpr->x.pList;
77345: }
77346: sqlite3ExplainPrintf(pOut, "%sFUNCTION:%s(",
77347: op==TK_AGG_FUNCTION ? "AGG_" : "",
77348: pExpr->u.zToken);
77349: if( pFarg ){
77350: sqlite3ExplainExprList(pOut, pFarg);
77351: }
77352: sqlite3ExplainPrintf(pOut, ")");
77353: break;
77354: }
77355: #ifndef SQLITE_OMIT_SUBQUERY
77356: case TK_EXISTS: {
77357: sqlite3ExplainPrintf(pOut, "EXISTS(");
77358: sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
77359: sqlite3ExplainPrintf(pOut,")");
77360: break;
77361: }
77362: case TK_SELECT: {
77363: sqlite3ExplainPrintf(pOut, "(");
77364: sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
77365: sqlite3ExplainPrintf(pOut, ")");
77366: break;
77367: }
77368: case TK_IN: {
77369: sqlite3ExplainPrintf(pOut, "IN(");
77370: sqlite3ExplainExpr(pOut, pExpr->pLeft);
77371: sqlite3ExplainPrintf(pOut, ",");
77372: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
77373: sqlite3ExplainSelect(pOut, pExpr->x.pSelect);
77374: }else{
77375: sqlite3ExplainExprList(pOut, pExpr->x.pList);
77376: }
77377: sqlite3ExplainPrintf(pOut, ")");
77378: break;
77379: }
77380: #endif /* SQLITE_OMIT_SUBQUERY */
77381:
77382: /*
77383: ** x BETWEEN y AND z
77384: **
77385: ** This is equivalent to
77386: **
77387: ** x>=y AND x<=z
77388: **
77389: ** X is stored in pExpr->pLeft.
77390: ** Y is stored in pExpr->pList->a[0].pExpr.
77391: ** Z is stored in pExpr->pList->a[1].pExpr.
77392: */
77393: case TK_BETWEEN: {
77394: Expr *pX = pExpr->pLeft;
77395: Expr *pY = pExpr->x.pList->a[0].pExpr;
77396: Expr *pZ = pExpr->x.pList->a[1].pExpr;
77397: sqlite3ExplainPrintf(pOut, "BETWEEN(");
77398: sqlite3ExplainExpr(pOut, pX);
77399: sqlite3ExplainPrintf(pOut, ",");
77400: sqlite3ExplainExpr(pOut, pY);
77401: sqlite3ExplainPrintf(pOut, ",");
77402: sqlite3ExplainExpr(pOut, pZ);
77403: sqlite3ExplainPrintf(pOut, ")");
77404: break;
77405: }
77406: case TK_TRIGGER: {
77407: /* If the opcode is TK_TRIGGER, then the expression is a reference
77408: ** to a column in the new.* or old.* pseudo-tables available to
77409: ** trigger programs. In this case Expr.iTable is set to 1 for the
77410: ** new.* pseudo-table, or 0 for the old.* pseudo-table. Expr.iColumn
77411: ** is set to the column of the pseudo-table to read, or to -1 to
77412: ** read the rowid field.
77413: */
77414: sqlite3ExplainPrintf(pOut, "%s(%d)",
77415: pExpr->iTable ? "NEW" : "OLD", pExpr->iColumn);
77416: break;
77417: }
77418: case TK_CASE: {
77419: sqlite3ExplainPrintf(pOut, "CASE(");
77420: sqlite3ExplainExpr(pOut, pExpr->pLeft);
77421: sqlite3ExplainPrintf(pOut, ",");
77422: sqlite3ExplainExprList(pOut, pExpr->x.pList);
77423: break;
77424: }
77425: #ifndef SQLITE_OMIT_TRIGGER
77426: case TK_RAISE: {
77427: const char *zType = "unk";
77428: switch( pExpr->affinity ){
77429: case OE_Rollback: zType = "rollback"; break;
77430: case OE_Abort: zType = "abort"; break;
77431: case OE_Fail: zType = "fail"; break;
77432: case OE_Ignore: zType = "ignore"; break;
77433: }
77434: sqlite3ExplainPrintf(pOut, "RAISE-%s(%s)", zType, pExpr->u.zToken);
77435: break;
77436: }
77437: #endif
77438: }
77439: if( zBinOp ){
77440: sqlite3ExplainPrintf(pOut,"%s(", zBinOp);
77441: sqlite3ExplainExpr(pOut, pExpr->pLeft);
77442: sqlite3ExplainPrintf(pOut,",");
77443: sqlite3ExplainExpr(pOut, pExpr->pRight);
77444: sqlite3ExplainPrintf(pOut,")");
77445: }else if( zUniOp ){
77446: sqlite3ExplainPrintf(pOut,"%s(", zUniOp);
77447: sqlite3ExplainExpr(pOut, pExpr->pLeft);
77448: sqlite3ExplainPrintf(pOut,")");
77449: }
77450: }
77451: #endif /* defined(SQLITE_ENABLE_TREE_EXPLAIN) */
77452:
77453: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
77454: /*
77455: ** Generate a human-readable explanation of an expression list.
77456: */
77457: SQLITE_PRIVATE void sqlite3ExplainExprList(Vdbe *pOut, ExprList *pList){
77458: int i;
77459: if( pList==0 || pList->nExpr==0 ){
77460: sqlite3ExplainPrintf(pOut, "(empty-list)");
77461: return;
77462: }else if( pList->nExpr==1 ){
77463: sqlite3ExplainExpr(pOut, pList->a[0].pExpr);
77464: }else{
77465: sqlite3ExplainPush(pOut);
77466: for(i=0; i<pList->nExpr; i++){
77467: sqlite3ExplainPrintf(pOut, "item[%d] = ", i);
77468: sqlite3ExplainPush(pOut);
77469: sqlite3ExplainExpr(pOut, pList->a[i].pExpr);
77470: sqlite3ExplainPop(pOut);
77471: if( i<pList->nExpr-1 ){
77472: sqlite3ExplainNL(pOut);
77473: }
77474: }
77475: sqlite3ExplainPop(pOut);
77476: }
77477: }
77478: #endif /* SQLITE_DEBUG */
77479:
77480: /*
77481: ** Return TRUE if pExpr is an constant expression that is appropriate
77482: ** for factoring out of a loop. Appropriate expressions are:
77483: **
77484: ** * Any expression that evaluates to two or more opcodes.
77485: **
77486: ** * Any OP_Integer, OP_Real, OP_String, OP_Blob, OP_Null,
77487: ** or OP_Variable that does not need to be placed in a
77488: ** specific register.
77489: **
77490: ** There is no point in factoring out single-instruction constant
77491: ** expressions that need to be placed in a particular register.
77492: ** We could factor them out, but then we would end up adding an
77493: ** OP_SCopy instruction to move the value into the correct register
77494: ** later. We might as well just use the original instruction and
77495: ** avoid the OP_SCopy.
77496: */
77497: static int isAppropriateForFactoring(Expr *p){
77498: if( !sqlite3ExprIsConstantNotJoin(p) ){
77499: return 0; /* Only constant expressions are appropriate for factoring */
77500: }
77501: if( (p->flags & EP_FixedDest)==0 ){
77502: return 1; /* Any constant without a fixed destination is appropriate */
77503: }
77504: while( p->op==TK_UPLUS ) p = p->pLeft;
77505: switch( p->op ){
77506: #ifndef SQLITE_OMIT_BLOB_LITERAL
77507: case TK_BLOB:
77508: #endif
77509: case TK_VARIABLE:
77510: case TK_INTEGER:
77511: case TK_FLOAT:
77512: case TK_NULL:
77513: case TK_STRING: {
77514: testcase( p->op==TK_BLOB );
77515: testcase( p->op==TK_VARIABLE );
77516: testcase( p->op==TK_INTEGER );
77517: testcase( p->op==TK_FLOAT );
77518: testcase( p->op==TK_NULL );
77519: testcase( p->op==TK_STRING );
77520: /* Single-instruction constants with a fixed destination are
77521: ** better done in-line. If we factor them, they will just end
77522: ** up generating an OP_SCopy to move the value to the destination
77523: ** register. */
77524: return 0;
77525: }
77526: case TK_UMINUS: {
77527: if( p->pLeft->op==TK_FLOAT || p->pLeft->op==TK_INTEGER ){
77528: return 0;
77529: }
77530: break;
77531: }
77532: default: {
77533: break;
77534: }
77535: }
77536: return 1;
77537: }
77538:
77539: /*
77540: ** If pExpr is a constant expression that is appropriate for
77541: ** factoring out of a loop, then evaluate the expression
77542: ** into a register and convert the expression into a TK_REGISTER
77543: ** expression.
77544: */
77545: static int evalConstExpr(Walker *pWalker, Expr *pExpr){
77546: Parse *pParse = pWalker->pParse;
77547: switch( pExpr->op ){
77548: case TK_IN:
77549: case TK_REGISTER: {
77550: return WRC_Prune;
77551: }
77552: case TK_FUNCTION:
77553: case TK_AGG_FUNCTION:
77554: case TK_CONST_FUNC: {
77555: /* The arguments to a function have a fixed destination.
77556: ** Mark them this way to avoid generated unneeded OP_SCopy
77557: ** instructions.
77558: */
77559: ExprList *pList = pExpr->x.pList;
77560: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
77561: if( pList ){
77562: int i = pList->nExpr;
77563: struct ExprList_item *pItem = pList->a;
77564: for(; i>0; i--, pItem++){
77565: if( ALWAYS(pItem->pExpr) ) pItem->pExpr->flags |= EP_FixedDest;
77566: }
77567: }
77568: break;
77569: }
77570: }
77571: if( isAppropriateForFactoring(pExpr) ){
77572: int r1 = ++pParse->nMem;
77573: int r2;
77574: r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
77575: if( NEVER(r1!=r2) ) sqlite3ReleaseTempReg(pParse, r1);
77576: pExpr->op2 = pExpr->op;
77577: pExpr->op = TK_REGISTER;
77578: pExpr->iTable = r2;
77579: return WRC_Prune;
77580: }
77581: return WRC_Continue;
77582: }
77583:
77584: /*
77585: ** Preevaluate constant subexpressions within pExpr and store the
77586: ** results in registers. Modify pExpr so that the constant subexpresions
77587: ** are TK_REGISTER opcodes that refer to the precomputed values.
77588: **
77589: ** This routine is a no-op if the jump to the cookie-check code has
77590: ** already occur. Since the cookie-check jump is generated prior to
77591: ** any other serious processing, this check ensures that there is no
77592: ** way to accidently bypass the constant initializations.
77593: **
77594: ** This routine is also a no-op if the SQLITE_FactorOutConst optimization
77595: ** is disabled via the sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS)
77596: ** interface. This allows test logic to verify that the same answer is
77597: ** obtained for queries regardless of whether or not constants are
77598: ** precomputed into registers or if they are inserted in-line.
77599: */
77600: SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
77601: Walker w;
77602: if( pParse->cookieGoto ) return;
77603: if( (pParse->db->flags & SQLITE_FactorOutConst)!=0 ) return;
77604: w.xExprCallback = evalConstExpr;
77605: w.xSelectCallback = 0;
77606: w.pParse = pParse;
77607: sqlite3WalkExpr(&w, pExpr);
77608: }
77609:
77610:
77611: /*
77612: ** Generate code that pushes the value of every element of the given
77613: ** expression list into a sequence of registers beginning at target.
77614: **
77615: ** Return the number of elements evaluated.
77616: */
77617: SQLITE_PRIVATE int sqlite3ExprCodeExprList(
77618: Parse *pParse, /* Parsing context */
77619: ExprList *pList, /* The expression list to be coded */
77620: int target, /* Where to write results */
77621: int doHardCopy /* Make a hard copy of every element */
77622: ){
77623: struct ExprList_item *pItem;
77624: int i, n;
77625: assert( pList!=0 );
77626: assert( target>0 );
77627: assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
77628: n = pList->nExpr;
77629: for(pItem=pList->a, i=0; i<n; i++, pItem++){
77630: Expr *pExpr = pItem->pExpr;
77631: int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
77632: if( inReg!=target+i ){
77633: sqlite3VdbeAddOp2(pParse->pVdbe, doHardCopy ? OP_Copy : OP_SCopy,
77634: inReg, target+i);
77635: }
77636: }
77637: return n;
77638: }
77639:
77640: /*
77641: ** Generate code for a BETWEEN operator.
77642: **
77643: ** x BETWEEN y AND z
77644: **
77645: ** The above is equivalent to
77646: **
77647: ** x>=y AND x<=z
77648: **
77649: ** Code it as such, taking care to do the common subexpression
77650: ** elementation of x.
77651: */
77652: static void exprCodeBetween(
77653: Parse *pParse, /* Parsing and code generating context */
77654: Expr *pExpr, /* The BETWEEN expression */
77655: int dest, /* Jump here if the jump is taken */
77656: int jumpIfTrue, /* Take the jump if the BETWEEN is true */
77657: int jumpIfNull /* Take the jump if the BETWEEN is NULL */
77658: ){
77659: Expr exprAnd; /* The AND operator in x>=y AND x<=z */
77660: Expr compLeft; /* The x>=y term */
77661: Expr compRight; /* The x<=z term */
77662: Expr exprX; /* The x subexpression */
77663: int regFree1 = 0; /* Temporary use register */
77664:
77665: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
77666: exprX = *pExpr->pLeft;
77667: exprAnd.op = TK_AND;
77668: exprAnd.pLeft = &compLeft;
77669: exprAnd.pRight = &compRight;
77670: compLeft.op = TK_GE;
77671: compLeft.pLeft = &exprX;
77672: compLeft.pRight = pExpr->x.pList->a[0].pExpr;
77673: compRight.op = TK_LE;
77674: compRight.pLeft = &exprX;
77675: compRight.pRight = pExpr->x.pList->a[1].pExpr;
77676: exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, ®Free1);
77677: exprX.op = TK_REGISTER;
77678: if( jumpIfTrue ){
77679: sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
77680: }else{
77681: sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
77682: }
77683: sqlite3ReleaseTempReg(pParse, regFree1);
77684:
77685: /* Ensure adequate test coverage */
77686: testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1==0 );
77687: testcase( jumpIfTrue==0 && jumpIfNull==0 && regFree1!=0 );
77688: testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1==0 );
77689: testcase( jumpIfTrue==0 && jumpIfNull!=0 && regFree1!=0 );
77690: testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1==0 );
77691: testcase( jumpIfTrue!=0 && jumpIfNull==0 && regFree1!=0 );
77692: testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1==0 );
77693: testcase( jumpIfTrue!=0 && jumpIfNull!=0 && regFree1!=0 );
77694: }
77695:
77696: /*
77697: ** Generate code for a boolean expression such that a jump is made
77698: ** to the label "dest" if the expression is true but execution
77699: ** continues straight thru if the expression is false.
77700: **
77701: ** If the expression evaluates to NULL (neither true nor false), then
77702: ** take the jump if the jumpIfNull flag is SQLITE_JUMPIFNULL.
77703: **
77704: ** This code depends on the fact that certain token values (ex: TK_EQ)
77705: ** are the same as opcode values (ex: OP_Eq) that implement the corresponding
77706: ** operation. Special comments in vdbe.c and the mkopcodeh.awk script in
77707: ** the make process cause these values to align. Assert()s in the code
77708: ** below verify that the numbers are aligned correctly.
77709: */
77710: SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
77711: Vdbe *v = pParse->pVdbe;
77712: int op = 0;
77713: int regFree1 = 0;
77714: int regFree2 = 0;
77715: int r1, r2;
77716:
77717: assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
77718: if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
77719: if( NEVER(pExpr==0) ) return; /* No way this can happen */
77720: op = pExpr->op;
77721: switch( op ){
77722: case TK_AND: {
77723: int d2 = sqlite3VdbeMakeLabel(v);
77724: testcase( jumpIfNull==0 );
77725: sqlite3ExprCachePush(pParse);
77726: sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
77727: sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
77728: sqlite3VdbeResolveLabel(v, d2);
77729: sqlite3ExprCachePop(pParse, 1);
77730: break;
77731: }
77732: case TK_OR: {
77733: testcase( jumpIfNull==0 );
77734: sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
77735: sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
77736: break;
77737: }
77738: case TK_NOT: {
77739: testcase( jumpIfNull==0 );
77740: sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
77741: break;
77742: }
77743: case TK_LT:
77744: case TK_LE:
77745: case TK_GT:
77746: case TK_GE:
77747: case TK_NE:
77748: case TK_EQ: {
77749: assert( TK_LT==OP_Lt );
77750: assert( TK_LE==OP_Le );
77751: assert( TK_GT==OP_Gt );
77752: assert( TK_GE==OP_Ge );
77753: assert( TK_EQ==OP_Eq );
77754: assert( TK_NE==OP_Ne );
77755: testcase( op==TK_LT );
77756: testcase( op==TK_LE );
77757: testcase( op==TK_GT );
77758: testcase( op==TK_GE );
77759: testcase( op==TK_EQ );
77760: testcase( op==TK_NE );
77761: testcase( jumpIfNull==0 );
77762: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
77763: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
77764: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
77765: r1, r2, dest, jumpIfNull);
77766: testcase( regFree1==0 );
77767: testcase( regFree2==0 );
77768: break;
77769: }
77770: case TK_IS:
77771: case TK_ISNOT: {
77772: testcase( op==TK_IS );
77773: testcase( op==TK_ISNOT );
77774: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
77775: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
77776: op = (op==TK_IS) ? TK_EQ : TK_NE;
77777: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
77778: r1, r2, dest, SQLITE_NULLEQ);
77779: testcase( regFree1==0 );
77780: testcase( regFree2==0 );
77781: break;
77782: }
77783: case TK_ISNULL:
77784: case TK_NOTNULL: {
77785: assert( TK_ISNULL==OP_IsNull );
77786: assert( TK_NOTNULL==OP_NotNull );
77787: testcase( op==TK_ISNULL );
77788: testcase( op==TK_NOTNULL );
77789: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
77790: sqlite3VdbeAddOp2(v, op, r1, dest);
77791: testcase( regFree1==0 );
77792: break;
77793: }
77794: case TK_BETWEEN: {
77795: testcase( jumpIfNull==0 );
77796: exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
77797: break;
77798: }
77799: #ifndef SQLITE_OMIT_SUBQUERY
77800: case TK_IN: {
77801: int destIfFalse = sqlite3VdbeMakeLabel(v);
77802: int destIfNull = jumpIfNull ? dest : destIfFalse;
77803: sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
77804: sqlite3VdbeAddOp2(v, OP_Goto, 0, dest);
77805: sqlite3VdbeResolveLabel(v, destIfFalse);
77806: break;
77807: }
77808: #endif
77809: default: {
77810: r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
77811: sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
77812: testcase( regFree1==0 );
77813: testcase( jumpIfNull==0 );
77814: break;
77815: }
77816: }
77817: sqlite3ReleaseTempReg(pParse, regFree1);
77818: sqlite3ReleaseTempReg(pParse, regFree2);
77819: }
77820:
77821: /*
77822: ** Generate code for a boolean expression such that a jump is made
77823: ** to the label "dest" if the expression is false but execution
77824: ** continues straight thru if the expression is true.
77825: **
77826: ** If the expression evaluates to NULL (neither true nor false) then
77827: ** jump if jumpIfNull is SQLITE_JUMPIFNULL or fall through if jumpIfNull
77828: ** is 0.
77829: */
77830: SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
77831: Vdbe *v = pParse->pVdbe;
77832: int op = 0;
77833: int regFree1 = 0;
77834: int regFree2 = 0;
77835: int r1, r2;
77836:
77837: assert( jumpIfNull==SQLITE_JUMPIFNULL || jumpIfNull==0 );
77838: if( NEVER(v==0) ) return; /* Existance of VDBE checked by caller */
77839: if( pExpr==0 ) return;
77840:
77841: /* The value of pExpr->op and op are related as follows:
77842: **
77843: ** pExpr->op op
77844: ** --------- ----------
77845: ** TK_ISNULL OP_NotNull
77846: ** TK_NOTNULL OP_IsNull
77847: ** TK_NE OP_Eq
77848: ** TK_EQ OP_Ne
77849: ** TK_GT OP_Le
77850: ** TK_LE OP_Gt
77851: ** TK_GE OP_Lt
77852: ** TK_LT OP_Ge
77853: **
77854: ** For other values of pExpr->op, op is undefined and unused.
77855: ** The value of TK_ and OP_ constants are arranged such that we
77856: ** can compute the mapping above using the following expression.
77857: ** Assert()s verify that the computation is correct.
77858: */
77859: op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
77860:
77861: /* Verify correct alignment of TK_ and OP_ constants
77862: */
77863: assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
77864: assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
77865: assert( pExpr->op!=TK_NE || op==OP_Eq );
77866: assert( pExpr->op!=TK_EQ || op==OP_Ne );
77867: assert( pExpr->op!=TK_LT || op==OP_Ge );
77868: assert( pExpr->op!=TK_LE || op==OP_Gt );
77869: assert( pExpr->op!=TK_GT || op==OP_Le );
77870: assert( pExpr->op!=TK_GE || op==OP_Lt );
77871:
77872: switch( pExpr->op ){
77873: case TK_AND: {
77874: testcase( jumpIfNull==0 );
77875: sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
77876: sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
77877: break;
77878: }
77879: case TK_OR: {
77880: int d2 = sqlite3VdbeMakeLabel(v);
77881: testcase( jumpIfNull==0 );
77882: sqlite3ExprCachePush(pParse);
77883: sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
77884: sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
77885: sqlite3VdbeResolveLabel(v, d2);
77886: sqlite3ExprCachePop(pParse, 1);
77887: break;
77888: }
77889: case TK_NOT: {
77890: testcase( jumpIfNull==0 );
77891: sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
77892: break;
77893: }
77894: case TK_LT:
77895: case TK_LE:
77896: case TK_GT:
77897: case TK_GE:
77898: case TK_NE:
77899: case TK_EQ: {
77900: testcase( op==TK_LT );
77901: testcase( op==TK_LE );
77902: testcase( op==TK_GT );
77903: testcase( op==TK_GE );
77904: testcase( op==TK_EQ );
77905: testcase( op==TK_NE );
77906: testcase( jumpIfNull==0 );
77907: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
77908: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
77909: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
77910: r1, r2, dest, jumpIfNull);
77911: testcase( regFree1==0 );
77912: testcase( regFree2==0 );
77913: break;
77914: }
77915: case TK_IS:
77916: case TK_ISNOT: {
77917: testcase( pExpr->op==TK_IS );
77918: testcase( pExpr->op==TK_ISNOT );
77919: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
77920: r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
77921: op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
77922: codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
77923: r1, r2, dest, SQLITE_NULLEQ);
77924: testcase( regFree1==0 );
77925: testcase( regFree2==0 );
77926: break;
77927: }
77928: case TK_ISNULL:
77929: case TK_NOTNULL: {
77930: testcase( op==TK_ISNULL );
77931: testcase( op==TK_NOTNULL );
77932: r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
77933: sqlite3VdbeAddOp2(v, op, r1, dest);
77934: testcase( regFree1==0 );
77935: break;
77936: }
77937: case TK_BETWEEN: {
77938: testcase( jumpIfNull==0 );
77939: exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
77940: break;
77941: }
77942: #ifndef SQLITE_OMIT_SUBQUERY
77943: case TK_IN: {
77944: if( jumpIfNull ){
77945: sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
77946: }else{
77947: int destIfNull = sqlite3VdbeMakeLabel(v);
77948: sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
77949: sqlite3VdbeResolveLabel(v, destIfNull);
77950: }
77951: break;
77952: }
77953: #endif
77954: default: {
77955: r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
77956: sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
77957: testcase( regFree1==0 );
77958: testcase( jumpIfNull==0 );
77959: break;
77960: }
77961: }
77962: sqlite3ReleaseTempReg(pParse, regFree1);
77963: sqlite3ReleaseTempReg(pParse, regFree2);
77964: }
77965:
77966: /*
77967: ** Do a deep comparison of two expression trees. Return 0 if the two
77968: ** expressions are completely identical. Return 1 if they differ only
77969: ** by a COLLATE operator at the top level. Return 2 if there are differences
77970: ** other than the top-level COLLATE operator.
77971: **
77972: ** Sometimes this routine will return 2 even if the two expressions
77973: ** really are equivalent. If we cannot prove that the expressions are
77974: ** identical, we return 2 just to be safe. So if this routine
77975: ** returns 2, then you do not really know for certain if the two
77976: ** expressions are the same. But if you get a 0 or 1 return, then you
77977: ** can be sure the expressions are the same. In the places where
77978: ** this routine is used, it does not hurt to get an extra 2 - that
77979: ** just might result in some slightly slower code. But returning
77980: ** an incorrect 0 or 1 could lead to a malfunction.
77981: */
77982: SQLITE_PRIVATE int sqlite3ExprCompare(Expr *pA, Expr *pB){
77983: if( pA==0||pB==0 ){
77984: return pB==pA ? 0 : 2;
77985: }
77986: assert( !ExprHasAnyProperty(pA, EP_TokenOnly|EP_Reduced) );
77987: assert( !ExprHasAnyProperty(pB, EP_TokenOnly|EP_Reduced) );
77988: if( ExprHasProperty(pA, EP_xIsSelect) || ExprHasProperty(pB, EP_xIsSelect) ){
77989: return 2;
77990: }
77991: if( (pA->flags & EP_Distinct)!=(pB->flags & EP_Distinct) ) return 2;
77992: if( pA->op!=pB->op ) return 2;
77993: if( sqlite3ExprCompare(pA->pLeft, pB->pLeft) ) return 2;
77994: if( sqlite3ExprCompare(pA->pRight, pB->pRight) ) return 2;
77995: if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList) ) return 2;
77996: if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 2;
77997: if( ExprHasProperty(pA, EP_IntValue) ){
77998: if( !ExprHasProperty(pB, EP_IntValue) || pA->u.iValue!=pB->u.iValue ){
77999: return 2;
78000: }
78001: }else if( pA->op!=TK_COLUMN && pA->u.zToken ){
78002: if( ExprHasProperty(pB, EP_IntValue) || NEVER(pB->u.zToken==0) ) return 2;
78003: if( strcmp(pA->u.zToken,pB->u.zToken)!=0 ){
78004: return 2;
78005: }
78006: }
78007: if( (pA->flags & EP_ExpCollate)!=(pB->flags & EP_ExpCollate) ) return 1;
78008: if( (pA->flags & EP_ExpCollate)!=0 && pA->pColl!=pB->pColl ) return 2;
78009: return 0;
78010: }
78011:
78012: /*
78013: ** Compare two ExprList objects. Return 0 if they are identical and
78014: ** non-zero if they differ in any way.
78015: **
78016: ** This routine might return non-zero for equivalent ExprLists. The
78017: ** only consequence will be disabled optimizations. But this routine
78018: ** must never return 0 if the two ExprList objects are different, or
78019: ** a malfunction will result.
78020: **
78021: ** Two NULL pointers are considered to be the same. But a NULL pointer
78022: ** always differs from a non-NULL pointer.
78023: */
78024: SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB){
78025: int i;
78026: if( pA==0 && pB==0 ) return 0;
78027: if( pA==0 || pB==0 ) return 1;
78028: if( pA->nExpr!=pB->nExpr ) return 1;
78029: for(i=0; i<pA->nExpr; i++){
78030: Expr *pExprA = pA->a[i].pExpr;
78031: Expr *pExprB = pB->a[i].pExpr;
78032: if( pA->a[i].sortOrder!=pB->a[i].sortOrder ) return 1;
78033: if( sqlite3ExprCompare(pExprA, pExprB) ) return 1;
78034: }
78035: return 0;
78036: }
78037:
78038: /*
78039: ** Add a new element to the pAggInfo->aCol[] array. Return the index of
78040: ** the new element. Return a negative number if malloc fails.
78041: */
78042: static int addAggInfoColumn(sqlite3 *db, AggInfo *pInfo){
78043: int i;
78044: pInfo->aCol = sqlite3ArrayAllocate(
78045: db,
78046: pInfo->aCol,
78047: sizeof(pInfo->aCol[0]),
78048: 3,
78049: &pInfo->nColumn,
78050: &pInfo->nColumnAlloc,
78051: &i
78052: );
78053: return i;
78054: }
78055:
78056: /*
78057: ** Add a new element to the pAggInfo->aFunc[] array. Return the index of
78058: ** the new element. Return a negative number if malloc fails.
78059: */
78060: static int addAggInfoFunc(sqlite3 *db, AggInfo *pInfo){
78061: int i;
78062: pInfo->aFunc = sqlite3ArrayAllocate(
78063: db,
78064: pInfo->aFunc,
78065: sizeof(pInfo->aFunc[0]),
78066: 3,
78067: &pInfo->nFunc,
78068: &pInfo->nFuncAlloc,
78069: &i
78070: );
78071: return i;
78072: }
78073:
78074: /*
78075: ** This is the xExprCallback for a tree walker. It is used to
78076: ** implement sqlite3ExprAnalyzeAggregates(). See sqlite3ExprAnalyzeAggregates
78077: ** for additional information.
78078: */
78079: static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
78080: int i;
78081: NameContext *pNC = pWalker->u.pNC;
78082: Parse *pParse = pNC->pParse;
78083: SrcList *pSrcList = pNC->pSrcList;
78084: AggInfo *pAggInfo = pNC->pAggInfo;
78085:
78086: switch( pExpr->op ){
78087: case TK_AGG_COLUMN:
78088: case TK_COLUMN: {
78089: testcase( pExpr->op==TK_AGG_COLUMN );
78090: testcase( pExpr->op==TK_COLUMN );
78091: /* Check to see if the column is in one of the tables in the FROM
78092: ** clause of the aggregate query */
78093: if( ALWAYS(pSrcList!=0) ){
78094: struct SrcList_item *pItem = pSrcList->a;
78095: for(i=0; i<pSrcList->nSrc; i++, pItem++){
78096: struct AggInfo_col *pCol;
78097: assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
78098: if( pExpr->iTable==pItem->iCursor ){
78099: /* If we reach this point, it means that pExpr refers to a table
78100: ** that is in the FROM clause of the aggregate query.
78101: **
78102: ** Make an entry for the column in pAggInfo->aCol[] if there
78103: ** is not an entry there already.
78104: */
78105: int k;
78106: pCol = pAggInfo->aCol;
78107: for(k=0; k<pAggInfo->nColumn; k++, pCol++){
78108: if( pCol->iTable==pExpr->iTable &&
78109: pCol->iColumn==pExpr->iColumn ){
78110: break;
78111: }
78112: }
78113: if( (k>=pAggInfo->nColumn)
78114: && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
78115: ){
78116: pCol = &pAggInfo->aCol[k];
78117: pCol->pTab = pExpr->pTab;
78118: pCol->iTable = pExpr->iTable;
78119: pCol->iColumn = pExpr->iColumn;
78120: pCol->iMem = ++pParse->nMem;
78121: pCol->iSorterColumn = -1;
78122: pCol->pExpr = pExpr;
78123: if( pAggInfo->pGroupBy ){
78124: int j, n;
78125: ExprList *pGB = pAggInfo->pGroupBy;
78126: struct ExprList_item *pTerm = pGB->a;
78127: n = pGB->nExpr;
78128: for(j=0; j<n; j++, pTerm++){
78129: Expr *pE = pTerm->pExpr;
78130: if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
78131: pE->iColumn==pExpr->iColumn ){
78132: pCol->iSorterColumn = j;
78133: break;
78134: }
78135: }
78136: }
78137: if( pCol->iSorterColumn<0 ){
78138: pCol->iSorterColumn = pAggInfo->nSortingColumn++;
78139: }
78140: }
78141: /* There is now an entry for pExpr in pAggInfo->aCol[] (either
78142: ** because it was there before or because we just created it).
78143: ** Convert the pExpr to be a TK_AGG_COLUMN referring to that
78144: ** pAggInfo->aCol[] entry.
78145: */
78146: ExprSetIrreducible(pExpr);
78147: pExpr->pAggInfo = pAggInfo;
78148: pExpr->op = TK_AGG_COLUMN;
78149: pExpr->iAgg = (i16)k;
78150: break;
78151: } /* endif pExpr->iTable==pItem->iCursor */
78152: } /* end loop over pSrcList */
78153: }
78154: return WRC_Prune;
78155: }
78156: case TK_AGG_FUNCTION: {
78157: /* The pNC->nDepth==0 test causes aggregate functions in subqueries
78158: ** to be ignored */
78159: if( pNC->nDepth==0 ){
78160: /* Check to see if pExpr is a duplicate of another aggregate
78161: ** function that is already in the pAggInfo structure
78162: */
78163: struct AggInfo_func *pItem = pAggInfo->aFunc;
78164: for(i=0; i<pAggInfo->nFunc; i++, pItem++){
78165: if( sqlite3ExprCompare(pItem->pExpr, pExpr)==0 ){
78166: break;
78167: }
78168: }
78169: if( i>=pAggInfo->nFunc ){
78170: /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
78171: */
78172: u8 enc = ENC(pParse->db);
78173: i = addAggInfoFunc(pParse->db, pAggInfo);
78174: if( i>=0 ){
78175: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
78176: pItem = &pAggInfo->aFunc[i];
78177: pItem->pExpr = pExpr;
78178: pItem->iMem = ++pParse->nMem;
78179: assert( !ExprHasProperty(pExpr, EP_IntValue) );
78180: pItem->pFunc = sqlite3FindFunction(pParse->db,
78181: pExpr->u.zToken, sqlite3Strlen30(pExpr->u.zToken),
78182: pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
78183: if( pExpr->flags & EP_Distinct ){
78184: pItem->iDistinct = pParse->nTab++;
78185: }else{
78186: pItem->iDistinct = -1;
78187: }
78188: }
78189: }
78190: /* Make pExpr point to the appropriate pAggInfo->aFunc[] entry
78191: */
78192: assert( !ExprHasAnyProperty(pExpr, EP_TokenOnly|EP_Reduced) );
78193: ExprSetIrreducible(pExpr);
78194: pExpr->iAgg = (i16)i;
78195: pExpr->pAggInfo = pAggInfo;
78196: return WRC_Prune;
78197: }
78198: }
78199: }
78200: return WRC_Continue;
78201: }
78202: static int analyzeAggregatesInSelect(Walker *pWalker, Select *pSelect){
78203: NameContext *pNC = pWalker->u.pNC;
78204: if( pNC->nDepth==0 ){
78205: pNC->nDepth++;
78206: sqlite3WalkSelect(pWalker, pSelect);
78207: pNC->nDepth--;
78208: return WRC_Prune;
78209: }else{
78210: return WRC_Continue;
78211: }
78212: }
78213:
78214: /*
78215: ** Analyze the given expression looking for aggregate functions and
78216: ** for variables that need to be added to the pParse->aAgg[] array.
78217: ** Make additional entries to the pParse->aAgg[] array as necessary.
78218: **
78219: ** This routine should only be called after the expression has been
78220: ** analyzed by sqlite3ResolveExprNames().
78221: */
78222: SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
78223: Walker w;
78224: w.xExprCallback = analyzeAggregate;
78225: w.xSelectCallback = analyzeAggregatesInSelect;
78226: w.u.pNC = pNC;
78227: assert( pNC->pSrcList!=0 );
78228: sqlite3WalkExpr(&w, pExpr);
78229: }
78230:
78231: /*
78232: ** Call sqlite3ExprAnalyzeAggregates() for every expression in an
78233: ** expression list. Return the number of errors.
78234: **
78235: ** If an error is found, the analysis is cut short.
78236: */
78237: SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext *pNC, ExprList *pList){
78238: struct ExprList_item *pItem;
78239: int i;
78240: if( pList ){
78241: for(pItem=pList->a, i=0; i<pList->nExpr; i++, pItem++){
78242: sqlite3ExprAnalyzeAggregates(pNC, pItem->pExpr);
78243: }
78244: }
78245: }
78246:
78247: /*
78248: ** Allocate a single new register for use to hold some intermediate result.
78249: */
78250: SQLITE_PRIVATE int sqlite3GetTempReg(Parse *pParse){
78251: if( pParse->nTempReg==0 ){
78252: return ++pParse->nMem;
78253: }
78254: return pParse->aTempReg[--pParse->nTempReg];
78255: }
78256:
78257: /*
78258: ** Deallocate a register, making available for reuse for some other
78259: ** purpose.
78260: **
78261: ** If a register is currently being used by the column cache, then
78262: ** the dallocation is deferred until the column cache line that uses
78263: ** the register becomes stale.
78264: */
78265: SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
78266: if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
78267: int i;
78268: struct yColCache *p;
78269: for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
78270: if( p->iReg==iReg ){
78271: p->tempReg = 1;
78272: return;
78273: }
78274: }
78275: pParse->aTempReg[pParse->nTempReg++] = iReg;
78276: }
78277: }
78278:
78279: /*
78280: ** Allocate or deallocate a block of nReg consecutive registers
78281: */
78282: SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){
78283: int i, n;
78284: i = pParse->iRangeReg;
78285: n = pParse->nRangeReg;
78286: if( nReg<=n ){
78287: assert( !usedAsColumnCache(pParse, i, i+n-1) );
78288: pParse->iRangeReg += nReg;
78289: pParse->nRangeReg -= nReg;
78290: }else{
78291: i = pParse->nMem+1;
78292: pParse->nMem += nReg;
78293: }
78294: return i;
78295: }
78296: SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
78297: sqlite3ExprCacheRemove(pParse, iReg, nReg);
78298: if( nReg>pParse->nRangeReg ){
78299: pParse->nRangeReg = nReg;
78300: pParse->iRangeReg = iReg;
78301: }
78302: }
78303:
78304: /*
78305: ** Mark all temporary registers as being unavailable for reuse.
78306: */
78307: SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse *pParse){
78308: pParse->nTempReg = 0;
78309: pParse->nRangeReg = 0;
78310: }
78311:
78312: /************** End of expr.c ************************************************/
78313: /************** Begin file alter.c *******************************************/
78314: /*
78315: ** 2005 February 15
78316: **
78317: ** The author disclaims copyright to this source code. In place of
78318: ** a legal notice, here is a blessing:
78319: **
78320: ** May you do good and not evil.
78321: ** May you find forgiveness for yourself and forgive others.
78322: ** May you share freely, never taking more than you give.
78323: **
78324: *************************************************************************
78325: ** This file contains C code routines that used to generate VDBE code
78326: ** that implements the ALTER TABLE command.
78327: */
78328:
78329: /*
78330: ** The code in this file only exists if we are not omitting the
78331: ** ALTER TABLE logic from the build.
78332: */
78333: #ifndef SQLITE_OMIT_ALTERTABLE
78334:
78335:
78336: /*
78337: ** This function is used by SQL generated to implement the
78338: ** ALTER TABLE command. The first argument is the text of a CREATE TABLE or
78339: ** CREATE INDEX command. The second is a table name. The table name in
78340: ** the CREATE TABLE or CREATE INDEX statement is replaced with the third
78341: ** argument and the result returned. Examples:
78342: **
78343: ** sqlite_rename_table('CREATE TABLE abc(a, b, c)', 'def')
78344: ** -> 'CREATE TABLE def(a, b, c)'
78345: **
78346: ** sqlite_rename_table('CREATE INDEX i ON abc(a)', 'def')
78347: ** -> 'CREATE INDEX i ON def(a, b, c)'
78348: */
78349: static void renameTableFunc(
78350: sqlite3_context *context,
78351: int NotUsed,
78352: sqlite3_value **argv
78353: ){
78354: unsigned char const *zSql = sqlite3_value_text(argv[0]);
78355: unsigned char const *zTableName = sqlite3_value_text(argv[1]);
78356:
78357: int token;
78358: Token tname;
78359: unsigned char const *zCsr = zSql;
78360: int len = 0;
78361: char *zRet;
78362:
78363: sqlite3 *db = sqlite3_context_db_handle(context);
78364:
78365: UNUSED_PARAMETER(NotUsed);
78366:
78367: /* The principle used to locate the table name in the CREATE TABLE
78368: ** statement is that the table name is the first non-space token that
78369: ** is immediately followed by a TK_LP or TK_USING token.
78370: */
78371: if( zSql ){
78372: do {
78373: if( !*zCsr ){
78374: /* Ran out of input before finding an opening bracket. Return NULL. */
78375: return;
78376: }
78377:
78378: /* Store the token that zCsr points to in tname. */
78379: tname.z = (char*)zCsr;
78380: tname.n = len;
78381:
78382: /* Advance zCsr to the next token. Store that token type in 'token',
78383: ** and its length in 'len' (to be used next iteration of this loop).
78384: */
78385: do {
78386: zCsr += len;
78387: len = sqlite3GetToken(zCsr, &token);
78388: } while( token==TK_SPACE );
78389: assert( len>0 );
78390: } while( token!=TK_LP && token!=TK_USING );
78391:
78392: zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql,
78393: zTableName, tname.z+tname.n);
78394: sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
78395: }
78396: }
78397:
78398: /*
78399: ** This C function implements an SQL user function that is used by SQL code
78400: ** generated by the ALTER TABLE ... RENAME command to modify the definition
78401: ** of any foreign key constraints that use the table being renamed as the
78402: ** parent table. It is passed three arguments:
78403: **
78404: ** 1) The complete text of the CREATE TABLE statement being modified,
78405: ** 2) The old name of the table being renamed, and
78406: ** 3) The new name of the table being renamed.
78407: **
78408: ** It returns the new CREATE TABLE statement. For example:
78409: **
78410: ** sqlite_rename_parent('CREATE TABLE t1(a REFERENCES t2)', 't2', 't3')
78411: ** -> 'CREATE TABLE t1(a REFERENCES t3)'
78412: */
78413: #ifndef SQLITE_OMIT_FOREIGN_KEY
78414: static void renameParentFunc(
78415: sqlite3_context *context,
78416: int NotUsed,
78417: sqlite3_value **argv
78418: ){
78419: sqlite3 *db = sqlite3_context_db_handle(context);
78420: char *zOutput = 0;
78421: char *zResult;
78422: unsigned char const *zInput = sqlite3_value_text(argv[0]);
78423: unsigned char const *zOld = sqlite3_value_text(argv[1]);
78424: unsigned char const *zNew = sqlite3_value_text(argv[2]);
78425:
78426: unsigned const char *z; /* Pointer to token */
78427: int n; /* Length of token z */
78428: int token; /* Type of token */
78429:
78430: UNUSED_PARAMETER(NotUsed);
78431: for(z=zInput; *z; z=z+n){
78432: n = sqlite3GetToken(z, &token);
78433: if( token==TK_REFERENCES ){
78434: char *zParent;
78435: do {
78436: z += n;
78437: n = sqlite3GetToken(z, &token);
78438: }while( token==TK_SPACE );
78439:
78440: zParent = sqlite3DbStrNDup(db, (const char *)z, n);
78441: if( zParent==0 ) break;
78442: sqlite3Dequote(zParent);
78443: if( 0==sqlite3StrICmp((const char *)zOld, zParent) ){
78444: char *zOut = sqlite3MPrintf(db, "%s%.*s\"%w\"",
78445: (zOutput?zOutput:""), z-zInput, zInput, (const char *)zNew
78446: );
78447: sqlite3DbFree(db, zOutput);
78448: zOutput = zOut;
78449: zInput = &z[n];
78450: }
78451: sqlite3DbFree(db, zParent);
78452: }
78453: }
78454:
78455: zResult = sqlite3MPrintf(db, "%s%s", (zOutput?zOutput:""), zInput),
78456: sqlite3_result_text(context, zResult, -1, SQLITE_DYNAMIC);
78457: sqlite3DbFree(db, zOutput);
78458: }
78459: #endif
78460:
78461: #ifndef SQLITE_OMIT_TRIGGER
78462: /* This function is used by SQL generated to implement the
78463: ** ALTER TABLE command. The first argument is the text of a CREATE TRIGGER
78464: ** statement. The second is a table name. The table name in the CREATE
78465: ** TRIGGER statement is replaced with the third argument and the result
78466: ** returned. This is analagous to renameTableFunc() above, except for CREATE
78467: ** TRIGGER, not CREATE INDEX and CREATE TABLE.
78468: */
78469: static void renameTriggerFunc(
78470: sqlite3_context *context,
78471: int NotUsed,
78472: sqlite3_value **argv
78473: ){
78474: unsigned char const *zSql = sqlite3_value_text(argv[0]);
78475: unsigned char const *zTableName = sqlite3_value_text(argv[1]);
78476:
78477: int token;
78478: Token tname;
78479: int dist = 3;
78480: unsigned char const *zCsr = zSql;
78481: int len = 0;
78482: char *zRet;
78483: sqlite3 *db = sqlite3_context_db_handle(context);
78484:
78485: UNUSED_PARAMETER(NotUsed);
78486:
78487: /* The principle used to locate the table name in the CREATE TRIGGER
78488: ** statement is that the table name is the first token that is immediatedly
78489: ** preceded by either TK_ON or TK_DOT and immediatedly followed by one
78490: ** of TK_WHEN, TK_BEGIN or TK_FOR.
78491: */
78492: if( zSql ){
78493: do {
78494:
78495: if( !*zCsr ){
78496: /* Ran out of input before finding the table name. Return NULL. */
78497: return;
78498: }
78499:
78500: /* Store the token that zCsr points to in tname. */
78501: tname.z = (char*)zCsr;
78502: tname.n = len;
78503:
78504: /* Advance zCsr to the next token. Store that token type in 'token',
78505: ** and its length in 'len' (to be used next iteration of this loop).
78506: */
78507: do {
78508: zCsr += len;
78509: len = sqlite3GetToken(zCsr, &token);
78510: }while( token==TK_SPACE );
78511: assert( len>0 );
78512:
78513: /* Variable 'dist' stores the number of tokens read since the most
78514: ** recent TK_DOT or TK_ON. This means that when a WHEN, FOR or BEGIN
78515: ** token is read and 'dist' equals 2, the condition stated above
78516: ** to be met.
78517: **
78518: ** Note that ON cannot be a database, table or column name, so
78519: ** there is no need to worry about syntax like
78520: ** "CREATE TRIGGER ... ON ON.ON BEGIN ..." etc.
78521: */
78522: dist++;
78523: if( token==TK_DOT || token==TK_ON ){
78524: dist = 0;
78525: }
78526: } while( dist!=2 || (token!=TK_WHEN && token!=TK_FOR && token!=TK_BEGIN) );
78527:
78528: /* Variable tname now contains the token that is the old table-name
78529: ** in the CREATE TRIGGER statement.
78530: */
78531: zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql,
78532: zTableName, tname.z+tname.n);
78533: sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
78534: }
78535: }
78536: #endif /* !SQLITE_OMIT_TRIGGER */
78537:
78538: /*
78539: ** Register built-in functions used to help implement ALTER TABLE
78540: */
78541: SQLITE_PRIVATE void sqlite3AlterFunctions(void){
78542: static SQLITE_WSD FuncDef aAlterTableFuncs[] = {
78543: FUNCTION(sqlite_rename_table, 2, 0, 0, renameTableFunc),
78544: #ifndef SQLITE_OMIT_TRIGGER
78545: FUNCTION(sqlite_rename_trigger, 2, 0, 0, renameTriggerFunc),
78546: #endif
78547: #ifndef SQLITE_OMIT_FOREIGN_KEY
78548: FUNCTION(sqlite_rename_parent, 3, 0, 0, renameParentFunc),
78549: #endif
78550: };
78551: int i;
78552: FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
78553: FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aAlterTableFuncs);
78554:
78555: for(i=0; i<ArraySize(aAlterTableFuncs); i++){
78556: sqlite3FuncDefInsert(pHash, &aFunc[i]);
78557: }
78558: }
78559:
78560: /*
78561: ** This function is used to create the text of expressions of the form:
78562: **
78563: ** name=<constant1> OR name=<constant2> OR ...
78564: **
78565: ** If argument zWhere is NULL, then a pointer string containing the text
78566: ** "name=<constant>" is returned, where <constant> is the quoted version
78567: ** of the string passed as argument zConstant. The returned buffer is
78568: ** allocated using sqlite3DbMalloc(). It is the responsibility of the
78569: ** caller to ensure that it is eventually freed.
78570: **
78571: ** If argument zWhere is not NULL, then the string returned is
78572: ** "<where> OR name=<constant>", where <where> is the contents of zWhere.
78573: ** In this case zWhere is passed to sqlite3DbFree() before returning.
78574: **
78575: */
78576: static char *whereOrName(sqlite3 *db, char *zWhere, char *zConstant){
78577: char *zNew;
78578: if( !zWhere ){
78579: zNew = sqlite3MPrintf(db, "name=%Q", zConstant);
78580: }else{
78581: zNew = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, zConstant);
78582: sqlite3DbFree(db, zWhere);
78583: }
78584: return zNew;
78585: }
78586:
78587: #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
78588: /*
78589: ** Generate the text of a WHERE expression which can be used to select all
78590: ** tables that have foreign key constraints that refer to table pTab (i.e.
78591: ** constraints for which pTab is the parent table) from the sqlite_master
78592: ** table.
78593: */
78594: static char *whereForeignKeys(Parse *pParse, Table *pTab){
78595: FKey *p;
78596: char *zWhere = 0;
78597: for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
78598: zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
78599: }
78600: return zWhere;
78601: }
78602: #endif
78603:
78604: /*
78605: ** Generate the text of a WHERE expression which can be used to select all
78606: ** temporary triggers on table pTab from the sqlite_temp_master table. If
78607: ** table pTab has no temporary triggers, or is itself stored in the
78608: ** temporary database, NULL is returned.
78609: */
78610: static char *whereTempTriggers(Parse *pParse, Table *pTab){
78611: Trigger *pTrig;
78612: char *zWhere = 0;
78613: const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */
78614:
78615: /* If the table is not located in the temp-db (in which case NULL is
78616: ** returned, loop through the tables list of triggers. For each trigger
78617: ** that is not part of the temp-db schema, add a clause to the WHERE
78618: ** expression being built up in zWhere.
78619: */
78620: if( pTab->pSchema!=pTempSchema ){
78621: sqlite3 *db = pParse->db;
78622: for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
78623: if( pTrig->pSchema==pTempSchema ){
78624: zWhere = whereOrName(db, zWhere, pTrig->zName);
78625: }
78626: }
78627: }
78628: if( zWhere ){
78629: char *zNew = sqlite3MPrintf(pParse->db, "type='trigger' AND (%s)", zWhere);
78630: sqlite3DbFree(pParse->db, zWhere);
78631: zWhere = zNew;
78632: }
78633: return zWhere;
78634: }
78635:
78636: /*
78637: ** Generate code to drop and reload the internal representation of table
78638: ** pTab from the database, including triggers and temporary triggers.
78639: ** Argument zName is the name of the table in the database schema at
78640: ** the time the generated code is executed. This can be different from
78641: ** pTab->zName if this function is being called to code part of an
78642: ** "ALTER TABLE RENAME TO" statement.
78643: */
78644: static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
78645: Vdbe *v;
78646: char *zWhere;
78647: int iDb; /* Index of database containing pTab */
78648: #ifndef SQLITE_OMIT_TRIGGER
78649: Trigger *pTrig;
78650: #endif
78651:
78652: v = sqlite3GetVdbe(pParse);
78653: if( NEVER(v==0) ) return;
78654: assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
78655: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
78656: assert( iDb>=0 );
78657:
78658: #ifndef SQLITE_OMIT_TRIGGER
78659: /* Drop any table triggers from the internal schema. */
78660: for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
78661: int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
78662: assert( iTrigDb==iDb || iTrigDb==1 );
78663: sqlite3VdbeAddOp4(v, OP_DropTrigger, iTrigDb, 0, 0, pTrig->zName, 0);
78664: }
78665: #endif
78666:
78667: /* Drop the table and index from the internal schema. */
78668: sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
78669:
78670: /* Reload the table, index and permanent trigger schemas. */
78671: zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
78672: if( !zWhere ) return;
78673: sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
78674:
78675: #ifndef SQLITE_OMIT_TRIGGER
78676: /* Now, if the table is not stored in the temp database, reload any temp
78677: ** triggers. Don't use IN(...) in case SQLITE_OMIT_SUBQUERY is defined.
78678: */
78679: if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
78680: sqlite3VdbeAddParseSchemaOp(v, 1, zWhere);
78681: }
78682: #endif
78683: }
78684:
78685: /*
78686: ** Parameter zName is the name of a table that is about to be altered
78687: ** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN).
78688: ** If the table is a system table, this function leaves an error message
78689: ** in pParse->zErr (system tables may not be altered) and returns non-zero.
78690: **
78691: ** Or, if zName is not a system table, zero is returned.
78692: */
78693: static int isSystemTable(Parse *pParse, const char *zName){
78694: if( sqlite3Strlen30(zName)>6 && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
78695: sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
78696: return 1;
78697: }
78698: return 0;
78699: }
78700:
78701: /*
78702: ** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy"
78703: ** command.
78704: */
78705: SQLITE_PRIVATE void sqlite3AlterRenameTable(
78706: Parse *pParse, /* Parser context. */
78707: SrcList *pSrc, /* The table to rename. */
78708: Token *pName /* The new table name. */
78709: ){
78710: int iDb; /* Database that contains the table */
78711: char *zDb; /* Name of database iDb */
78712: Table *pTab; /* Table being renamed */
78713: char *zName = 0; /* NULL-terminated version of pName */
78714: sqlite3 *db = pParse->db; /* Database connection */
78715: int nTabName; /* Number of UTF-8 characters in zTabName */
78716: const char *zTabName; /* Original name of the table */
78717: Vdbe *v;
78718: #ifndef SQLITE_OMIT_TRIGGER
78719: char *zWhere = 0; /* Where clause to locate temp triggers */
78720: #endif
78721: VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */
78722: int savedDbFlags; /* Saved value of db->flags */
78723:
78724: savedDbFlags = db->flags;
78725: if( NEVER(db->mallocFailed) ) goto exit_rename_table;
78726: assert( pSrc->nSrc==1 );
78727: assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
78728:
78729: pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
78730: if( !pTab ) goto exit_rename_table;
78731: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
78732: zDb = db->aDb[iDb].zName;
78733: db->flags |= SQLITE_PreferBuiltin;
78734:
78735: /* Get a NULL terminated version of the new table name. */
78736: zName = sqlite3NameFromToken(db, pName);
78737: if( !zName ) goto exit_rename_table;
78738:
78739: /* Check that a table or index named 'zName' does not already exist
78740: ** in database iDb. If so, this is an error.
78741: */
78742: if( sqlite3FindTable(db, zName, zDb) || sqlite3FindIndex(db, zName, zDb) ){
78743: sqlite3ErrorMsg(pParse,
78744: "there is already another table or index with this name: %s", zName);
78745: goto exit_rename_table;
78746: }
78747:
78748: /* Make sure it is not a system table being altered, or a reserved name
78749: ** that the table is being renamed to.
78750: */
78751: if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
78752: goto exit_rename_table;
78753: }
78754: if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
78755: exit_rename_table;
78756: }
78757:
78758: #ifndef SQLITE_OMIT_VIEW
78759: if( pTab->pSelect ){
78760: sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
78761: goto exit_rename_table;
78762: }
78763: #endif
78764:
78765: #ifndef SQLITE_OMIT_AUTHORIZATION
78766: /* Invoke the authorization callback. */
78767: if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
78768: goto exit_rename_table;
78769: }
78770: #endif
78771:
78772: #ifndef SQLITE_OMIT_VIRTUALTABLE
78773: if( sqlite3ViewGetColumnNames(pParse, pTab) ){
78774: goto exit_rename_table;
78775: }
78776: if( IsVirtual(pTab) ){
78777: pVTab = sqlite3GetVTable(db, pTab);
78778: if( pVTab->pVtab->pModule->xRename==0 ){
78779: pVTab = 0;
78780: }
78781: }
78782: #endif
78783:
78784: /* Begin a transaction and code the VerifyCookie for database iDb.
78785: ** Then modify the schema cookie (since the ALTER TABLE modifies the
78786: ** schema). Open a statement transaction if the table is a virtual
78787: ** table.
78788: */
78789: v = sqlite3GetVdbe(pParse);
78790: if( v==0 ){
78791: goto exit_rename_table;
78792: }
78793: sqlite3BeginWriteOperation(pParse, pVTab!=0, iDb);
78794: sqlite3ChangeCookie(pParse, iDb);
78795:
78796: /* If this is a virtual table, invoke the xRename() function if
78797: ** one is defined. The xRename() callback will modify the names
78798: ** of any resources used by the v-table implementation (including other
78799: ** SQLite tables) that are identified by the name of the virtual table.
78800: */
78801: #ifndef SQLITE_OMIT_VIRTUALTABLE
78802: if( pVTab ){
78803: int i = ++pParse->nMem;
78804: sqlite3VdbeAddOp4(v, OP_String8, 0, i, 0, zName, 0);
78805: sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
78806: sqlite3MayAbort(pParse);
78807: }
78808: #endif
78809:
78810: /* figure out how many UTF-8 characters are in zName */
78811: zTabName = pTab->zName;
78812: nTabName = sqlite3Utf8CharLen(zTabName, -1);
78813:
78814: #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
78815: if( db->flags&SQLITE_ForeignKeys ){
78816: /* If foreign-key support is enabled, rewrite the CREATE TABLE
78817: ** statements corresponding to all child tables of foreign key constraints
78818: ** for which the renamed table is the parent table. */
78819: if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){
78820: sqlite3NestedParse(pParse,
78821: "UPDATE \"%w\".%s SET "
78822: "sql = sqlite_rename_parent(sql, %Q, %Q) "
78823: "WHERE %s;", zDb, SCHEMA_TABLE(iDb), zTabName, zName, zWhere);
78824: sqlite3DbFree(db, zWhere);
78825: }
78826: }
78827: #endif
78828:
78829: /* Modify the sqlite_master table to use the new table name. */
78830: sqlite3NestedParse(pParse,
78831: "UPDATE %Q.%s SET "
78832: #ifdef SQLITE_OMIT_TRIGGER
78833: "sql = sqlite_rename_table(sql, %Q), "
78834: #else
78835: "sql = CASE "
78836: "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)"
78837: "ELSE sqlite_rename_table(sql, %Q) END, "
78838: #endif
78839: "tbl_name = %Q, "
78840: "name = CASE "
78841: "WHEN type='table' THEN %Q "
78842: "WHEN name LIKE 'sqlite_autoindex%%' AND type='index' THEN "
78843: "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
78844: "ELSE name END "
78845: "WHERE tbl_name=%Q AND "
78846: "(type='table' OR type='index' OR type='trigger');",
78847: zDb, SCHEMA_TABLE(iDb), zName, zName, zName,
78848: #ifndef SQLITE_OMIT_TRIGGER
78849: zName,
78850: #endif
78851: zName, nTabName, zTabName
78852: );
78853:
78854: #ifndef SQLITE_OMIT_AUTOINCREMENT
78855: /* If the sqlite_sequence table exists in this database, then update
78856: ** it with the new table name.
78857: */
78858: if( sqlite3FindTable(db, "sqlite_sequence", zDb) ){
78859: sqlite3NestedParse(pParse,
78860: "UPDATE \"%w\".sqlite_sequence set name = %Q WHERE name = %Q",
78861: zDb, zName, pTab->zName);
78862: }
78863: #endif
78864:
78865: #ifndef SQLITE_OMIT_TRIGGER
78866: /* If there are TEMP triggers on this table, modify the sqlite_temp_master
78867: ** table. Don't do this if the table being ALTERed is itself located in
78868: ** the temp database.
78869: */
78870: if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
78871: sqlite3NestedParse(pParse,
78872: "UPDATE sqlite_temp_master SET "
78873: "sql = sqlite_rename_trigger(sql, %Q), "
78874: "tbl_name = %Q "
78875: "WHERE %s;", zName, zName, zWhere);
78876: sqlite3DbFree(db, zWhere);
78877: }
78878: #endif
78879:
78880: #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
78881: if( db->flags&SQLITE_ForeignKeys ){
78882: FKey *p;
78883: for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
78884: Table *pFrom = p->pFrom;
78885: if( pFrom!=pTab ){
78886: reloadTableSchema(pParse, p->pFrom, pFrom->zName);
78887: }
78888: }
78889: }
78890: #endif
78891:
78892: /* Drop and reload the internal table schema. */
78893: reloadTableSchema(pParse, pTab, zName);
78894:
78895: exit_rename_table:
78896: sqlite3SrcListDelete(db, pSrc);
78897: sqlite3DbFree(db, zName);
78898: db->flags = savedDbFlags;
78899: }
78900:
78901:
78902: /*
78903: ** Generate code to make sure the file format number is at least minFormat.
78904: ** The generated code will increase the file format number if necessary.
78905: */
78906: SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
78907: Vdbe *v;
78908: v = sqlite3GetVdbe(pParse);
78909: /* The VDBE should have been allocated before this routine is called.
78910: ** If that allocation failed, we would have quit before reaching this
78911: ** point */
78912: if( ALWAYS(v) ){
78913: int r1 = sqlite3GetTempReg(pParse);
78914: int r2 = sqlite3GetTempReg(pParse);
78915: int j1;
78916: sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
78917: sqlite3VdbeUsesBtree(v, iDb);
78918: sqlite3VdbeAddOp2(v, OP_Integer, minFormat, r2);
78919: j1 = sqlite3VdbeAddOp3(v, OP_Ge, r2, 0, r1);
78920: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, r2);
78921: sqlite3VdbeJumpHere(v, j1);
78922: sqlite3ReleaseTempReg(pParse, r1);
78923: sqlite3ReleaseTempReg(pParse, r2);
78924: }
78925: }
78926:
78927: /*
78928: ** This function is called after an "ALTER TABLE ... ADD" statement
78929: ** has been parsed. Argument pColDef contains the text of the new
78930: ** column definition.
78931: **
78932: ** The Table structure pParse->pNewTable was extended to include
78933: ** the new column during parsing.
78934: */
78935: SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
78936: Table *pNew; /* Copy of pParse->pNewTable */
78937: Table *pTab; /* Table being altered */
78938: int iDb; /* Database number */
78939: const char *zDb; /* Database name */
78940: const char *zTab; /* Table name */
78941: char *zCol; /* Null-terminated column definition */
78942: Column *pCol; /* The new column */
78943: Expr *pDflt; /* Default value for the new column */
78944: sqlite3 *db; /* The database connection; */
78945:
78946: db = pParse->db;
78947: if( pParse->nErr || db->mallocFailed ) return;
78948: pNew = pParse->pNewTable;
78949: assert( pNew );
78950:
78951: assert( sqlite3BtreeHoldsAllMutexes(db) );
78952: iDb = sqlite3SchemaToIndex(db, pNew->pSchema);
78953: zDb = db->aDb[iDb].zName;
78954: zTab = &pNew->zName[16]; /* Skip the "sqlite_altertab_" prefix on the name */
78955: pCol = &pNew->aCol[pNew->nCol-1];
78956: pDflt = pCol->pDflt;
78957: pTab = sqlite3FindTable(db, zTab, zDb);
78958: assert( pTab );
78959:
78960: #ifndef SQLITE_OMIT_AUTHORIZATION
78961: /* Invoke the authorization callback. */
78962: if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
78963: return;
78964: }
78965: #endif
78966:
78967: /* If the default value for the new column was specified with a
78968: ** literal NULL, then set pDflt to 0. This simplifies checking
78969: ** for an SQL NULL default below.
78970: */
78971: if( pDflt && pDflt->op==TK_NULL ){
78972: pDflt = 0;
78973: }
78974:
78975: /* Check that the new column is not specified as PRIMARY KEY or UNIQUE.
78976: ** If there is a NOT NULL constraint, then the default value for the
78977: ** column must not be NULL.
78978: */
78979: if( pCol->isPrimKey ){
78980: sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
78981: return;
78982: }
78983: if( pNew->pIndex ){
78984: sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column");
78985: return;
78986: }
78987: if( (db->flags&SQLITE_ForeignKeys) && pNew->pFKey && pDflt ){
78988: sqlite3ErrorMsg(pParse,
78989: "Cannot add a REFERENCES column with non-NULL default value");
78990: return;
78991: }
78992: if( pCol->notNull && !pDflt ){
78993: sqlite3ErrorMsg(pParse,
78994: "Cannot add a NOT NULL column with default value NULL");
78995: return;
78996: }
78997:
78998: /* Ensure the default expression is something that sqlite3ValueFromExpr()
78999: ** can handle (i.e. not CURRENT_TIME etc.)
79000: */
79001: if( pDflt ){
79002: sqlite3_value *pVal;
79003: if( sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){
79004: db->mallocFailed = 1;
79005: return;
79006: }
79007: if( !pVal ){
79008: sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default");
79009: return;
79010: }
79011: sqlite3ValueFree(pVal);
79012: }
79013:
79014: /* Modify the CREATE TABLE statement. */
79015: zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
79016: if( zCol ){
79017: char *zEnd = &zCol[pColDef->n-1];
79018: int savedDbFlags = db->flags;
79019: while( zEnd>zCol && (*zEnd==';' || sqlite3Isspace(*zEnd)) ){
79020: *zEnd-- = '\0';
79021: }
79022: db->flags |= SQLITE_PreferBuiltin;
79023: sqlite3NestedParse(pParse,
79024: "UPDATE \"%w\".%s SET "
79025: "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
79026: "WHERE type = 'table' AND name = %Q",
79027: zDb, SCHEMA_TABLE(iDb), pNew->addColOffset, zCol, pNew->addColOffset+1,
79028: zTab
79029: );
79030: sqlite3DbFree(db, zCol);
79031: db->flags = savedDbFlags;
79032: }
79033:
79034: /* If the default value of the new column is NULL, then set the file
79035: ** format to 2. If the default value of the new column is not NULL,
79036: ** the file format becomes 3.
79037: */
79038: sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
79039:
79040: /* Reload the schema of the modified table. */
79041: reloadTableSchema(pParse, pTab, pTab->zName);
79042: }
79043:
79044: /*
79045: ** This function is called by the parser after the table-name in
79046: ** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument
79047: ** pSrc is the full-name of the table being altered.
79048: **
79049: ** This routine makes a (partial) copy of the Table structure
79050: ** for the table being altered and sets Parse.pNewTable to point
79051: ** to it. Routines called by the parser as the column definition
79052: ** is parsed (i.e. sqlite3AddColumn()) add the new Column data to
79053: ** the copy. The copy of the Table structure is deleted by tokenize.c
79054: ** after parsing is finished.
79055: **
79056: ** Routine sqlite3AlterFinishAddColumn() will be called to complete
79057: ** coding the "ALTER TABLE ... ADD" statement.
79058: */
79059: SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
79060: Table *pNew;
79061: Table *pTab;
79062: Vdbe *v;
79063: int iDb;
79064: int i;
79065: int nAlloc;
79066: sqlite3 *db = pParse->db;
79067:
79068: /* Look up the table being altered. */
79069: assert( pParse->pNewTable==0 );
79070: assert( sqlite3BtreeHoldsAllMutexes(db) );
79071: if( db->mallocFailed ) goto exit_begin_add_column;
79072: pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
79073: if( !pTab ) goto exit_begin_add_column;
79074:
79075: #ifndef SQLITE_OMIT_VIRTUALTABLE
79076: if( IsVirtual(pTab) ){
79077: sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
79078: goto exit_begin_add_column;
79079: }
79080: #endif
79081:
79082: /* Make sure this is not an attempt to ALTER a view. */
79083: if( pTab->pSelect ){
79084: sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
79085: goto exit_begin_add_column;
79086: }
79087: if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
79088: goto exit_begin_add_column;
79089: }
79090:
79091: assert( pTab->addColOffset>0 );
79092: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
79093:
79094: /* Put a copy of the Table struct in Parse.pNewTable for the
79095: ** sqlite3AddColumn() function and friends to modify. But modify
79096: ** the name by adding an "sqlite_altertab_" prefix. By adding this
79097: ** prefix, we insure that the name will not collide with an existing
79098: ** table because user table are not allowed to have the "sqlite_"
79099: ** prefix on their name.
79100: */
79101: pNew = (Table*)sqlite3DbMallocZero(db, sizeof(Table));
79102: if( !pNew ) goto exit_begin_add_column;
79103: pParse->pNewTable = pNew;
79104: pNew->nRef = 1;
79105: pNew->nCol = pTab->nCol;
79106: assert( pNew->nCol>0 );
79107: nAlloc = (((pNew->nCol-1)/8)*8)+8;
79108: assert( nAlloc>=pNew->nCol && nAlloc%8==0 && nAlloc-pNew->nCol<8 );
79109: pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
79110: pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
79111: if( !pNew->aCol || !pNew->zName ){
79112: db->mallocFailed = 1;
79113: goto exit_begin_add_column;
79114: }
79115: memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
79116: for(i=0; i<pNew->nCol; i++){
79117: Column *pCol = &pNew->aCol[i];
79118: pCol->zName = sqlite3DbStrDup(db, pCol->zName);
79119: pCol->zColl = 0;
79120: pCol->zType = 0;
79121: pCol->pDflt = 0;
79122: pCol->zDflt = 0;
79123: }
79124: pNew->pSchema = db->aDb[iDb].pSchema;
79125: pNew->addColOffset = pTab->addColOffset;
79126: pNew->nRef = 1;
79127:
79128: /* Begin a transaction and increment the schema cookie. */
79129: sqlite3BeginWriteOperation(pParse, 0, iDb);
79130: v = sqlite3GetVdbe(pParse);
79131: if( !v ) goto exit_begin_add_column;
79132: sqlite3ChangeCookie(pParse, iDb);
79133:
79134: exit_begin_add_column:
79135: sqlite3SrcListDelete(db, pSrc);
79136: return;
79137: }
79138: #endif /* SQLITE_ALTER_TABLE */
79139:
79140: /************** End of alter.c ***********************************************/
79141: /************** Begin file analyze.c *****************************************/
79142: /*
79143: ** 2005 July 8
79144: **
79145: ** The author disclaims copyright to this source code. In place of
79146: ** a legal notice, here is a blessing:
79147: **
79148: ** May you do good and not evil.
79149: ** May you find forgiveness for yourself and forgive others.
79150: ** May you share freely, never taking more than you give.
79151: **
79152: *************************************************************************
79153: ** This file contains code associated with the ANALYZE command.
79154: **
79155: ** The ANALYZE command gather statistics about the content of tables
79156: ** and indices. These statistics are made available to the query planner
79157: ** to help it make better decisions about how to perform queries.
79158: **
79159: ** The following system tables are or have been supported:
79160: **
79161: ** CREATE TABLE sqlite_stat1(tbl, idx, stat);
79162: ** CREATE TABLE sqlite_stat2(tbl, idx, sampleno, sample);
79163: ** CREATE TABLE sqlite_stat3(tbl, idx, nEq, nLt, nDLt, sample);
79164: **
79165: ** Additional tables might be added in future releases of SQLite.
79166: ** The sqlite_stat2 table is not created or used unless the SQLite version
79167: ** is between 3.6.18 and 3.7.8, inclusive, and unless SQLite is compiled
79168: ** with SQLITE_ENABLE_STAT2. The sqlite_stat2 table is deprecated.
79169: ** The sqlite_stat2 table is superceded by sqlite_stat3, which is only
79170: ** created and used by SQLite versions 3.7.9 and later and with
79171: ** SQLITE_ENABLE_STAT3 defined. The fucntionality of sqlite_stat3
79172: ** is a superset of sqlite_stat2.
79173: **
79174: ** Format of sqlite_stat1:
79175: **
79176: ** There is normally one row per index, with the index identified by the
79177: ** name in the idx column. The tbl column is the name of the table to
79178: ** which the index belongs. In each such row, the stat column will be
79179: ** a string consisting of a list of integers. The first integer in this
79180: ** list is the number of rows in the index and in the table. The second
79181: ** integer is the average number of rows in the index that have the same
79182: ** value in the first column of the index. The third integer is the average
79183: ** number of rows in the index that have the same value for the first two
79184: ** columns. The N-th integer (for N>1) is the average number of rows in
79185: ** the index which have the same value for the first N-1 columns. For
79186: ** a K-column index, there will be K+1 integers in the stat column. If
79187: ** the index is unique, then the last integer will be 1.
79188: **
79189: ** The list of integers in the stat column can optionally be followed
79190: ** by the keyword "unordered". The "unordered" keyword, if it is present,
79191: ** must be separated from the last integer by a single space. If the
79192: ** "unordered" keyword is present, then the query planner assumes that
79193: ** the index is unordered and will not use the index for a range query.
79194: **
79195: ** If the sqlite_stat1.idx column is NULL, then the sqlite_stat1.stat
79196: ** column contains a single integer which is the (estimated) number of
79197: ** rows in the table identified by sqlite_stat1.tbl.
79198: **
79199: ** Format of sqlite_stat2:
79200: **
79201: ** The sqlite_stat2 is only created and is only used if SQLite is compiled
79202: ** with SQLITE_ENABLE_STAT2 and if the SQLite version number is between
79203: ** 3.6.18 and 3.7.8. The "stat2" table contains additional information
79204: ** about the distribution of keys within an index. The index is identified by
79205: ** the "idx" column and the "tbl" column is the name of the table to which
79206: ** the index belongs. There are usually 10 rows in the sqlite_stat2
79207: ** table for each index.
79208: **
79209: ** The sqlite_stat2 entries for an index that have sampleno between 0 and 9
79210: ** inclusive are samples of the left-most key value in the index taken at
79211: ** evenly spaced points along the index. Let the number of samples be S
79212: ** (10 in the standard build) and let C be the number of rows in the index.
79213: ** Then the sampled rows are given by:
79214: **
79215: ** rownumber = (i*C*2 + C)/(S*2)
79216: **
79217: ** For i between 0 and S-1. Conceptually, the index space is divided into
79218: ** S uniform buckets and the samples are the middle row from each bucket.
79219: **
79220: ** The format for sqlite_stat2 is recorded here for legacy reference. This
79221: ** version of SQLite does not support sqlite_stat2. It neither reads nor
79222: ** writes the sqlite_stat2 table. This version of SQLite only supports
79223: ** sqlite_stat3.
79224: **
79225: ** Format for sqlite_stat3:
79226: **
79227: ** The sqlite_stat3 is an enhancement to sqlite_stat2. A new name is
79228: ** used to avoid compatibility problems.
79229: **
79230: ** The format of the sqlite_stat3 table is similar to the format of
79231: ** the sqlite_stat2 table. There are multiple entries for each index.
79232: ** The idx column names the index and the tbl column is the table of the
79233: ** index. If the idx and tbl columns are the same, then the sample is
79234: ** of the INTEGER PRIMARY KEY. The sample column is a value taken from
79235: ** the left-most column of the index. The nEq column is the approximate
79236: ** number of entires in the index whose left-most column exactly matches
79237: ** the sample. nLt is the approximate number of entires whose left-most
79238: ** column is less than the sample. The nDLt column is the approximate
79239: ** number of distinct left-most entries in the index that are less than
79240: ** the sample.
79241: **
79242: ** Future versions of SQLite might change to store a string containing
79243: ** multiple integers values in the nDLt column of sqlite_stat3. The first
79244: ** integer will be the number of prior index entires that are distinct in
79245: ** the left-most column. The second integer will be the number of prior index
79246: ** entries that are distinct in the first two columns. The third integer
79247: ** will be the number of prior index entries that are distinct in the first
79248: ** three columns. And so forth. With that extension, the nDLt field is
79249: ** similar in function to the sqlite_stat1.stat field.
79250: **
79251: ** There can be an arbitrary number of sqlite_stat3 entries per index.
79252: ** The ANALYZE command will typically generate sqlite_stat3 tables
79253: ** that contain between 10 and 40 samples which are distributed across
79254: ** the key space, though not uniformly, and which include samples with
79255: ** largest possible nEq values.
79256: */
79257: #ifndef SQLITE_OMIT_ANALYZE
79258:
79259: /*
79260: ** This routine generates code that opens the sqlite_stat1 table for
79261: ** writing with cursor iStatCur. If the library was built with the
79262: ** SQLITE_ENABLE_STAT3 macro defined, then the sqlite_stat3 table is
79263: ** opened for writing using cursor (iStatCur+1)
79264: **
79265: ** If the sqlite_stat1 tables does not previously exist, it is created.
79266: ** Similarly, if the sqlite_stat3 table does not exist and the library
79267: ** is compiled with SQLITE_ENABLE_STAT3 defined, it is created.
79268: **
79269: ** Argument zWhere may be a pointer to a buffer containing a table name,
79270: ** or it may be a NULL pointer. If it is not NULL, then all entries in
79271: ** the sqlite_stat1 and (if applicable) sqlite_stat3 tables associated
79272: ** with the named table are deleted. If zWhere==0, then code is generated
79273: ** to delete all stat table entries.
79274: */
79275: static void openStatTable(
79276: Parse *pParse, /* Parsing context */
79277: int iDb, /* The database we are looking in */
79278: int iStatCur, /* Open the sqlite_stat1 table on this cursor */
79279: const char *zWhere, /* Delete entries for this table or index */
79280: const char *zWhereType /* Either "tbl" or "idx" */
79281: ){
79282: static const struct {
79283: const char *zName;
79284: const char *zCols;
79285: } aTable[] = {
79286: { "sqlite_stat1", "tbl,idx,stat" },
79287: #ifdef SQLITE_ENABLE_STAT3
79288: { "sqlite_stat3", "tbl,idx,neq,nlt,ndlt,sample" },
79289: #endif
79290: };
79291:
79292: int aRoot[] = {0, 0};
79293: u8 aCreateTbl[] = {0, 0};
79294:
79295: int i;
79296: sqlite3 *db = pParse->db;
79297: Db *pDb;
79298: Vdbe *v = sqlite3GetVdbe(pParse);
79299: if( v==0 ) return;
79300: assert( sqlite3BtreeHoldsAllMutexes(db) );
79301: assert( sqlite3VdbeDb(v)==db );
79302: pDb = &db->aDb[iDb];
79303:
79304: /* Create new statistic tables if they do not exist, or clear them
79305: ** if they do already exist.
79306: */
79307: for(i=0; i<ArraySize(aTable); i++){
79308: const char *zTab = aTable[i].zName;
79309: Table *pStat;
79310: if( (pStat = sqlite3FindTable(db, zTab, pDb->zName))==0 ){
79311: /* The sqlite_stat[12] table does not exist. Create it. Note that a
79312: ** side-effect of the CREATE TABLE statement is to leave the rootpage
79313: ** of the new table in register pParse->regRoot. This is important
79314: ** because the OpenWrite opcode below will be needing it. */
79315: sqlite3NestedParse(pParse,
79316: "CREATE TABLE %Q.%s(%s)", pDb->zName, zTab, aTable[i].zCols
79317: );
79318: aRoot[i] = pParse->regRoot;
79319: aCreateTbl[i] = 1;
79320: }else{
79321: /* The table already exists. If zWhere is not NULL, delete all entries
79322: ** associated with the table zWhere. If zWhere is NULL, delete the
79323: ** entire contents of the table. */
79324: aRoot[i] = pStat->tnum;
79325: sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
79326: if( zWhere ){
79327: sqlite3NestedParse(pParse,
79328: "DELETE FROM %Q.%s WHERE %s=%Q", pDb->zName, zTab, zWhereType, zWhere
79329: );
79330: }else{
79331: /* The sqlite_stat[12] table already exists. Delete all rows. */
79332: sqlite3VdbeAddOp2(v, OP_Clear, aRoot[i], iDb);
79333: }
79334: }
79335: }
79336:
79337: /* Open the sqlite_stat[13] tables for writing. */
79338: for(i=0; i<ArraySize(aTable); i++){
79339: sqlite3VdbeAddOp3(v, OP_OpenWrite, iStatCur+i, aRoot[i], iDb);
79340: sqlite3VdbeChangeP4(v, -1, (char *)3, P4_INT32);
79341: sqlite3VdbeChangeP5(v, aCreateTbl[i]);
79342: }
79343: }
79344:
79345: /*
79346: ** Recommended number of samples for sqlite_stat3
79347: */
79348: #ifndef SQLITE_STAT3_SAMPLES
79349: # define SQLITE_STAT3_SAMPLES 24
79350: #endif
79351:
79352: /*
79353: ** Three SQL functions - stat3_init(), stat3_push(), and stat3_pop() -
79354: ** share an instance of the following structure to hold their state
79355: ** information.
79356: */
79357: typedef struct Stat3Accum Stat3Accum;
79358: struct Stat3Accum {
79359: tRowcnt nRow; /* Number of rows in the entire table */
79360: tRowcnt nPSample; /* How often to do a periodic sample */
79361: int iMin; /* Index of entry with minimum nEq and hash */
79362: int mxSample; /* Maximum number of samples to accumulate */
79363: int nSample; /* Current number of samples */
79364: u32 iPrn; /* Pseudo-random number used for sampling */
79365: struct Stat3Sample {
79366: i64 iRowid; /* Rowid in main table of the key */
79367: tRowcnt nEq; /* sqlite_stat3.nEq */
79368: tRowcnt nLt; /* sqlite_stat3.nLt */
79369: tRowcnt nDLt; /* sqlite_stat3.nDLt */
79370: u8 isPSample; /* True if a periodic sample */
79371: u32 iHash; /* Tiebreaker hash */
79372: } *a; /* An array of samples */
79373: };
79374:
79375: #ifdef SQLITE_ENABLE_STAT3
79376: /*
79377: ** Implementation of the stat3_init(C,S) SQL function. The two parameters
79378: ** are the number of rows in the table or index (C) and the number of samples
79379: ** to accumulate (S).
79380: **
79381: ** This routine allocates the Stat3Accum object.
79382: **
79383: ** The return value is the Stat3Accum object (P).
79384: */
79385: static void stat3Init(
79386: sqlite3_context *context,
79387: int argc,
79388: sqlite3_value **argv
79389: ){
79390: Stat3Accum *p;
79391: tRowcnt nRow;
79392: int mxSample;
79393: int n;
79394:
79395: UNUSED_PARAMETER(argc);
79396: nRow = (tRowcnt)sqlite3_value_int64(argv[0]);
79397: mxSample = sqlite3_value_int(argv[1]);
79398: n = sizeof(*p) + sizeof(p->a[0])*mxSample;
79399: p = sqlite3_malloc( n );
79400: if( p==0 ){
79401: sqlite3_result_error_nomem(context);
79402: return;
79403: }
79404: memset(p, 0, n);
79405: p->a = (struct Stat3Sample*)&p[1];
79406: p->nRow = nRow;
79407: p->mxSample = mxSample;
79408: p->nPSample = p->nRow/(mxSample/3+1) + 1;
79409: sqlite3_randomness(sizeof(p->iPrn), &p->iPrn);
79410: sqlite3_result_blob(context, p, sizeof(p), sqlite3_free);
79411: }
79412: static const FuncDef stat3InitFuncdef = {
79413: 2, /* nArg */
79414: SQLITE_UTF8, /* iPrefEnc */
79415: 0, /* flags */
79416: 0, /* pUserData */
79417: 0, /* pNext */
79418: stat3Init, /* xFunc */
79419: 0, /* xStep */
79420: 0, /* xFinalize */
79421: "stat3_init", /* zName */
79422: 0, /* pHash */
79423: 0 /* pDestructor */
79424: };
79425:
79426:
79427: /*
79428: ** Implementation of the stat3_push(nEq,nLt,nDLt,rowid,P) SQL function. The
79429: ** arguments describe a single key instance. This routine makes the
79430: ** decision about whether or not to retain this key for the sqlite_stat3
79431: ** table.
79432: **
79433: ** The return value is NULL.
79434: */
79435: static void stat3Push(
79436: sqlite3_context *context,
79437: int argc,
79438: sqlite3_value **argv
79439: ){
79440: Stat3Accum *p = (Stat3Accum*)sqlite3_value_blob(argv[4]);
79441: tRowcnt nEq = sqlite3_value_int64(argv[0]);
79442: tRowcnt nLt = sqlite3_value_int64(argv[1]);
79443: tRowcnt nDLt = sqlite3_value_int64(argv[2]);
79444: i64 rowid = sqlite3_value_int64(argv[3]);
79445: u8 isPSample = 0;
79446: u8 doInsert = 0;
79447: int iMin = p->iMin;
79448: struct Stat3Sample *pSample;
79449: int i;
79450: u32 h;
79451:
79452: UNUSED_PARAMETER(context);
79453: UNUSED_PARAMETER(argc);
79454: if( nEq==0 ) return;
79455: h = p->iPrn = p->iPrn*1103515245 + 12345;
79456: if( (nLt/p->nPSample)!=((nEq+nLt)/p->nPSample) ){
79457: doInsert = isPSample = 1;
79458: }else if( p->nSample<p->mxSample ){
79459: doInsert = 1;
79460: }else{
79461: if( nEq>p->a[iMin].nEq || (nEq==p->a[iMin].nEq && h>p->a[iMin].iHash) ){
79462: doInsert = 1;
79463: }
79464: }
79465: if( !doInsert ) return;
79466: if( p->nSample==p->mxSample ){
79467: assert( p->nSample - iMin - 1 >= 0 );
79468: memmove(&p->a[iMin], &p->a[iMin+1], sizeof(p->a[0])*(p->nSample-iMin-1));
79469: pSample = &p->a[p->nSample-1];
79470: }else{
79471: pSample = &p->a[p->nSample++];
79472: }
79473: pSample->iRowid = rowid;
79474: pSample->nEq = nEq;
79475: pSample->nLt = nLt;
79476: pSample->nDLt = nDLt;
79477: pSample->iHash = h;
79478: pSample->isPSample = isPSample;
79479:
79480: /* Find the new minimum */
79481: if( p->nSample==p->mxSample ){
79482: pSample = p->a;
79483: i = 0;
79484: while( pSample->isPSample ){
79485: i++;
79486: pSample++;
79487: assert( i<p->nSample );
79488: }
79489: nEq = pSample->nEq;
79490: h = pSample->iHash;
79491: iMin = i;
79492: for(i++, pSample++; i<p->nSample; i++, pSample++){
79493: if( pSample->isPSample ) continue;
79494: if( pSample->nEq<nEq
79495: || (pSample->nEq==nEq && pSample->iHash<h)
79496: ){
79497: iMin = i;
79498: nEq = pSample->nEq;
79499: h = pSample->iHash;
79500: }
79501: }
79502: p->iMin = iMin;
79503: }
79504: }
79505: static const FuncDef stat3PushFuncdef = {
79506: 5, /* nArg */
79507: SQLITE_UTF8, /* iPrefEnc */
79508: 0, /* flags */
79509: 0, /* pUserData */
79510: 0, /* pNext */
79511: stat3Push, /* xFunc */
79512: 0, /* xStep */
79513: 0, /* xFinalize */
79514: "stat3_push", /* zName */
79515: 0, /* pHash */
79516: 0 /* pDestructor */
79517: };
79518:
79519: /*
79520: ** Implementation of the stat3_get(P,N,...) SQL function. This routine is
79521: ** used to query the results. Content is returned for the Nth sqlite_stat3
79522: ** row where N is between 0 and S-1 and S is the number of samples. The
79523: ** value returned depends on the number of arguments.
79524: **
79525: ** argc==2 result: rowid
79526: ** argc==3 result: nEq
79527: ** argc==4 result: nLt
79528: ** argc==5 result: nDLt
79529: */
79530: static void stat3Get(
79531: sqlite3_context *context,
79532: int argc,
79533: sqlite3_value **argv
79534: ){
79535: int n = sqlite3_value_int(argv[1]);
79536: Stat3Accum *p = (Stat3Accum*)sqlite3_value_blob(argv[0]);
79537:
79538: assert( p!=0 );
79539: if( p->nSample<=n ) return;
79540: switch( argc ){
79541: case 2: sqlite3_result_int64(context, p->a[n].iRowid); break;
79542: case 3: sqlite3_result_int64(context, p->a[n].nEq); break;
79543: case 4: sqlite3_result_int64(context, p->a[n].nLt); break;
79544: default: sqlite3_result_int64(context, p->a[n].nDLt); break;
79545: }
79546: }
79547: static const FuncDef stat3GetFuncdef = {
79548: -1, /* nArg */
79549: SQLITE_UTF8, /* iPrefEnc */
79550: 0, /* flags */
79551: 0, /* pUserData */
79552: 0, /* pNext */
79553: stat3Get, /* xFunc */
79554: 0, /* xStep */
79555: 0, /* xFinalize */
79556: "stat3_get", /* zName */
79557: 0, /* pHash */
79558: 0 /* pDestructor */
79559: };
79560: #endif /* SQLITE_ENABLE_STAT3 */
79561:
79562:
79563:
79564:
79565: /*
79566: ** Generate code to do an analysis of all indices associated with
79567: ** a single table.
79568: */
79569: static void analyzeOneTable(
79570: Parse *pParse, /* Parser context */
79571: Table *pTab, /* Table whose indices are to be analyzed */
79572: Index *pOnlyIdx, /* If not NULL, only analyze this one index */
79573: int iStatCur, /* Index of VdbeCursor that writes the sqlite_stat1 table */
79574: int iMem /* Available memory locations begin here */
79575: ){
79576: sqlite3 *db = pParse->db; /* Database handle */
79577: Index *pIdx; /* An index to being analyzed */
79578: int iIdxCur; /* Cursor open on index being analyzed */
79579: Vdbe *v; /* The virtual machine being built up */
79580: int i; /* Loop counter */
79581: int topOfLoop; /* The top of the loop */
79582: int endOfLoop; /* The end of the loop */
79583: int jZeroRows = -1; /* Jump from here if number of rows is zero */
79584: int iDb; /* Index of database containing pTab */
79585: int regTabname = iMem++; /* Register containing table name */
79586: int regIdxname = iMem++; /* Register containing index name */
79587: int regStat1 = iMem++; /* The stat column of sqlite_stat1 */
79588: #ifdef SQLITE_ENABLE_STAT3
79589: int regNumEq = regStat1; /* Number of instances. Same as regStat1 */
79590: int regNumLt = iMem++; /* Number of keys less than regSample */
79591: int regNumDLt = iMem++; /* Number of distinct keys less than regSample */
79592: int regSample = iMem++; /* The next sample value */
79593: int regRowid = regSample; /* Rowid of a sample */
79594: int regAccum = iMem++; /* Register to hold Stat3Accum object */
79595: int regLoop = iMem++; /* Loop counter */
79596: int regCount = iMem++; /* Number of rows in the table or index */
79597: int regTemp1 = iMem++; /* Intermediate register */
79598: int regTemp2 = iMem++; /* Intermediate register */
79599: int once = 1; /* One-time initialization */
79600: int shortJump = 0; /* Instruction address */
79601: int iTabCur = pParse->nTab++; /* Table cursor */
79602: #endif
79603: int regCol = iMem++; /* Content of a column in analyzed table */
79604: int regRec = iMem++; /* Register holding completed record */
79605: int regTemp = iMem++; /* Temporary use register */
79606: int regNewRowid = iMem++; /* Rowid for the inserted record */
79607:
79608:
79609: v = sqlite3GetVdbe(pParse);
79610: if( v==0 || NEVER(pTab==0) ){
79611: return;
79612: }
79613: if( pTab->tnum==0 ){
79614: /* Do not gather statistics on views or virtual tables */
79615: return;
79616: }
79617: if( memcmp(pTab->zName, "sqlite_", 7)==0 ){
79618: /* Do not gather statistics on system tables */
79619: return;
79620: }
79621: assert( sqlite3BtreeHoldsAllMutexes(db) );
79622: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
79623: assert( iDb>=0 );
79624: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79625: #ifndef SQLITE_OMIT_AUTHORIZATION
79626: if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
79627: db->aDb[iDb].zName ) ){
79628: return;
79629: }
79630: #endif
79631:
79632: /* Establish a read-lock on the table at the shared-cache level. */
79633: sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
79634:
79635: iIdxCur = pParse->nTab++;
79636: sqlite3VdbeAddOp4(v, OP_String8, 0, regTabname, 0, pTab->zName, 0);
79637: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
79638: int nCol;
79639: KeyInfo *pKey;
79640: int addrIfNot = 0; /* address of OP_IfNot */
79641: int *aChngAddr; /* Array of jump instruction addresses */
79642:
79643: if( pOnlyIdx && pOnlyIdx!=pIdx ) continue;
79644: VdbeNoopComment((v, "Begin analysis of %s", pIdx->zName));
79645: nCol = pIdx->nColumn;
79646: aChngAddr = sqlite3DbMallocRaw(db, sizeof(int)*nCol);
79647: if( aChngAddr==0 ) continue;
79648: pKey = sqlite3IndexKeyinfo(pParse, pIdx);
79649: if( iMem+1+(nCol*2)>pParse->nMem ){
79650: pParse->nMem = iMem+1+(nCol*2);
79651: }
79652:
79653: /* Open a cursor to the index to be analyzed. */
79654: assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
79655: sqlite3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb,
79656: (char *)pKey, P4_KEYINFO_HANDOFF);
79657: VdbeComment((v, "%s", pIdx->zName));
79658:
79659: /* Populate the register containing the index name. */
79660: sqlite3VdbeAddOp4(v, OP_String8, 0, regIdxname, 0, pIdx->zName, 0);
79661:
79662: #ifdef SQLITE_ENABLE_STAT3
79663: if( once ){
79664: once = 0;
79665: sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
79666: }
79667: sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regCount);
79668: sqlite3VdbeAddOp2(v, OP_Integer, SQLITE_STAT3_SAMPLES, regTemp1);
79669: sqlite3VdbeAddOp2(v, OP_Integer, 0, regNumEq);
79670: sqlite3VdbeAddOp2(v, OP_Integer, 0, regNumLt);
79671: sqlite3VdbeAddOp2(v, OP_Integer, -1, regNumDLt);
79672: sqlite3VdbeAddOp3(v, OP_Null, 0, regSample, regAccum);
79673: sqlite3VdbeAddOp4(v, OP_Function, 1, regCount, regAccum,
79674: (char*)&stat3InitFuncdef, P4_FUNCDEF);
79675: sqlite3VdbeChangeP5(v, 2);
79676: #endif /* SQLITE_ENABLE_STAT3 */
79677:
79678: /* The block of memory cells initialized here is used as follows.
79679: **
79680: ** iMem:
79681: ** The total number of rows in the table.
79682: **
79683: ** iMem+1 .. iMem+nCol:
79684: ** Number of distinct entries in index considering the
79685: ** left-most N columns only, where N is between 1 and nCol,
79686: ** inclusive.
79687: **
79688: ** iMem+nCol+1 .. Mem+2*nCol:
79689: ** Previous value of indexed columns, from left to right.
79690: **
79691: ** Cells iMem through iMem+nCol are initialized to 0. The others are
79692: ** initialized to contain an SQL NULL.
79693: */
79694: for(i=0; i<=nCol; i++){
79695: sqlite3VdbeAddOp2(v, OP_Integer, 0, iMem+i);
79696: }
79697: for(i=0; i<nCol; i++){
79698: sqlite3VdbeAddOp2(v, OP_Null, 0, iMem+nCol+i+1);
79699: }
79700:
79701: /* Start the analysis loop. This loop runs through all the entries in
79702: ** the index b-tree. */
79703: endOfLoop = sqlite3VdbeMakeLabel(v);
79704: sqlite3VdbeAddOp2(v, OP_Rewind, iIdxCur, endOfLoop);
79705: topOfLoop = sqlite3VdbeCurrentAddr(v);
79706: sqlite3VdbeAddOp2(v, OP_AddImm, iMem, 1); /* Increment row counter */
79707:
79708: for(i=0; i<nCol; i++){
79709: CollSeq *pColl;
79710: sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regCol);
79711: if( i==0 ){
79712: /* Always record the very first row */
79713: addrIfNot = sqlite3VdbeAddOp1(v, OP_IfNot, iMem+1);
79714: }
79715: assert( pIdx->azColl!=0 );
79716: assert( pIdx->azColl[i]!=0 );
79717: pColl = sqlite3LocateCollSeq(pParse, pIdx->azColl[i]);
79718: aChngAddr[i] = sqlite3VdbeAddOp4(v, OP_Ne, regCol, 0, iMem+nCol+i+1,
79719: (char*)pColl, P4_COLLSEQ);
79720: sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
79721: VdbeComment((v, "jump if column %d changed", i));
79722: #ifdef SQLITE_ENABLE_STAT3
79723: if( i==0 ){
79724: sqlite3VdbeAddOp2(v, OP_AddImm, regNumEq, 1);
79725: VdbeComment((v, "incr repeat count"));
79726: }
79727: #endif
79728: }
79729: sqlite3VdbeAddOp2(v, OP_Goto, 0, endOfLoop);
79730: for(i=0; i<nCol; i++){
79731: sqlite3VdbeJumpHere(v, aChngAddr[i]); /* Set jump dest for the OP_Ne */
79732: if( i==0 ){
79733: sqlite3VdbeJumpHere(v, addrIfNot); /* Jump dest for OP_IfNot */
79734: #ifdef SQLITE_ENABLE_STAT3
79735: sqlite3VdbeAddOp4(v, OP_Function, 1, regNumEq, regTemp2,
79736: (char*)&stat3PushFuncdef, P4_FUNCDEF);
79737: sqlite3VdbeChangeP5(v, 5);
79738: sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, pIdx->nColumn, regRowid);
79739: sqlite3VdbeAddOp3(v, OP_Add, regNumEq, regNumLt, regNumLt);
79740: sqlite3VdbeAddOp2(v, OP_AddImm, regNumDLt, 1);
79741: sqlite3VdbeAddOp2(v, OP_Integer, 1, regNumEq);
79742: #endif
79743: }
79744: sqlite3VdbeAddOp2(v, OP_AddImm, iMem+i+1, 1);
79745: sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, iMem+nCol+i+1);
79746: }
79747: sqlite3DbFree(db, aChngAddr);
79748:
79749: /* Always jump here after updating the iMem+1...iMem+1+nCol counters */
79750: sqlite3VdbeResolveLabel(v, endOfLoop);
79751:
79752: sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, topOfLoop);
79753: sqlite3VdbeAddOp1(v, OP_Close, iIdxCur);
79754: #ifdef SQLITE_ENABLE_STAT3
79755: sqlite3VdbeAddOp4(v, OP_Function, 1, regNumEq, regTemp2,
79756: (char*)&stat3PushFuncdef, P4_FUNCDEF);
79757: sqlite3VdbeChangeP5(v, 5);
79758: sqlite3VdbeAddOp2(v, OP_Integer, -1, regLoop);
79759: shortJump =
79760: sqlite3VdbeAddOp2(v, OP_AddImm, regLoop, 1);
79761: sqlite3VdbeAddOp4(v, OP_Function, 1, regAccum, regTemp1,
79762: (char*)&stat3GetFuncdef, P4_FUNCDEF);
79763: sqlite3VdbeChangeP5(v, 2);
79764: sqlite3VdbeAddOp1(v, OP_IsNull, regTemp1);
79765: sqlite3VdbeAddOp3(v, OP_NotExists, iTabCur, shortJump, regTemp1);
79766: sqlite3VdbeAddOp3(v, OP_Column, iTabCur, pIdx->aiColumn[0], regSample);
79767: sqlite3ColumnDefault(v, pTab, pIdx->aiColumn[0], regSample);
79768: sqlite3VdbeAddOp4(v, OP_Function, 1, regAccum, regNumEq,
79769: (char*)&stat3GetFuncdef, P4_FUNCDEF);
79770: sqlite3VdbeChangeP5(v, 3);
79771: sqlite3VdbeAddOp4(v, OP_Function, 1, regAccum, regNumLt,
79772: (char*)&stat3GetFuncdef, P4_FUNCDEF);
79773: sqlite3VdbeChangeP5(v, 4);
79774: sqlite3VdbeAddOp4(v, OP_Function, 1, regAccum, regNumDLt,
79775: (char*)&stat3GetFuncdef, P4_FUNCDEF);
79776: sqlite3VdbeChangeP5(v, 5);
79777: sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 6, regRec, "bbbbbb", 0);
79778: sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur+1, regNewRowid);
79779: sqlite3VdbeAddOp3(v, OP_Insert, iStatCur+1, regRec, regNewRowid);
79780: sqlite3VdbeAddOp2(v, OP_Goto, 0, shortJump);
79781: sqlite3VdbeJumpHere(v, shortJump+2);
79782: #endif
79783:
79784: /* Store the results in sqlite_stat1.
79785: **
79786: ** The result is a single row of the sqlite_stat1 table. The first
79787: ** two columns are the names of the table and index. The third column
79788: ** is a string composed of a list of integer statistics about the
79789: ** index. The first integer in the list is the total number of entries
79790: ** in the index. There is one additional integer in the list for each
79791: ** column of the table. This additional integer is a guess of how many
79792: ** rows of the table the index will select. If D is the count of distinct
79793: ** values and K is the total number of rows, then the integer is computed
79794: ** as:
79795: **
79796: ** I = (K+D-1)/D
79797: **
79798: ** If K==0 then no entry is made into the sqlite_stat1 table.
79799: ** If K>0 then it is always the case the D>0 so division by zero
79800: ** is never possible.
79801: */
79802: sqlite3VdbeAddOp2(v, OP_SCopy, iMem, regStat1);
79803: if( jZeroRows<0 ){
79804: jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, iMem);
79805: }
79806: for(i=0; i<nCol; i++){
79807: sqlite3VdbeAddOp4(v, OP_String8, 0, regTemp, 0, " ", 0);
79808: sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regStat1, regStat1);
79809: sqlite3VdbeAddOp3(v, OP_Add, iMem, iMem+i+1, regTemp);
79810: sqlite3VdbeAddOp2(v, OP_AddImm, regTemp, -1);
79811: sqlite3VdbeAddOp3(v, OP_Divide, iMem+i+1, regTemp, regTemp);
79812: sqlite3VdbeAddOp1(v, OP_ToInt, regTemp);
79813: sqlite3VdbeAddOp3(v, OP_Concat, regTemp, regStat1, regStat1);
79814: }
79815: sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regRec, "aaa", 0);
79816: sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
79817: sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regNewRowid);
79818: sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
79819: }
79820:
79821: /* If the table has no indices, create a single sqlite_stat1 entry
79822: ** containing NULL as the index name and the row count as the content.
79823: */
79824: if( pTab->pIndex==0 ){
79825: sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pTab->tnum, iDb);
79826: VdbeComment((v, "%s", pTab->zName));
79827: sqlite3VdbeAddOp2(v, OP_Count, iIdxCur, regStat1);
79828: sqlite3VdbeAddOp1(v, OP_Close, iIdxCur);
79829: jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1);
79830: }else{
79831: sqlite3VdbeJumpHere(v, jZeroRows);
79832: jZeroRows = sqlite3VdbeAddOp0(v, OP_Goto);
79833: }
79834: sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname);
79835: sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regRec, "aaa", 0);
79836: sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
79837: sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regRec, regNewRowid);
79838: sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
79839: if( pParse->nMem<regRec ) pParse->nMem = regRec;
79840: sqlite3VdbeJumpHere(v, jZeroRows);
79841: }
79842:
79843:
79844: /*
79845: ** Generate code that will cause the most recent index analysis to
79846: ** be loaded into internal hash tables where is can be used.
79847: */
79848: static void loadAnalysis(Parse *pParse, int iDb){
79849: Vdbe *v = sqlite3GetVdbe(pParse);
79850: if( v ){
79851: sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
79852: }
79853: }
79854:
79855: /*
79856: ** Generate code that will do an analysis of an entire database
79857: */
79858: static void analyzeDatabase(Parse *pParse, int iDb){
79859: sqlite3 *db = pParse->db;
79860: Schema *pSchema = db->aDb[iDb].pSchema; /* Schema of database iDb */
79861: HashElem *k;
79862: int iStatCur;
79863: int iMem;
79864:
79865: sqlite3BeginWriteOperation(pParse, 0, iDb);
79866: iStatCur = pParse->nTab;
79867: pParse->nTab += 3;
79868: openStatTable(pParse, iDb, iStatCur, 0, 0);
79869: iMem = pParse->nMem+1;
79870: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
79871: for(k=sqliteHashFirst(&pSchema->tblHash); k; k=sqliteHashNext(k)){
79872: Table *pTab = (Table*)sqliteHashData(k);
79873: analyzeOneTable(pParse, pTab, 0, iStatCur, iMem);
79874: }
79875: loadAnalysis(pParse, iDb);
79876: }
79877:
79878: /*
79879: ** Generate code that will do an analysis of a single table in
79880: ** a database. If pOnlyIdx is not NULL then it is a single index
79881: ** in pTab that should be analyzed.
79882: */
79883: static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
79884: int iDb;
79885: int iStatCur;
79886:
79887: assert( pTab!=0 );
79888: assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
79889: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
79890: sqlite3BeginWriteOperation(pParse, 0, iDb);
79891: iStatCur = pParse->nTab;
79892: pParse->nTab += 3;
79893: if( pOnlyIdx ){
79894: openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
79895: }else{
79896: openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
79897: }
79898: analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur, pParse->nMem+1);
79899: loadAnalysis(pParse, iDb);
79900: }
79901:
79902: /*
79903: ** Generate code for the ANALYZE command. The parser calls this routine
79904: ** when it recognizes an ANALYZE command.
79905: **
79906: ** ANALYZE -- 1
79907: ** ANALYZE <database> -- 2
79908: ** ANALYZE ?<database>.?<tablename> -- 3
79909: **
79910: ** Form 1 causes all indices in all attached databases to be analyzed.
79911: ** Form 2 analyzes all indices the single database named.
79912: ** Form 3 analyzes all indices associated with the named table.
79913: */
79914: SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
79915: sqlite3 *db = pParse->db;
79916: int iDb;
79917: int i;
79918: char *z, *zDb;
79919: Table *pTab;
79920: Index *pIdx;
79921: Token *pTableName;
79922:
79923: /* Read the database schema. If an error occurs, leave an error message
79924: ** and code in pParse and return NULL. */
79925: assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
79926: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
79927: return;
79928: }
79929:
79930: assert( pName2!=0 || pName1==0 );
79931: if( pName1==0 ){
79932: /* Form 1: Analyze everything */
79933: for(i=0; i<db->nDb; i++){
79934: if( i==1 ) continue; /* Do not analyze the TEMP database */
79935: analyzeDatabase(pParse, i);
79936: }
79937: }else if( pName2->n==0 ){
79938: /* Form 2: Analyze the database or table named */
79939: iDb = sqlite3FindDb(db, pName1);
79940: if( iDb>=0 ){
79941: analyzeDatabase(pParse, iDb);
79942: }else{
79943: z = sqlite3NameFromToken(db, pName1);
79944: if( z ){
79945: if( (pIdx = sqlite3FindIndex(db, z, 0))!=0 ){
79946: analyzeTable(pParse, pIdx->pTable, pIdx);
79947: }else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){
79948: analyzeTable(pParse, pTab, 0);
79949: }
79950: sqlite3DbFree(db, z);
79951: }
79952: }
79953: }else{
79954: /* Form 3: Analyze the fully qualified table name */
79955: iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
79956: if( iDb>=0 ){
79957: zDb = db->aDb[iDb].zName;
79958: z = sqlite3NameFromToken(db, pTableName);
79959: if( z ){
79960: if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
79961: analyzeTable(pParse, pIdx->pTable, pIdx);
79962: }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
79963: analyzeTable(pParse, pTab, 0);
79964: }
79965: sqlite3DbFree(db, z);
79966: }
79967: }
79968: }
79969: }
79970:
79971: /*
79972: ** Used to pass information from the analyzer reader through to the
79973: ** callback routine.
79974: */
79975: typedef struct analysisInfo analysisInfo;
79976: struct analysisInfo {
79977: sqlite3 *db;
79978: const char *zDatabase;
79979: };
79980:
79981: /*
79982: ** This callback is invoked once for each index when reading the
79983: ** sqlite_stat1 table.
79984: **
79985: ** argv[0] = name of the table
79986: ** argv[1] = name of the index (might be NULL)
79987: ** argv[2] = results of analysis - on integer for each column
79988: **
79989: ** Entries for which argv[1]==NULL simply record the number of rows in
79990: ** the table.
79991: */
79992: static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
79993: analysisInfo *pInfo = (analysisInfo*)pData;
79994: Index *pIndex;
79995: Table *pTable;
79996: int i, c, n;
79997: tRowcnt v;
79998: const char *z;
79999:
80000: assert( argc==3 );
80001: UNUSED_PARAMETER2(NotUsed, argc);
80002:
80003: if( argv==0 || argv[0]==0 || argv[2]==0 ){
80004: return 0;
80005: }
80006: pTable = sqlite3FindTable(pInfo->db, argv[0], pInfo->zDatabase);
80007: if( pTable==0 ){
80008: return 0;
80009: }
80010: if( argv[1] ){
80011: pIndex = sqlite3FindIndex(pInfo->db, argv[1], pInfo->zDatabase);
80012: }else{
80013: pIndex = 0;
80014: }
80015: n = pIndex ? pIndex->nColumn : 0;
80016: z = argv[2];
80017: for(i=0; *z && i<=n; i++){
80018: v = 0;
80019: while( (c=z[0])>='0' && c<='9' ){
80020: v = v*10 + c - '0';
80021: z++;
80022: }
80023: if( i==0 ) pTable->nRowEst = v;
80024: if( pIndex==0 ) break;
80025: pIndex->aiRowEst[i] = v;
80026: if( *z==' ' ) z++;
80027: if( memcmp(z, "unordered", 10)==0 ){
80028: pIndex->bUnordered = 1;
80029: break;
80030: }
80031: }
80032: return 0;
80033: }
80034:
80035: /*
80036: ** If the Index.aSample variable is not NULL, delete the aSample[] array
80037: ** and its contents.
80038: */
80039: SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){
80040: #ifdef SQLITE_ENABLE_STAT3
80041: if( pIdx->aSample ){
80042: int j;
80043: for(j=0; j<pIdx->nSample; j++){
80044: IndexSample *p = &pIdx->aSample[j];
80045: if( p->eType==SQLITE_TEXT || p->eType==SQLITE_BLOB ){
80046: sqlite3DbFree(db, p->u.z);
80047: }
80048: }
80049: sqlite3DbFree(db, pIdx->aSample);
80050: }
80051: if( db && db->pnBytesFreed==0 ){
80052: pIdx->nSample = 0;
80053: pIdx->aSample = 0;
80054: }
80055: #else
80056: UNUSED_PARAMETER(db);
80057: UNUSED_PARAMETER(pIdx);
80058: #endif
80059: }
80060:
80061: #ifdef SQLITE_ENABLE_STAT3
80062: /*
80063: ** Load content from the sqlite_stat3 table into the Index.aSample[]
80064: ** arrays of all indices.
80065: */
80066: static int loadStat3(sqlite3 *db, const char *zDb){
80067: int rc; /* Result codes from subroutines */
80068: sqlite3_stmt *pStmt = 0; /* An SQL statement being run */
80069: char *zSql; /* Text of the SQL statement */
80070: Index *pPrevIdx = 0; /* Previous index in the loop */
80071: int idx = 0; /* slot in pIdx->aSample[] for next sample */
80072: int eType; /* Datatype of a sample */
80073: IndexSample *pSample; /* A slot in pIdx->aSample[] */
80074:
80075: if( !sqlite3FindTable(db, "sqlite_stat3", zDb) ){
80076: return SQLITE_OK;
80077: }
80078:
80079: zSql = sqlite3MPrintf(db,
80080: "SELECT idx,count(*) FROM %Q.sqlite_stat3"
80081: " GROUP BY idx", zDb);
80082: if( !zSql ){
80083: return SQLITE_NOMEM;
80084: }
80085: rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
80086: sqlite3DbFree(db, zSql);
80087: if( rc ) return rc;
80088:
80089: while( sqlite3_step(pStmt)==SQLITE_ROW ){
80090: char *zIndex; /* Index name */
80091: Index *pIdx; /* Pointer to the index object */
80092: int nSample; /* Number of samples */
80093:
80094: zIndex = (char *)sqlite3_column_text(pStmt, 0);
80095: if( zIndex==0 ) continue;
80096: nSample = sqlite3_column_int(pStmt, 1);
80097: pIdx = sqlite3FindIndex(db, zIndex, zDb);
80098: if( pIdx==0 ) continue;
80099: assert( pIdx->nSample==0 );
80100: pIdx->nSample = nSample;
80101: pIdx->aSample = sqlite3MallocZero( nSample*sizeof(IndexSample) );
80102: pIdx->avgEq = pIdx->aiRowEst[1];
80103: if( pIdx->aSample==0 ){
80104: db->mallocFailed = 1;
80105: sqlite3_finalize(pStmt);
80106: return SQLITE_NOMEM;
80107: }
80108: }
80109: rc = sqlite3_finalize(pStmt);
80110: if( rc ) return rc;
80111:
80112: zSql = sqlite3MPrintf(db,
80113: "SELECT idx,neq,nlt,ndlt,sample FROM %Q.sqlite_stat3", zDb);
80114: if( !zSql ){
80115: return SQLITE_NOMEM;
80116: }
80117: rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
80118: sqlite3DbFree(db, zSql);
80119: if( rc ) return rc;
80120:
80121: while( sqlite3_step(pStmt)==SQLITE_ROW ){
80122: char *zIndex; /* Index name */
80123: Index *pIdx; /* Pointer to the index object */
80124: int i; /* Loop counter */
80125: tRowcnt sumEq; /* Sum of the nEq values */
80126:
80127: zIndex = (char *)sqlite3_column_text(pStmt, 0);
80128: if( zIndex==0 ) continue;
80129: pIdx = sqlite3FindIndex(db, zIndex, zDb);
80130: if( pIdx==0 ) continue;
80131: if( pIdx==pPrevIdx ){
80132: idx++;
80133: }else{
80134: pPrevIdx = pIdx;
80135: idx = 0;
80136: }
80137: assert( idx<pIdx->nSample );
80138: pSample = &pIdx->aSample[idx];
80139: pSample->nEq = (tRowcnt)sqlite3_column_int64(pStmt, 1);
80140: pSample->nLt = (tRowcnt)sqlite3_column_int64(pStmt, 2);
80141: pSample->nDLt = (tRowcnt)sqlite3_column_int64(pStmt, 3);
80142: if( idx==pIdx->nSample-1 ){
80143: if( pSample->nDLt>0 ){
80144: for(i=0, sumEq=0; i<=idx-1; i++) sumEq += pIdx->aSample[i].nEq;
80145: pIdx->avgEq = (pSample->nLt - sumEq)/pSample->nDLt;
80146: }
80147: if( pIdx->avgEq<=0 ) pIdx->avgEq = 1;
80148: }
80149: eType = sqlite3_column_type(pStmt, 4);
80150: pSample->eType = (u8)eType;
80151: switch( eType ){
80152: case SQLITE_INTEGER: {
80153: pSample->u.i = sqlite3_column_int64(pStmt, 4);
80154: break;
80155: }
80156: case SQLITE_FLOAT: {
80157: pSample->u.r = sqlite3_column_double(pStmt, 4);
80158: break;
80159: }
80160: case SQLITE_NULL: {
80161: break;
80162: }
80163: default: assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB ); {
80164: const char *z = (const char *)(
80165: (eType==SQLITE_BLOB) ?
80166: sqlite3_column_blob(pStmt, 4):
80167: sqlite3_column_text(pStmt, 4)
80168: );
80169: int n = z ? sqlite3_column_bytes(pStmt, 4) : 0;
80170: pSample->nByte = n;
80171: if( n < 1){
80172: pSample->u.z = 0;
80173: }else{
80174: pSample->u.z = sqlite3Malloc(n);
80175: if( pSample->u.z==0 ){
80176: db->mallocFailed = 1;
80177: sqlite3_finalize(pStmt);
80178: return SQLITE_NOMEM;
80179: }
80180: memcpy(pSample->u.z, z, n);
80181: }
80182: }
80183: }
80184: }
80185: return sqlite3_finalize(pStmt);
80186: }
80187: #endif /* SQLITE_ENABLE_STAT3 */
80188:
80189: /*
80190: ** Load the content of the sqlite_stat1 and sqlite_stat3 tables. The
80191: ** contents of sqlite_stat1 are used to populate the Index.aiRowEst[]
80192: ** arrays. The contents of sqlite_stat3 are used to populate the
80193: ** Index.aSample[] arrays.
80194: **
80195: ** If the sqlite_stat1 table is not present in the database, SQLITE_ERROR
80196: ** is returned. In this case, even if SQLITE_ENABLE_STAT3 was defined
80197: ** during compilation and the sqlite_stat3 table is present, no data is
80198: ** read from it.
80199: **
80200: ** If SQLITE_ENABLE_STAT3 was defined during compilation and the
80201: ** sqlite_stat3 table is not present in the database, SQLITE_ERROR is
80202: ** returned. However, in this case, data is read from the sqlite_stat1
80203: ** table (if it is present) before returning.
80204: **
80205: ** If an OOM error occurs, this function always sets db->mallocFailed.
80206: ** This means if the caller does not care about other errors, the return
80207: ** code may be ignored.
80208: */
80209: SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
80210: analysisInfo sInfo;
80211: HashElem *i;
80212: char *zSql;
80213: int rc;
80214:
80215: assert( iDb>=0 && iDb<db->nDb );
80216: assert( db->aDb[iDb].pBt!=0 );
80217:
80218: /* Clear any prior statistics */
80219: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
80220: for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
80221: Index *pIdx = sqliteHashData(i);
80222: sqlite3DefaultRowEst(pIdx);
80223: #ifdef SQLITE_ENABLE_STAT3
80224: sqlite3DeleteIndexSamples(db, pIdx);
80225: pIdx->aSample = 0;
80226: #endif
80227: }
80228:
80229: /* Check to make sure the sqlite_stat1 table exists */
80230: sInfo.db = db;
80231: sInfo.zDatabase = db->aDb[iDb].zName;
80232: if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){
80233: return SQLITE_ERROR;
80234: }
80235:
80236: /* Load new statistics out of the sqlite_stat1 table */
80237: zSql = sqlite3MPrintf(db,
80238: "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase);
80239: if( zSql==0 ){
80240: rc = SQLITE_NOMEM;
80241: }else{
80242: rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);
80243: sqlite3DbFree(db, zSql);
80244: }
80245:
80246:
80247: /* Load the statistics from the sqlite_stat3 table. */
80248: #ifdef SQLITE_ENABLE_STAT3
80249: if( rc==SQLITE_OK ){
80250: rc = loadStat3(db, sInfo.zDatabase);
80251: }
80252: #endif
80253:
80254: if( rc==SQLITE_NOMEM ){
80255: db->mallocFailed = 1;
80256: }
80257: return rc;
80258: }
80259:
80260:
80261: #endif /* SQLITE_OMIT_ANALYZE */
80262:
80263: /************** End of analyze.c *********************************************/
80264: /************** Begin file attach.c ******************************************/
80265: /*
80266: ** 2003 April 6
80267: **
80268: ** The author disclaims copyright to this source code. In place of
80269: ** a legal notice, here is a blessing:
80270: **
80271: ** May you do good and not evil.
80272: ** May you find forgiveness for yourself and forgive others.
80273: ** May you share freely, never taking more than you give.
80274: **
80275: *************************************************************************
80276: ** This file contains code used to implement the ATTACH and DETACH commands.
80277: */
80278:
80279: #ifndef SQLITE_OMIT_ATTACH
80280: /*
80281: ** Resolve an expression that was part of an ATTACH or DETACH statement. This
80282: ** is slightly different from resolving a normal SQL expression, because simple
80283: ** identifiers are treated as strings, not possible column names or aliases.
80284: **
80285: ** i.e. if the parser sees:
80286: **
80287: ** ATTACH DATABASE abc AS def
80288: **
80289: ** it treats the two expressions as literal strings 'abc' and 'def' instead of
80290: ** looking for columns of the same name.
80291: **
80292: ** This only applies to the root node of pExpr, so the statement:
80293: **
80294: ** ATTACH DATABASE abc||def AS 'db2'
80295: **
80296: ** will fail because neither abc or def can be resolved.
80297: */
80298: static int resolveAttachExpr(NameContext *pName, Expr *pExpr)
80299: {
80300: int rc = SQLITE_OK;
80301: if( pExpr ){
80302: if( pExpr->op!=TK_ID ){
80303: rc = sqlite3ResolveExprNames(pName, pExpr);
80304: if( rc==SQLITE_OK && !sqlite3ExprIsConstant(pExpr) ){
80305: sqlite3ErrorMsg(pName->pParse, "invalid name: \"%s\"", pExpr->u.zToken);
80306: return SQLITE_ERROR;
80307: }
80308: }else{
80309: pExpr->op = TK_STRING;
80310: }
80311: }
80312: return rc;
80313: }
80314:
80315: /*
80316: ** An SQL user-function registered to do the work of an ATTACH statement. The
80317: ** three arguments to the function come directly from an attach statement:
80318: **
80319: ** ATTACH DATABASE x AS y KEY z
80320: **
80321: ** SELECT sqlite_attach(x, y, z)
80322: **
80323: ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
80324: ** third argument.
80325: */
80326: static void attachFunc(
80327: sqlite3_context *context,
80328: int NotUsed,
80329: sqlite3_value **argv
80330: ){
80331: int i;
80332: int rc = 0;
80333: sqlite3 *db = sqlite3_context_db_handle(context);
80334: const char *zName;
80335: const char *zFile;
80336: char *zPath = 0;
80337: char *zErr = 0;
80338: unsigned int flags;
80339: Db *aNew;
80340: char *zErrDyn = 0;
80341: sqlite3_vfs *pVfs;
80342:
80343: UNUSED_PARAMETER(NotUsed);
80344:
80345: zFile = (const char *)sqlite3_value_text(argv[0]);
80346: zName = (const char *)sqlite3_value_text(argv[1]);
80347: if( zFile==0 ) zFile = "";
80348: if( zName==0 ) zName = "";
80349:
80350: /* Check for the following errors:
80351: **
80352: ** * Too many attached databases,
80353: ** * Transaction currently open
80354: ** * Specified database name already being used.
80355: */
80356: if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
80357: zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",
80358: db->aLimit[SQLITE_LIMIT_ATTACHED]
80359: );
80360: goto attach_error;
80361: }
80362: if( !db->autoCommit ){
80363: zErrDyn = sqlite3MPrintf(db, "cannot ATTACH database within transaction");
80364: goto attach_error;
80365: }
80366: for(i=0; i<db->nDb; i++){
80367: char *z = db->aDb[i].zName;
80368: assert( z && zName );
80369: if( sqlite3StrICmp(z, zName)==0 ){
80370: zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
80371: goto attach_error;
80372: }
80373: }
80374:
80375: /* Allocate the new entry in the db->aDb[] array and initialise the schema
80376: ** hash tables.
80377: */
80378: if( db->aDb==db->aDbStatic ){
80379: aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );
80380: if( aNew==0 ) return;
80381: memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
80382: }else{
80383: aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
80384: if( aNew==0 ) return;
80385: }
80386: db->aDb = aNew;
80387: aNew = &db->aDb[db->nDb];
80388: memset(aNew, 0, sizeof(*aNew));
80389:
80390: /* Open the database file. If the btree is successfully opened, use
80391: ** it to obtain the database schema. At this point the schema may
80392: ** or may not be initialised.
80393: */
80394: flags = db->openFlags;
80395: rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
80396: if( rc!=SQLITE_OK ){
80397: if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
80398: sqlite3_result_error(context, zErr, -1);
80399: sqlite3_free(zErr);
80400: return;
80401: }
80402: assert( pVfs );
80403: flags |= SQLITE_OPEN_MAIN_DB;
80404: rc = sqlite3BtreeOpen(pVfs, zPath, db, &aNew->pBt, 0, flags);
80405: sqlite3_free( zPath );
80406: db->nDb++;
80407: if( rc==SQLITE_CONSTRAINT ){
80408: rc = SQLITE_ERROR;
80409: zErrDyn = sqlite3MPrintf(db, "database is already attached");
80410: }else if( rc==SQLITE_OK ){
80411: Pager *pPager;
80412: aNew->pSchema = sqlite3SchemaGet(db, aNew->pBt);
80413: if( !aNew->pSchema ){
80414: rc = SQLITE_NOMEM;
80415: }else if( aNew->pSchema->file_format && aNew->pSchema->enc!=ENC(db) ){
80416: zErrDyn = sqlite3MPrintf(db,
80417: "attached databases must use the same text encoding as main database");
80418: rc = SQLITE_ERROR;
80419: }
80420: pPager = sqlite3BtreePager(aNew->pBt);
80421: sqlite3PagerLockingMode(pPager, db->dfltLockMode);
80422: sqlite3BtreeSecureDelete(aNew->pBt,
80423: sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
80424: }
80425: aNew->safety_level = 3;
80426: aNew->zName = sqlite3DbStrDup(db, zName);
80427: if( rc==SQLITE_OK && aNew->zName==0 ){
80428: rc = SQLITE_NOMEM;
80429: }
80430:
80431:
80432: #ifdef SQLITE_HAS_CODEC
80433: if( rc==SQLITE_OK ){
80434: extern int sqlite3CodecAttach(sqlite3*, int, const void*, int);
80435: extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
80436: int nKey;
80437: char *zKey;
80438: int t = sqlite3_value_type(argv[2]);
80439: switch( t ){
80440: case SQLITE_INTEGER:
80441: case SQLITE_FLOAT:
80442: zErrDyn = sqlite3DbStrDup(db, "Invalid key value");
80443: rc = SQLITE_ERROR;
80444: break;
80445:
80446: case SQLITE_TEXT:
80447: case SQLITE_BLOB:
80448: nKey = sqlite3_value_bytes(argv[2]);
80449: zKey = (char *)sqlite3_value_blob(argv[2]);
80450: rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
80451: break;
80452:
80453: case SQLITE_NULL:
80454: /* No key specified. Use the key from the main database */
80455: sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
80456: if( nKey>0 || sqlite3BtreeGetReserve(db->aDb[0].pBt)>0 ){
80457: rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
80458: }
80459: break;
80460: }
80461: }
80462: #endif
80463:
80464: /* If the file was opened successfully, read the schema for the new database.
80465: ** If this fails, or if opening the file failed, then close the file and
80466: ** remove the entry from the db->aDb[] array. i.e. put everything back the way
80467: ** we found it.
80468: */
80469: if( rc==SQLITE_OK ){
80470: sqlite3BtreeEnterAll(db);
80471: rc = sqlite3Init(db, &zErrDyn);
80472: sqlite3BtreeLeaveAll(db);
80473: }
80474: if( rc ){
80475: int iDb = db->nDb - 1;
80476: assert( iDb>=2 );
80477: if( db->aDb[iDb].pBt ){
80478: sqlite3BtreeClose(db->aDb[iDb].pBt);
80479: db->aDb[iDb].pBt = 0;
80480: db->aDb[iDb].pSchema = 0;
80481: }
80482: sqlite3ResetInternalSchema(db, -1);
80483: db->nDb = iDb;
80484: if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
80485: db->mallocFailed = 1;
80486: sqlite3DbFree(db, zErrDyn);
80487: zErrDyn = sqlite3MPrintf(db, "out of memory");
80488: }else if( zErrDyn==0 ){
80489: zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);
80490: }
80491: goto attach_error;
80492: }
80493:
80494: return;
80495:
80496: attach_error:
80497: /* Return an error if we get here */
80498: if( zErrDyn ){
80499: sqlite3_result_error(context, zErrDyn, -1);
80500: sqlite3DbFree(db, zErrDyn);
80501: }
80502: if( rc ) sqlite3_result_error_code(context, rc);
80503: }
80504:
80505: /*
80506: ** An SQL user-function registered to do the work of an DETACH statement. The
80507: ** three arguments to the function come directly from a detach statement:
80508: **
80509: ** DETACH DATABASE x
80510: **
80511: ** SELECT sqlite_detach(x)
80512: */
80513: static void detachFunc(
80514: sqlite3_context *context,
80515: int NotUsed,
80516: sqlite3_value **argv
80517: ){
80518: const char *zName = (const char *)sqlite3_value_text(argv[0]);
80519: sqlite3 *db = sqlite3_context_db_handle(context);
80520: int i;
80521: Db *pDb = 0;
80522: char zErr[128];
80523:
80524: UNUSED_PARAMETER(NotUsed);
80525:
80526: if( zName==0 ) zName = "";
80527: for(i=0; i<db->nDb; i++){
80528: pDb = &db->aDb[i];
80529: if( pDb->pBt==0 ) continue;
80530: if( sqlite3StrICmp(pDb->zName, zName)==0 ) break;
80531: }
80532:
80533: if( i>=db->nDb ){
80534: sqlite3_snprintf(sizeof(zErr),zErr, "no such database: %s", zName);
80535: goto detach_error;
80536: }
80537: if( i<2 ){
80538: sqlite3_snprintf(sizeof(zErr),zErr, "cannot detach database %s", zName);
80539: goto detach_error;
80540: }
80541: if( !db->autoCommit ){
80542: sqlite3_snprintf(sizeof(zErr), zErr,
80543: "cannot DETACH database within transaction");
80544: goto detach_error;
80545: }
80546: if( sqlite3BtreeIsInReadTrans(pDb->pBt) || sqlite3BtreeIsInBackup(pDb->pBt) ){
80547: sqlite3_snprintf(sizeof(zErr),zErr, "database %s is locked", zName);
80548: goto detach_error;
80549: }
80550:
80551: sqlite3BtreeClose(pDb->pBt);
80552: pDb->pBt = 0;
80553: pDb->pSchema = 0;
80554: sqlite3ResetInternalSchema(db, -1);
80555: return;
80556:
80557: detach_error:
80558: sqlite3_result_error(context, zErr, -1);
80559: }
80560:
80561: /*
80562: ** This procedure generates VDBE code for a single invocation of either the
80563: ** sqlite_detach() or sqlite_attach() SQL user functions.
80564: */
80565: static void codeAttach(
80566: Parse *pParse, /* The parser context */
80567: int type, /* Either SQLITE_ATTACH or SQLITE_DETACH */
80568: FuncDef const *pFunc,/* FuncDef wrapper for detachFunc() or attachFunc() */
80569: Expr *pAuthArg, /* Expression to pass to authorization callback */
80570: Expr *pFilename, /* Name of database file */
80571: Expr *pDbname, /* Name of the database to use internally */
80572: Expr *pKey /* Database key for encryption extension */
80573: ){
80574: int rc;
80575: NameContext sName;
80576: Vdbe *v;
80577: sqlite3* db = pParse->db;
80578: int regArgs;
80579:
80580: memset(&sName, 0, sizeof(NameContext));
80581: sName.pParse = pParse;
80582:
80583: if(
80584: SQLITE_OK!=(rc = resolveAttachExpr(&sName, pFilename)) ||
80585: SQLITE_OK!=(rc = resolveAttachExpr(&sName, pDbname)) ||
80586: SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
80587: ){
80588: pParse->nErr++;
80589: goto attach_end;
80590: }
80591:
80592: #ifndef SQLITE_OMIT_AUTHORIZATION
80593: if( pAuthArg ){
80594: char *zAuthArg;
80595: if( pAuthArg->op==TK_STRING ){
80596: zAuthArg = pAuthArg->u.zToken;
80597: }else{
80598: zAuthArg = 0;
80599: }
80600: rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
80601: if(rc!=SQLITE_OK ){
80602: goto attach_end;
80603: }
80604: }
80605: #endif /* SQLITE_OMIT_AUTHORIZATION */
80606:
80607:
80608: v = sqlite3GetVdbe(pParse);
80609: regArgs = sqlite3GetTempRange(pParse, 4);
80610: sqlite3ExprCode(pParse, pFilename, regArgs);
80611: sqlite3ExprCode(pParse, pDbname, regArgs+1);
80612: sqlite3ExprCode(pParse, pKey, regArgs+2);
80613:
80614: assert( v || db->mallocFailed );
80615: if( v ){
80616: sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-pFunc->nArg, regArgs+3);
80617: assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg );
80618: sqlite3VdbeChangeP5(v, (u8)(pFunc->nArg));
80619: sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);
80620:
80621: /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
80622: ** statement only). For DETACH, set it to false (expire all existing
80623: ** statements).
80624: */
80625: sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
80626: }
80627:
80628: attach_end:
80629: sqlite3ExprDelete(db, pFilename);
80630: sqlite3ExprDelete(db, pDbname);
80631: sqlite3ExprDelete(db, pKey);
80632: }
80633:
80634: /*
80635: ** Called by the parser to compile a DETACH statement.
80636: **
80637: ** DETACH pDbname
80638: */
80639: SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){
80640: static const FuncDef detach_func = {
80641: 1, /* nArg */
80642: SQLITE_UTF8, /* iPrefEnc */
80643: 0, /* flags */
80644: 0, /* pUserData */
80645: 0, /* pNext */
80646: detachFunc, /* xFunc */
80647: 0, /* xStep */
80648: 0, /* xFinalize */
80649: "sqlite_detach", /* zName */
80650: 0, /* pHash */
80651: 0 /* pDestructor */
80652: };
80653: codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);
80654: }
80655:
80656: /*
80657: ** Called by the parser to compile an ATTACH statement.
80658: **
80659: ** ATTACH p AS pDbname KEY pKey
80660: */
80661: SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
80662: static const FuncDef attach_func = {
80663: 3, /* nArg */
80664: SQLITE_UTF8, /* iPrefEnc */
80665: 0, /* flags */
80666: 0, /* pUserData */
80667: 0, /* pNext */
80668: attachFunc, /* xFunc */
80669: 0, /* xStep */
80670: 0, /* xFinalize */
80671: "sqlite_attach", /* zName */
80672: 0, /* pHash */
80673: 0 /* pDestructor */
80674: };
80675: codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
80676: }
80677: #endif /* SQLITE_OMIT_ATTACH */
80678:
80679: /*
80680: ** Initialize a DbFixer structure. This routine must be called prior
80681: ** to passing the structure to one of the sqliteFixAAAA() routines below.
80682: **
80683: ** The return value indicates whether or not fixation is required. TRUE
80684: ** means we do need to fix the database references, FALSE means we do not.
80685: */
80686: SQLITE_PRIVATE int sqlite3FixInit(
80687: DbFixer *pFix, /* The fixer to be initialized */
80688: Parse *pParse, /* Error messages will be written here */
80689: int iDb, /* This is the database that must be used */
80690: const char *zType, /* "view", "trigger", or "index" */
80691: const Token *pName /* Name of the view, trigger, or index */
80692: ){
80693: sqlite3 *db;
80694:
80695: if( NEVER(iDb<0) || iDb==1 ) return 0;
80696: db = pParse->db;
80697: assert( db->nDb>iDb );
80698: pFix->pParse = pParse;
80699: pFix->zDb = db->aDb[iDb].zName;
80700: pFix->zType = zType;
80701: pFix->pName = pName;
80702: return 1;
80703: }
80704:
80705: /*
80706: ** The following set of routines walk through the parse tree and assign
80707: ** a specific database to all table references where the database name
80708: ** was left unspecified in the original SQL statement. The pFix structure
80709: ** must have been initialized by a prior call to sqlite3FixInit().
80710: **
80711: ** These routines are used to make sure that an index, trigger, or
80712: ** view in one database does not refer to objects in a different database.
80713: ** (Exception: indices, triggers, and views in the TEMP database are
80714: ** allowed to refer to anything.) If a reference is explicitly made
80715: ** to an object in a different database, an error message is added to
80716: ** pParse->zErrMsg and these routines return non-zero. If everything
80717: ** checks out, these routines return 0.
80718: */
80719: SQLITE_PRIVATE int sqlite3FixSrcList(
80720: DbFixer *pFix, /* Context of the fixation */
80721: SrcList *pList /* The Source list to check and modify */
80722: ){
80723: int i;
80724: const char *zDb;
80725: struct SrcList_item *pItem;
80726:
80727: if( NEVER(pList==0) ) return 0;
80728: zDb = pFix->zDb;
80729: for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
80730: if( pItem->zDatabase==0 ){
80731: pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb);
80732: }else if( sqlite3StrICmp(pItem->zDatabase,zDb)!=0 ){
80733: sqlite3ErrorMsg(pFix->pParse,
80734: "%s %T cannot reference objects in database %s",
80735: pFix->zType, pFix->pName, pItem->zDatabase);
80736: return 1;
80737: }
80738: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
80739: if( sqlite3FixSelect(pFix, pItem->pSelect) ) return 1;
80740: if( sqlite3FixExpr(pFix, pItem->pOn) ) return 1;
80741: #endif
80742: }
80743: return 0;
80744: }
80745: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_TRIGGER)
80746: SQLITE_PRIVATE int sqlite3FixSelect(
80747: DbFixer *pFix, /* Context of the fixation */
80748: Select *pSelect /* The SELECT statement to be fixed to one database */
80749: ){
80750: while( pSelect ){
80751: if( sqlite3FixExprList(pFix, pSelect->pEList) ){
80752: return 1;
80753: }
80754: if( sqlite3FixSrcList(pFix, pSelect->pSrc) ){
80755: return 1;
80756: }
80757: if( sqlite3FixExpr(pFix, pSelect->pWhere) ){
80758: return 1;
80759: }
80760: if( sqlite3FixExpr(pFix, pSelect->pHaving) ){
80761: return 1;
80762: }
80763: pSelect = pSelect->pPrior;
80764: }
80765: return 0;
80766: }
80767: SQLITE_PRIVATE int sqlite3FixExpr(
80768: DbFixer *pFix, /* Context of the fixation */
80769: Expr *pExpr /* The expression to be fixed to one database */
80770: ){
80771: while( pExpr ){
80772: if( ExprHasAnyProperty(pExpr, EP_TokenOnly) ) break;
80773: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
80774: if( sqlite3FixSelect(pFix, pExpr->x.pSelect) ) return 1;
80775: }else{
80776: if( sqlite3FixExprList(pFix, pExpr->x.pList) ) return 1;
80777: }
80778: if( sqlite3FixExpr(pFix, pExpr->pRight) ){
80779: return 1;
80780: }
80781: pExpr = pExpr->pLeft;
80782: }
80783: return 0;
80784: }
80785: SQLITE_PRIVATE int sqlite3FixExprList(
80786: DbFixer *pFix, /* Context of the fixation */
80787: ExprList *pList /* The expression to be fixed to one database */
80788: ){
80789: int i;
80790: struct ExprList_item *pItem;
80791: if( pList==0 ) return 0;
80792: for(i=0, pItem=pList->a; i<pList->nExpr; i++, pItem++){
80793: if( sqlite3FixExpr(pFix, pItem->pExpr) ){
80794: return 1;
80795: }
80796: }
80797: return 0;
80798: }
80799: #endif
80800:
80801: #ifndef SQLITE_OMIT_TRIGGER
80802: SQLITE_PRIVATE int sqlite3FixTriggerStep(
80803: DbFixer *pFix, /* Context of the fixation */
80804: TriggerStep *pStep /* The trigger step be fixed to one database */
80805: ){
80806: while( pStep ){
80807: if( sqlite3FixSelect(pFix, pStep->pSelect) ){
80808: return 1;
80809: }
80810: if( sqlite3FixExpr(pFix, pStep->pWhere) ){
80811: return 1;
80812: }
80813: if( sqlite3FixExprList(pFix, pStep->pExprList) ){
80814: return 1;
80815: }
80816: pStep = pStep->pNext;
80817: }
80818: return 0;
80819: }
80820: #endif
80821:
80822: /************** End of attach.c **********************************************/
80823: /************** Begin file auth.c ********************************************/
80824: /*
80825: ** 2003 January 11
80826: **
80827: ** The author disclaims copyright to this source code. In place of
80828: ** a legal notice, here is a blessing:
80829: **
80830: ** May you do good and not evil.
80831: ** May you find forgiveness for yourself and forgive others.
80832: ** May you share freely, never taking more than you give.
80833: **
80834: *************************************************************************
80835: ** This file contains code used to implement the sqlite3_set_authorizer()
80836: ** API. This facility is an optional feature of the library. Embedded
80837: ** systems that do not need this facility may omit it by recompiling
80838: ** the library with -DSQLITE_OMIT_AUTHORIZATION=1
80839: */
80840:
80841: /*
80842: ** All of the code in this file may be omitted by defining a single
80843: ** macro.
80844: */
80845: #ifndef SQLITE_OMIT_AUTHORIZATION
80846:
80847: /*
80848: ** Set or clear the access authorization function.
80849: **
80850: ** The access authorization function is be called during the compilation
80851: ** phase to verify that the user has read and/or write access permission on
80852: ** various fields of the database. The first argument to the auth function
80853: ** is a copy of the 3rd argument to this routine. The second argument
80854: ** to the auth function is one of these constants:
80855: **
80856: ** SQLITE_CREATE_INDEX
80857: ** SQLITE_CREATE_TABLE
80858: ** SQLITE_CREATE_TEMP_INDEX
80859: ** SQLITE_CREATE_TEMP_TABLE
80860: ** SQLITE_CREATE_TEMP_TRIGGER
80861: ** SQLITE_CREATE_TEMP_VIEW
80862: ** SQLITE_CREATE_TRIGGER
80863: ** SQLITE_CREATE_VIEW
80864: ** SQLITE_DELETE
80865: ** SQLITE_DROP_INDEX
80866: ** SQLITE_DROP_TABLE
80867: ** SQLITE_DROP_TEMP_INDEX
80868: ** SQLITE_DROP_TEMP_TABLE
80869: ** SQLITE_DROP_TEMP_TRIGGER
80870: ** SQLITE_DROP_TEMP_VIEW
80871: ** SQLITE_DROP_TRIGGER
80872: ** SQLITE_DROP_VIEW
80873: ** SQLITE_INSERT
80874: ** SQLITE_PRAGMA
80875: ** SQLITE_READ
80876: ** SQLITE_SELECT
80877: ** SQLITE_TRANSACTION
80878: ** SQLITE_UPDATE
80879: **
80880: ** The third and fourth arguments to the auth function are the name of
80881: ** the table and the column that are being accessed. The auth function
80882: ** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If
80883: ** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY
80884: ** means that the SQL statement will never-run - the sqlite3_exec() call
80885: ** will return with an error. SQLITE_IGNORE means that the SQL statement
80886: ** should run but attempts to read the specified column will return NULL
80887: ** and attempts to write the column will be ignored.
80888: **
80889: ** Setting the auth function to NULL disables this hook. The default
80890: ** setting of the auth function is NULL.
80891: */
80892: SQLITE_API int sqlite3_set_authorizer(
80893: sqlite3 *db,
80894: int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
80895: void *pArg
80896: ){
80897: sqlite3_mutex_enter(db->mutex);
80898: db->xAuth = xAuth;
80899: db->pAuthArg = pArg;
80900: sqlite3ExpirePreparedStatements(db);
80901: sqlite3_mutex_leave(db->mutex);
80902: return SQLITE_OK;
80903: }
80904:
80905: /*
80906: ** Write an error message into pParse->zErrMsg that explains that the
80907: ** user-supplied authorization function returned an illegal value.
80908: */
80909: static void sqliteAuthBadReturnCode(Parse *pParse){
80910: sqlite3ErrorMsg(pParse, "authorizer malfunction");
80911: pParse->rc = SQLITE_ERROR;
80912: }
80913:
80914: /*
80915: ** Invoke the authorization callback for permission to read column zCol from
80916: ** table zTab in database zDb. This function assumes that an authorization
80917: ** callback has been registered (i.e. that sqlite3.xAuth is not NULL).
80918: **
80919: ** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
80920: ** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE
80921: ** is treated as SQLITE_DENY. In this case an error is left in pParse.
80922: */
80923: SQLITE_PRIVATE int sqlite3AuthReadCol(
80924: Parse *pParse, /* The parser context */
80925: const char *zTab, /* Table name */
80926: const char *zCol, /* Column name */
80927: int iDb /* Index of containing database. */
80928: ){
80929: sqlite3 *db = pParse->db; /* Database handle */
80930: char *zDb = db->aDb[iDb].zName; /* Name of attached database */
80931: int rc; /* Auth callback return code */
80932:
80933: rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext);
80934: if( rc==SQLITE_DENY ){
80935: if( db->nDb>2 || iDb!=0 ){
80936: sqlite3ErrorMsg(pParse, "access to %s.%s.%s is prohibited",zDb,zTab,zCol);
80937: }else{
80938: sqlite3ErrorMsg(pParse, "access to %s.%s is prohibited", zTab, zCol);
80939: }
80940: pParse->rc = SQLITE_AUTH;
80941: }else if( rc!=SQLITE_IGNORE && rc!=SQLITE_OK ){
80942: sqliteAuthBadReturnCode(pParse);
80943: }
80944: return rc;
80945: }
80946:
80947: /*
80948: ** The pExpr should be a TK_COLUMN expression. The table referred to
80949: ** is in pTabList or else it is the NEW or OLD table of a trigger.
80950: ** Check to see if it is OK to read this particular column.
80951: **
80952: ** If the auth function returns SQLITE_IGNORE, change the TK_COLUMN
80953: ** instruction into a TK_NULL. If the auth function returns SQLITE_DENY,
80954: ** then generate an error.
80955: */
80956: SQLITE_PRIVATE void sqlite3AuthRead(
80957: Parse *pParse, /* The parser context */
80958: Expr *pExpr, /* The expression to check authorization on */
80959: Schema *pSchema, /* The schema of the expression */
80960: SrcList *pTabList /* All table that pExpr might refer to */
80961: ){
80962: sqlite3 *db = pParse->db;
80963: Table *pTab = 0; /* The table being read */
80964: const char *zCol; /* Name of the column of the table */
80965: int iSrc; /* Index in pTabList->a[] of table being read */
80966: int iDb; /* The index of the database the expression refers to */
80967: int iCol; /* Index of column in table */
80968:
80969: if( db->xAuth==0 ) return;
80970: iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
80971: if( iDb<0 ){
80972: /* An attempt to read a column out of a subquery or other
80973: ** temporary table. */
80974: return;
80975: }
80976:
80977: assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
80978: if( pExpr->op==TK_TRIGGER ){
80979: pTab = pParse->pTriggerTab;
80980: }else{
80981: assert( pTabList );
80982: for(iSrc=0; ALWAYS(iSrc<pTabList->nSrc); iSrc++){
80983: if( pExpr->iTable==pTabList->a[iSrc].iCursor ){
80984: pTab = pTabList->a[iSrc].pTab;
80985: break;
80986: }
80987: }
80988: }
80989: iCol = pExpr->iColumn;
80990: if( NEVER(pTab==0) ) return;
80991:
80992: if( iCol>=0 ){
80993: assert( iCol<pTab->nCol );
80994: zCol = pTab->aCol[iCol].zName;
80995: }else if( pTab->iPKey>=0 ){
80996: assert( pTab->iPKey<pTab->nCol );
80997: zCol = pTab->aCol[pTab->iPKey].zName;
80998: }else{
80999: zCol = "ROWID";
81000: }
81001: assert( iDb>=0 && iDb<db->nDb );
81002: if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
81003: pExpr->op = TK_NULL;
81004: }
81005: }
81006:
81007: /*
81008: ** Do an authorization check using the code and arguments given. Return
81009: ** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY
81010: ** is returned, then the error count and error message in pParse are
81011: ** modified appropriately.
81012: */
81013: SQLITE_PRIVATE int sqlite3AuthCheck(
81014: Parse *pParse,
81015: int code,
81016: const char *zArg1,
81017: const char *zArg2,
81018: const char *zArg3
81019: ){
81020: sqlite3 *db = pParse->db;
81021: int rc;
81022:
81023: /* Don't do any authorization checks if the database is initialising
81024: ** or if the parser is being invoked from within sqlite3_declare_vtab.
81025: */
81026: if( db->init.busy || IN_DECLARE_VTAB ){
81027: return SQLITE_OK;
81028: }
81029:
81030: if( db->xAuth==0 ){
81031: return SQLITE_OK;
81032: }
81033: rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext);
81034: if( rc==SQLITE_DENY ){
81035: sqlite3ErrorMsg(pParse, "not authorized");
81036: pParse->rc = SQLITE_AUTH;
81037: }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){
81038: rc = SQLITE_DENY;
81039: sqliteAuthBadReturnCode(pParse);
81040: }
81041: return rc;
81042: }
81043:
81044: /*
81045: ** Push an authorization context. After this routine is called, the
81046: ** zArg3 argument to authorization callbacks will be zContext until
81047: ** popped. Or if pParse==0, this routine is a no-op.
81048: */
81049: SQLITE_PRIVATE void sqlite3AuthContextPush(
81050: Parse *pParse,
81051: AuthContext *pContext,
81052: const char *zContext
81053: ){
81054: assert( pParse );
81055: pContext->pParse = pParse;
81056: pContext->zAuthContext = pParse->zAuthContext;
81057: pParse->zAuthContext = zContext;
81058: }
81059:
81060: /*
81061: ** Pop an authorization context that was previously pushed
81062: ** by sqlite3AuthContextPush
81063: */
81064: SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext *pContext){
81065: if( pContext->pParse ){
81066: pContext->pParse->zAuthContext = pContext->zAuthContext;
81067: pContext->pParse = 0;
81068: }
81069: }
81070:
81071: #endif /* SQLITE_OMIT_AUTHORIZATION */
81072:
81073: /************** End of auth.c ************************************************/
81074: /************** Begin file build.c *******************************************/
81075: /*
81076: ** 2001 September 15
81077: **
81078: ** The author disclaims copyright to this source code. In place of
81079: ** a legal notice, here is a blessing:
81080: **
81081: ** May you do good and not evil.
81082: ** May you find forgiveness for yourself and forgive others.
81083: ** May you share freely, never taking more than you give.
81084: **
81085: *************************************************************************
81086: ** This file contains C code routines that are called by the SQLite parser
81087: ** when syntax rules are reduced. The routines in this file handle the
81088: ** following kinds of SQL syntax:
81089: **
81090: ** CREATE TABLE
81091: ** DROP TABLE
81092: ** CREATE INDEX
81093: ** DROP INDEX
81094: ** creating ID lists
81095: ** BEGIN TRANSACTION
81096: ** COMMIT
81097: ** ROLLBACK
81098: */
81099:
81100: /*
81101: ** This routine is called when a new SQL statement is beginning to
81102: ** be parsed. Initialize the pParse structure as needed.
81103: */
81104: SQLITE_PRIVATE void sqlite3BeginParse(Parse *pParse, int explainFlag){
81105: pParse->explain = (u8)explainFlag;
81106: pParse->nVar = 0;
81107: }
81108:
81109: #ifndef SQLITE_OMIT_SHARED_CACHE
81110: /*
81111: ** The TableLock structure is only used by the sqlite3TableLock() and
81112: ** codeTableLocks() functions.
81113: */
81114: struct TableLock {
81115: int iDb; /* The database containing the table to be locked */
81116: int iTab; /* The root page of the table to be locked */
81117: u8 isWriteLock; /* True for write lock. False for a read lock */
81118: const char *zName; /* Name of the table */
81119: };
81120:
81121: /*
81122: ** Record the fact that we want to lock a table at run-time.
81123: **
81124: ** The table to be locked has root page iTab and is found in database iDb.
81125: ** A read or a write lock can be taken depending on isWritelock.
81126: **
81127: ** This routine just records the fact that the lock is desired. The
81128: ** code to make the lock occur is generated by a later call to
81129: ** codeTableLocks() which occurs during sqlite3FinishCoding().
81130: */
81131: SQLITE_PRIVATE void sqlite3TableLock(
81132: Parse *pParse, /* Parsing context */
81133: int iDb, /* Index of the database containing the table to lock */
81134: int iTab, /* Root page number of the table to be locked */
81135: u8 isWriteLock, /* True for a write lock */
81136: const char *zName /* Name of the table to be locked */
81137: ){
81138: Parse *pToplevel = sqlite3ParseToplevel(pParse);
81139: int i;
81140: int nBytes;
81141: TableLock *p;
81142: assert( iDb>=0 );
81143:
81144: for(i=0; i<pToplevel->nTableLock; i++){
81145: p = &pToplevel->aTableLock[i];
81146: if( p->iDb==iDb && p->iTab==iTab ){
81147: p->isWriteLock = (p->isWriteLock || isWriteLock);
81148: return;
81149: }
81150: }
81151:
81152: nBytes = sizeof(TableLock) * (pToplevel->nTableLock+1);
81153: pToplevel->aTableLock =
81154: sqlite3DbReallocOrFree(pToplevel->db, pToplevel->aTableLock, nBytes);
81155: if( pToplevel->aTableLock ){
81156: p = &pToplevel->aTableLock[pToplevel->nTableLock++];
81157: p->iDb = iDb;
81158: p->iTab = iTab;
81159: p->isWriteLock = isWriteLock;
81160: p->zName = zName;
81161: }else{
81162: pToplevel->nTableLock = 0;
81163: pToplevel->db->mallocFailed = 1;
81164: }
81165: }
81166:
81167: /*
81168: ** Code an OP_TableLock instruction for each table locked by the
81169: ** statement (configured by calls to sqlite3TableLock()).
81170: */
81171: static void codeTableLocks(Parse *pParse){
81172: int i;
81173: Vdbe *pVdbe;
81174:
81175: pVdbe = sqlite3GetVdbe(pParse);
81176: assert( pVdbe!=0 ); /* sqlite3GetVdbe cannot fail: VDBE already allocated */
81177:
81178: for(i=0; i<pParse->nTableLock; i++){
81179: TableLock *p = &pParse->aTableLock[i];
81180: int p1 = p->iDb;
81181: sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
81182: p->zName, P4_STATIC);
81183: }
81184: }
81185: #else
81186: #define codeTableLocks(x)
81187: #endif
81188:
81189: /*
81190: ** This routine is called after a single SQL statement has been
81191: ** parsed and a VDBE program to execute that statement has been
81192: ** prepared. This routine puts the finishing touches on the
81193: ** VDBE program and resets the pParse structure for the next
81194: ** parse.
81195: **
81196: ** Note that if an error occurred, it might be the case that
81197: ** no VDBE code was generated.
81198: */
81199: SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
81200: sqlite3 *db;
81201: Vdbe *v;
81202:
81203: db = pParse->db;
81204: if( db->mallocFailed ) return;
81205: if( pParse->nested ) return;
81206: if( pParse->nErr ) return;
81207:
81208: /* Begin by generating some termination code at the end of the
81209: ** vdbe program
81210: */
81211: v = sqlite3GetVdbe(pParse);
81212: assert( !pParse->isMultiWrite
81213: || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
81214: if( v ){
81215: sqlite3VdbeAddOp0(v, OP_Halt);
81216:
81217: /* The cookie mask contains one bit for each database file open.
81218: ** (Bit 0 is for main, bit 1 is for temp, and so forth.) Bits are
81219: ** set for each database that is used. Generate code to start a
81220: ** transaction on each used database and to verify the schema cookie
81221: ** on each used database.
81222: */
81223: if( pParse->cookieGoto>0 ){
81224: yDbMask mask;
81225: int iDb;
81226: sqlite3VdbeJumpHere(v, pParse->cookieGoto-1);
81227: for(iDb=0, mask=1; iDb<db->nDb; mask<<=1, iDb++){
81228: if( (mask & pParse->cookieMask)==0 ) continue;
81229: sqlite3VdbeUsesBtree(v, iDb);
81230: sqlite3VdbeAddOp2(v,OP_Transaction, iDb, (mask & pParse->writeMask)!=0);
81231: if( db->init.busy==0 ){
81232: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
81233: sqlite3VdbeAddOp3(v, OP_VerifyCookie,
81234: iDb, pParse->cookieValue[iDb],
81235: db->aDb[iDb].pSchema->iGeneration);
81236: }
81237: }
81238: #ifndef SQLITE_OMIT_VIRTUALTABLE
81239: {
81240: int i;
81241: for(i=0; i<pParse->nVtabLock; i++){
81242: char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
81243: sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
81244: }
81245: pParse->nVtabLock = 0;
81246: }
81247: #endif
81248:
81249: /* Once all the cookies have been verified and transactions opened,
81250: ** obtain the required table-locks. This is a no-op unless the
81251: ** shared-cache feature is enabled.
81252: */
81253: codeTableLocks(pParse);
81254:
81255: /* Initialize any AUTOINCREMENT data structures required.
81256: */
81257: sqlite3AutoincrementBegin(pParse);
81258:
81259: /* Finally, jump back to the beginning of the executable code. */
81260: sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->cookieGoto);
81261: }
81262: }
81263:
81264:
81265: /* Get the VDBE program ready for execution
81266: */
81267: if( v && ALWAYS(pParse->nErr==0) && !db->mallocFailed ){
81268: #ifdef SQLITE_DEBUG
81269: FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0;
81270: sqlite3VdbeTrace(v, trace);
81271: #endif
81272: assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */
81273: /* A minimum of one cursor is required if autoincrement is used
81274: * See ticket [a696379c1f08866] */
81275: if( pParse->pAinc!=0 && pParse->nTab==0 ) pParse->nTab = 1;
81276: sqlite3VdbeMakeReady(v, pParse);
81277: pParse->rc = SQLITE_DONE;
81278: pParse->colNamesSet = 0;
81279: }else{
81280: pParse->rc = SQLITE_ERROR;
81281: }
81282: pParse->nTab = 0;
81283: pParse->nMem = 0;
81284: pParse->nSet = 0;
81285: pParse->nVar = 0;
81286: pParse->cookieMask = 0;
81287: pParse->cookieGoto = 0;
81288: }
81289:
81290: /*
81291: ** Run the parser and code generator recursively in order to generate
81292: ** code for the SQL statement given onto the end of the pParse context
81293: ** currently under construction. When the parser is run recursively
81294: ** this way, the final OP_Halt is not appended and other initialization
81295: ** and finalization steps are omitted because those are handling by the
81296: ** outermost parser.
81297: **
81298: ** Not everything is nestable. This facility is designed to permit
81299: ** INSERT, UPDATE, and DELETE operations against SQLITE_MASTER. Use
81300: ** care if you decide to try to use this routine for some other purposes.
81301: */
81302: SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
81303: va_list ap;
81304: char *zSql;
81305: char *zErrMsg = 0;
81306: sqlite3 *db = pParse->db;
81307: # define SAVE_SZ (sizeof(Parse) - offsetof(Parse,nVar))
81308: char saveBuf[SAVE_SZ];
81309:
81310: if( pParse->nErr ) return;
81311: assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
81312: va_start(ap, zFormat);
81313: zSql = sqlite3VMPrintf(db, zFormat, ap);
81314: va_end(ap);
81315: if( zSql==0 ){
81316: return; /* A malloc must have failed */
81317: }
81318: pParse->nested++;
81319: memcpy(saveBuf, &pParse->nVar, SAVE_SZ);
81320: memset(&pParse->nVar, 0, SAVE_SZ);
81321: sqlite3RunParser(pParse, zSql, &zErrMsg);
81322: sqlite3DbFree(db, zErrMsg);
81323: sqlite3DbFree(db, zSql);
81324: memcpy(&pParse->nVar, saveBuf, SAVE_SZ);
81325: pParse->nested--;
81326: }
81327:
81328: /*
81329: ** Locate the in-memory structure that describes a particular database
81330: ** table given the name of that table and (optionally) the name of the
81331: ** database containing the table. Return NULL if not found.
81332: **
81333: ** If zDatabase is 0, all databases are searched for the table and the
81334: ** first matching table is returned. (No checking for duplicate table
81335: ** names is done.) The search order is TEMP first, then MAIN, then any
81336: ** auxiliary databases added using the ATTACH command.
81337: **
81338: ** See also sqlite3LocateTable().
81339: */
81340: SQLITE_PRIVATE Table *sqlite3FindTable(sqlite3 *db, const char *zName, const char *zDatabase){
81341: Table *p = 0;
81342: int i;
81343: int nName;
81344: assert( zName!=0 );
81345: nName = sqlite3Strlen30(zName);
81346: /* All mutexes are required for schema access. Make sure we hold them. */
81347: assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
81348: for(i=OMIT_TEMPDB; i<db->nDb; i++){
81349: int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
81350: if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
81351: assert( sqlite3SchemaMutexHeld(db, j, 0) );
81352: p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName, nName);
81353: if( p ) break;
81354: }
81355: return p;
81356: }
81357:
81358: /*
81359: ** Locate the in-memory structure that describes a particular database
81360: ** table given the name of that table and (optionally) the name of the
81361: ** database containing the table. Return NULL if not found. Also leave an
81362: ** error message in pParse->zErrMsg.
81363: **
81364: ** The difference between this routine and sqlite3FindTable() is that this
81365: ** routine leaves an error message in pParse->zErrMsg where
81366: ** sqlite3FindTable() does not.
81367: */
81368: SQLITE_PRIVATE Table *sqlite3LocateTable(
81369: Parse *pParse, /* context in which to report errors */
81370: int isView, /* True if looking for a VIEW rather than a TABLE */
81371: const char *zName, /* Name of the table we are looking for */
81372: const char *zDbase /* Name of the database. Might be NULL */
81373: ){
81374: Table *p;
81375:
81376: /* Read the database schema. If an error occurs, leave an error message
81377: ** and code in pParse and return NULL. */
81378: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
81379: return 0;
81380: }
81381:
81382: p = sqlite3FindTable(pParse->db, zName, zDbase);
81383: if( p==0 ){
81384: const char *zMsg = isView ? "no such view" : "no such table";
81385: if( zDbase ){
81386: sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
81387: }else{
81388: sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
81389: }
81390: pParse->checkSchema = 1;
81391: }
81392: return p;
81393: }
81394:
81395: /*
81396: ** Locate the in-memory structure that describes
81397: ** a particular index given the name of that index
81398: ** and the name of the database that contains the index.
81399: ** Return NULL if not found.
81400: **
81401: ** If zDatabase is 0, all databases are searched for the
81402: ** table and the first matching index is returned. (No checking
81403: ** for duplicate index names is done.) The search order is
81404: ** TEMP first, then MAIN, then any auxiliary databases added
81405: ** using the ATTACH command.
81406: */
81407: SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const char *zDb){
81408: Index *p = 0;
81409: int i;
81410: int nName = sqlite3Strlen30(zName);
81411: /* All mutexes are required for schema access. Make sure we hold them. */
81412: assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
81413: for(i=OMIT_TEMPDB; i<db->nDb; i++){
81414: int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
81415: Schema *pSchema = db->aDb[j].pSchema;
81416: assert( pSchema );
81417: if( zDb && sqlite3StrICmp(zDb, db->aDb[j].zName) ) continue;
81418: assert( sqlite3SchemaMutexHeld(db, j, 0) );
81419: p = sqlite3HashFind(&pSchema->idxHash, zName, nName);
81420: if( p ) break;
81421: }
81422: return p;
81423: }
81424:
81425: /*
81426: ** Reclaim the memory used by an index
81427: */
81428: static void freeIndex(sqlite3 *db, Index *p){
81429: #ifndef SQLITE_OMIT_ANALYZE
81430: sqlite3DeleteIndexSamples(db, p);
81431: #endif
81432: sqlite3DbFree(db, p->zColAff);
81433: sqlite3DbFree(db, p);
81434: }
81435:
81436: /*
81437: ** For the index called zIdxName which is found in the database iDb,
81438: ** unlike that index from its Table then remove the index from
81439: ** the index hash table and free all memory structures associated
81440: ** with the index.
81441: */
81442: SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char *zIdxName){
81443: Index *pIndex;
81444: int len;
81445: Hash *pHash;
81446:
81447: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
81448: pHash = &db->aDb[iDb].pSchema->idxHash;
81449: len = sqlite3Strlen30(zIdxName);
81450: pIndex = sqlite3HashInsert(pHash, zIdxName, len, 0);
81451: if( ALWAYS(pIndex) ){
81452: if( pIndex->pTable->pIndex==pIndex ){
81453: pIndex->pTable->pIndex = pIndex->pNext;
81454: }else{
81455: Index *p;
81456: /* Justification of ALWAYS(); The index must be on the list of
81457: ** indices. */
81458: p = pIndex->pTable->pIndex;
81459: while( ALWAYS(p) && p->pNext!=pIndex ){ p = p->pNext; }
81460: if( ALWAYS(p && p->pNext==pIndex) ){
81461: p->pNext = pIndex->pNext;
81462: }
81463: }
81464: freeIndex(db, pIndex);
81465: }
81466: db->flags |= SQLITE_InternChanges;
81467: }
81468:
81469: /*
81470: ** Erase all schema information from the in-memory hash tables of
81471: ** a single database. This routine is called to reclaim memory
81472: ** before the database closes. It is also called during a rollback
81473: ** if there were schema changes during the transaction or if a
81474: ** schema-cookie mismatch occurs.
81475: **
81476: ** If iDb<0 then reset the internal schema tables for all database
81477: ** files. If iDb>=0 then reset the internal schema for only the
81478: ** single file indicated.
81479: */
81480: SQLITE_PRIVATE void sqlite3ResetInternalSchema(sqlite3 *db, int iDb){
81481: int i, j;
81482: assert( iDb<db->nDb );
81483:
81484: if( iDb>=0 ){
81485: /* Case 1: Reset the single schema identified by iDb */
81486: Db *pDb = &db->aDb[iDb];
81487: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
81488: assert( pDb->pSchema!=0 );
81489: sqlite3SchemaClear(pDb->pSchema);
81490:
81491: /* If any database other than TEMP is reset, then also reset TEMP
81492: ** since TEMP might be holding triggers that reference tables in the
81493: ** other database.
81494: */
81495: if( iDb!=1 ){
81496: pDb = &db->aDb[1];
81497: assert( pDb->pSchema!=0 );
81498: sqlite3SchemaClear(pDb->pSchema);
81499: }
81500: return;
81501: }
81502: /* Case 2 (from here to the end): Reset all schemas for all attached
81503: ** databases. */
81504: assert( iDb<0 );
81505: sqlite3BtreeEnterAll(db);
81506: for(i=0; i<db->nDb; i++){
81507: Db *pDb = &db->aDb[i];
81508: if( pDb->pSchema ){
81509: sqlite3SchemaClear(pDb->pSchema);
81510: }
81511: }
81512: db->flags &= ~SQLITE_InternChanges;
81513: sqlite3VtabUnlockList(db);
81514: sqlite3BtreeLeaveAll(db);
81515:
81516: /* If one or more of the auxiliary database files has been closed,
81517: ** then remove them from the auxiliary database list. We take the
81518: ** opportunity to do this here since we have just deleted all of the
81519: ** schema hash tables and therefore do not have to make any changes
81520: ** to any of those tables.
81521: */
81522: for(i=j=2; i<db->nDb; i++){
81523: struct Db *pDb = &db->aDb[i];
81524: if( pDb->pBt==0 ){
81525: sqlite3DbFree(db, pDb->zName);
81526: pDb->zName = 0;
81527: continue;
81528: }
81529: if( j<i ){
81530: db->aDb[j] = db->aDb[i];
81531: }
81532: j++;
81533: }
81534: memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
81535: db->nDb = j;
81536: if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
81537: memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
81538: sqlite3DbFree(db, db->aDb);
81539: db->aDb = db->aDbStatic;
81540: }
81541: }
81542:
81543: /*
81544: ** This routine is called when a commit occurs.
81545: */
81546: SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3 *db){
81547: db->flags &= ~SQLITE_InternChanges;
81548: }
81549:
81550: /*
81551: ** Delete memory allocated for the column names of a table or view (the
81552: ** Table.aCol[] array).
81553: */
81554: static void sqliteDeleteColumnNames(sqlite3 *db, Table *pTable){
81555: int i;
81556: Column *pCol;
81557: assert( pTable!=0 );
81558: if( (pCol = pTable->aCol)!=0 ){
81559: for(i=0; i<pTable->nCol; i++, pCol++){
81560: sqlite3DbFree(db, pCol->zName);
81561: sqlite3ExprDelete(db, pCol->pDflt);
81562: sqlite3DbFree(db, pCol->zDflt);
81563: sqlite3DbFree(db, pCol->zType);
81564: sqlite3DbFree(db, pCol->zColl);
81565: }
81566: sqlite3DbFree(db, pTable->aCol);
81567: }
81568: }
81569:
81570: /*
81571: ** Remove the memory data structures associated with the given
81572: ** Table. No changes are made to disk by this routine.
81573: **
81574: ** This routine just deletes the data structure. It does not unlink
81575: ** the table data structure from the hash table. But it does destroy
81576: ** memory structures of the indices and foreign keys associated with
81577: ** the table.
81578: */
81579: SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3 *db, Table *pTable){
81580: Index *pIndex, *pNext;
81581:
81582: assert( !pTable || pTable->nRef>0 );
81583:
81584: /* Do not delete the table until the reference count reaches zero. */
81585: if( !pTable ) return;
81586: if( ((!db || db->pnBytesFreed==0) && (--pTable->nRef)>0) ) return;
81587:
81588: /* Delete all indices associated with this table. */
81589: for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){
81590: pNext = pIndex->pNext;
81591: assert( pIndex->pSchema==pTable->pSchema );
81592: if( !db || db->pnBytesFreed==0 ){
81593: char *zName = pIndex->zName;
81594: TESTONLY ( Index *pOld = ) sqlite3HashInsert(
81595: &pIndex->pSchema->idxHash, zName, sqlite3Strlen30(zName), 0
81596: );
81597: assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
81598: assert( pOld==pIndex || pOld==0 );
81599: }
81600: freeIndex(db, pIndex);
81601: }
81602:
81603: /* Delete any foreign keys attached to this table. */
81604: sqlite3FkDelete(db, pTable);
81605:
81606: /* Delete the Table structure itself.
81607: */
81608: sqliteDeleteColumnNames(db, pTable);
81609: sqlite3DbFree(db, pTable->zName);
81610: sqlite3DbFree(db, pTable->zColAff);
81611: sqlite3SelectDelete(db, pTable->pSelect);
81612: #ifndef SQLITE_OMIT_CHECK
81613: sqlite3ExprDelete(db, pTable->pCheck);
81614: #endif
81615: #ifndef SQLITE_OMIT_VIRTUALTABLE
81616: sqlite3VtabClear(db, pTable);
81617: #endif
81618: sqlite3DbFree(db, pTable);
81619: }
81620:
81621: /*
81622: ** Unlink the given table from the hash tables and the delete the
81623: ** table structure with all its indices and foreign keys.
81624: */
81625: SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3 *db, int iDb, const char *zTabName){
81626: Table *p;
81627: Db *pDb;
81628:
81629: assert( db!=0 );
81630: assert( iDb>=0 && iDb<db->nDb );
81631: assert( zTabName );
81632: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
81633: testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
81634: pDb = &db->aDb[iDb];
81635: p = sqlite3HashInsert(&pDb->pSchema->tblHash, zTabName,
81636: sqlite3Strlen30(zTabName),0);
81637: sqlite3DeleteTable(db, p);
81638: db->flags |= SQLITE_InternChanges;
81639: }
81640:
81641: /*
81642: ** Given a token, return a string that consists of the text of that
81643: ** token. Space to hold the returned string
81644: ** is obtained from sqliteMalloc() and must be freed by the calling
81645: ** function.
81646: **
81647: ** Any quotation marks (ex: "name", 'name', [name], or `name`) that
81648: ** surround the body of the token are removed.
81649: **
81650: ** Tokens are often just pointers into the original SQL text and so
81651: ** are not \000 terminated and are not persistent. The returned string
81652: ** is \000 terminated and is persistent.
81653: */
81654: SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3 *db, Token *pName){
81655: char *zName;
81656: if( pName ){
81657: zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
81658: sqlite3Dequote(zName);
81659: }else{
81660: zName = 0;
81661: }
81662: return zName;
81663: }
81664:
81665: /*
81666: ** Open the sqlite_master table stored in database number iDb for
81667: ** writing. The table is opened using cursor 0.
81668: */
81669: SQLITE_PRIVATE void sqlite3OpenMasterTable(Parse *p, int iDb){
81670: Vdbe *v = sqlite3GetVdbe(p);
81671: sqlite3TableLock(p, iDb, MASTER_ROOT, 1, SCHEMA_TABLE(iDb));
81672: sqlite3VdbeAddOp3(v, OP_OpenWrite, 0, MASTER_ROOT, iDb);
81673: sqlite3VdbeChangeP4(v, -1, (char *)5, P4_INT32); /* 5 column table */
81674: if( p->nTab==0 ){
81675: p->nTab = 1;
81676: }
81677: }
81678:
81679: /*
81680: ** Parameter zName points to a nul-terminated buffer containing the name
81681: ** of a database ("main", "temp" or the name of an attached db). This
81682: ** function returns the index of the named database in db->aDb[], or
81683: ** -1 if the named db cannot be found.
81684: */
81685: SQLITE_PRIVATE int sqlite3FindDbName(sqlite3 *db, const char *zName){
81686: int i = -1; /* Database number */
81687: if( zName ){
81688: Db *pDb;
81689: int n = sqlite3Strlen30(zName);
81690: for(i=(db->nDb-1), pDb=&db->aDb[i]; i>=0; i--, pDb--){
81691: if( (!OMIT_TEMPDB || i!=1 ) && n==sqlite3Strlen30(pDb->zName) &&
81692: 0==sqlite3StrICmp(pDb->zName, zName) ){
81693: break;
81694: }
81695: }
81696: }
81697: return i;
81698: }
81699:
81700: /*
81701: ** The token *pName contains the name of a database (either "main" or
81702: ** "temp" or the name of an attached db). This routine returns the
81703: ** index of the named database in db->aDb[], or -1 if the named db
81704: ** does not exist.
81705: */
81706: SQLITE_PRIVATE int sqlite3FindDb(sqlite3 *db, Token *pName){
81707: int i; /* Database number */
81708: char *zName; /* Name we are searching for */
81709: zName = sqlite3NameFromToken(db, pName);
81710: i = sqlite3FindDbName(db, zName);
81711: sqlite3DbFree(db, zName);
81712: return i;
81713: }
81714:
81715: /* The table or view or trigger name is passed to this routine via tokens
81716: ** pName1 and pName2. If the table name was fully qualified, for example:
81717: **
81718: ** CREATE TABLE xxx.yyy (...);
81719: **
81720: ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
81721: ** the table name is not fully qualified, i.e.:
81722: **
81723: ** CREATE TABLE yyy(...);
81724: **
81725: ** Then pName1 is set to "yyy" and pName2 is "".
81726: **
81727: ** This routine sets the *ppUnqual pointer to point at the token (pName1 or
81728: ** pName2) that stores the unqualified table name. The index of the
81729: ** database "xxx" is returned.
81730: */
81731: SQLITE_PRIVATE int sqlite3TwoPartName(
81732: Parse *pParse, /* Parsing and code generating context */
81733: Token *pName1, /* The "xxx" in the name "xxx.yyy" or "xxx" */
81734: Token *pName2, /* The "yyy" in the name "xxx.yyy" */
81735: Token **pUnqual /* Write the unqualified object name here */
81736: ){
81737: int iDb; /* Database holding the object */
81738: sqlite3 *db = pParse->db;
81739:
81740: if( ALWAYS(pName2!=0) && pName2->n>0 ){
81741: if( db->init.busy ) {
81742: sqlite3ErrorMsg(pParse, "corrupt database");
81743: pParse->nErr++;
81744: return -1;
81745: }
81746: *pUnqual = pName2;
81747: iDb = sqlite3FindDb(db, pName1);
81748: if( iDb<0 ){
81749: sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
81750: pParse->nErr++;
81751: return -1;
81752: }
81753: }else{
81754: assert( db->init.iDb==0 || db->init.busy );
81755: iDb = db->init.iDb;
81756: *pUnqual = pName1;
81757: }
81758: return iDb;
81759: }
81760:
81761: /*
81762: ** This routine is used to check if the UTF-8 string zName is a legal
81763: ** unqualified name for a new schema object (table, index, view or
81764: ** trigger). All names are legal except those that begin with the string
81765: ** "sqlite_" (in upper, lower or mixed case). This portion of the namespace
81766: ** is reserved for internal use.
81767: */
81768: SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *pParse, const char *zName){
81769: if( !pParse->db->init.busy && pParse->nested==0
81770: && (pParse->db->flags & SQLITE_WriteSchema)==0
81771: && 0==sqlite3StrNICmp(zName, "sqlite_", 7) ){
81772: sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
81773: return SQLITE_ERROR;
81774: }
81775: return SQLITE_OK;
81776: }
81777:
81778: /*
81779: ** Begin constructing a new table representation in memory. This is
81780: ** the first of several action routines that get called in response
81781: ** to a CREATE TABLE statement. In particular, this routine is called
81782: ** after seeing tokens "CREATE" and "TABLE" and the table name. The isTemp
81783: ** flag is true if the table should be stored in the auxiliary database
81784: ** file instead of in the main database file. This is normally the case
81785: ** when the "TEMP" or "TEMPORARY" keyword occurs in between
81786: ** CREATE and TABLE.
81787: **
81788: ** The new table record is initialized and put in pParse->pNewTable.
81789: ** As more of the CREATE TABLE statement is parsed, additional action
81790: ** routines will be called to add more information to this record.
81791: ** At the end of the CREATE TABLE statement, the sqlite3EndTable() routine
81792: ** is called to complete the construction of the new table record.
81793: */
81794: SQLITE_PRIVATE void sqlite3StartTable(
81795: Parse *pParse, /* Parser context */
81796: Token *pName1, /* First part of the name of the table or view */
81797: Token *pName2, /* Second part of the name of the table or view */
81798: int isTemp, /* True if this is a TEMP table */
81799: int isView, /* True if this is a VIEW */
81800: int isVirtual, /* True if this is a VIRTUAL table */
81801: int noErr /* Do nothing if table already exists */
81802: ){
81803: Table *pTable;
81804: char *zName = 0; /* The name of the new table */
81805: sqlite3 *db = pParse->db;
81806: Vdbe *v;
81807: int iDb; /* Database number to create the table in */
81808: Token *pName; /* Unqualified name of the table to create */
81809:
81810: /* The table or view name to create is passed to this routine via tokens
81811: ** pName1 and pName2. If the table name was fully qualified, for example:
81812: **
81813: ** CREATE TABLE xxx.yyy (...);
81814: **
81815: ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
81816: ** the table name is not fully qualified, i.e.:
81817: **
81818: ** CREATE TABLE yyy(...);
81819: **
81820: ** Then pName1 is set to "yyy" and pName2 is "".
81821: **
81822: ** The call below sets the pName pointer to point at the token (pName1 or
81823: ** pName2) that stores the unqualified table name. The variable iDb is
81824: ** set to the index of the database that the table or view is to be
81825: ** created in.
81826: */
81827: iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
81828: if( iDb<0 ) return;
81829: if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
81830: /* If creating a temp table, the name may not be qualified. Unless
81831: ** the database name is "temp" anyway. */
81832: sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
81833: return;
81834: }
81835: if( !OMIT_TEMPDB && isTemp ) iDb = 1;
81836:
81837: pParse->sNameToken = *pName;
81838: zName = sqlite3NameFromToken(db, pName);
81839: if( zName==0 ) return;
81840: if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
81841: goto begin_table_error;
81842: }
81843: if( db->init.iDb==1 ) isTemp = 1;
81844: #ifndef SQLITE_OMIT_AUTHORIZATION
81845: assert( (isTemp & 1)==isTemp );
81846: {
81847: int code;
81848: char *zDb = db->aDb[iDb].zName;
81849: if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
81850: goto begin_table_error;
81851: }
81852: if( isView ){
81853: if( !OMIT_TEMPDB && isTemp ){
81854: code = SQLITE_CREATE_TEMP_VIEW;
81855: }else{
81856: code = SQLITE_CREATE_VIEW;
81857: }
81858: }else{
81859: if( !OMIT_TEMPDB && isTemp ){
81860: code = SQLITE_CREATE_TEMP_TABLE;
81861: }else{
81862: code = SQLITE_CREATE_TABLE;
81863: }
81864: }
81865: if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
81866: goto begin_table_error;
81867: }
81868: }
81869: #endif
81870:
81871: /* Make sure the new table name does not collide with an existing
81872: ** index or table name in the same database. Issue an error message if
81873: ** it does. The exception is if the statement being parsed was passed
81874: ** to an sqlite3_declare_vtab() call. In that case only the column names
81875: ** and types will be used, so there is no need to test for namespace
81876: ** collisions.
81877: */
81878: if( !IN_DECLARE_VTAB ){
81879: char *zDb = db->aDb[iDb].zName;
81880: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
81881: goto begin_table_error;
81882: }
81883: pTable = sqlite3FindTable(db, zName, zDb);
81884: if( pTable ){
81885: if( !noErr ){
81886: sqlite3ErrorMsg(pParse, "table %T already exists", pName);
81887: }else{
81888: assert( !db->init.busy );
81889: sqlite3CodeVerifySchema(pParse, iDb);
81890: }
81891: goto begin_table_error;
81892: }
81893: if( sqlite3FindIndex(db, zName, zDb)!=0 ){
81894: sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
81895: goto begin_table_error;
81896: }
81897: }
81898:
81899: pTable = sqlite3DbMallocZero(db, sizeof(Table));
81900: if( pTable==0 ){
81901: db->mallocFailed = 1;
81902: pParse->rc = SQLITE_NOMEM;
81903: pParse->nErr++;
81904: goto begin_table_error;
81905: }
81906: pTable->zName = zName;
81907: pTable->iPKey = -1;
81908: pTable->pSchema = db->aDb[iDb].pSchema;
81909: pTable->nRef = 1;
81910: pTable->nRowEst = 1000000;
81911: assert( pParse->pNewTable==0 );
81912: pParse->pNewTable = pTable;
81913:
81914: /* If this is the magic sqlite_sequence table used by autoincrement,
81915: ** then record a pointer to this table in the main database structure
81916: ** so that INSERT can find the table easily.
81917: */
81918: #ifndef SQLITE_OMIT_AUTOINCREMENT
81919: if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
81920: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
81921: pTable->pSchema->pSeqTab = pTable;
81922: }
81923: #endif
81924:
81925: /* Begin generating the code that will insert the table record into
81926: ** the SQLITE_MASTER table. Note in particular that we must go ahead
81927: ** and allocate the record number for the table entry now. Before any
81928: ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause
81929: ** indices to be created and the table record must come before the
81930: ** indices. Hence, the record number for the table must be allocated
81931: ** now.
81932: */
81933: if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
81934: int j1;
81935: int fileFormat;
81936: int reg1, reg2, reg3;
81937: sqlite3BeginWriteOperation(pParse, 0, iDb);
81938:
81939: #ifndef SQLITE_OMIT_VIRTUALTABLE
81940: if( isVirtual ){
81941: sqlite3VdbeAddOp0(v, OP_VBegin);
81942: }
81943: #endif
81944:
81945: /* If the file format and encoding in the database have not been set,
81946: ** set them now.
81947: */
81948: reg1 = pParse->regRowid = ++pParse->nMem;
81949: reg2 = pParse->regRoot = ++pParse->nMem;
81950: reg3 = ++pParse->nMem;
81951: sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
81952: sqlite3VdbeUsesBtree(v, iDb);
81953: j1 = sqlite3VdbeAddOp1(v, OP_If, reg3);
81954: fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
81955: 1 : SQLITE_MAX_FILE_FORMAT;
81956: sqlite3VdbeAddOp2(v, OP_Integer, fileFormat, reg3);
81957: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, reg3);
81958: sqlite3VdbeAddOp2(v, OP_Integer, ENC(db), reg3);
81959: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, reg3);
81960: sqlite3VdbeJumpHere(v, j1);
81961:
81962: /* This just creates a place-holder record in the sqlite_master table.
81963: ** The record created does not contain anything yet. It will be replaced
81964: ** by the real entry in code generated at sqlite3EndTable().
81965: **
81966: ** The rowid for the new entry is left in register pParse->regRowid.
81967: ** The root page number of the new table is left in reg pParse->regRoot.
81968: ** The rowid and root page number values are needed by the code that
81969: ** sqlite3EndTable will generate.
81970: */
81971: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
81972: if( isView || isVirtual ){
81973: sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
81974: }else
81975: #endif
81976: {
81977: sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
81978: }
81979: sqlite3OpenMasterTable(pParse, iDb);
81980: sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
81981: sqlite3VdbeAddOp2(v, OP_Null, 0, reg3);
81982: sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
81983: sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
81984: sqlite3VdbeAddOp0(v, OP_Close);
81985: }
81986:
81987: /* Normal (non-error) return. */
81988: return;
81989:
81990: /* If an error occurs, we jump here */
81991: begin_table_error:
81992: sqlite3DbFree(db, zName);
81993: return;
81994: }
81995:
81996: /*
81997: ** This macro is used to compare two strings in a case-insensitive manner.
81998: ** It is slightly faster than calling sqlite3StrICmp() directly, but
81999: ** produces larger code.
82000: **
82001: ** WARNING: This macro is not compatible with the strcmp() family. It
82002: ** returns true if the two strings are equal, otherwise false.
82003: */
82004: #define STRICMP(x, y) (\
82005: sqlite3UpperToLower[*(unsigned char *)(x)]== \
82006: sqlite3UpperToLower[*(unsigned char *)(y)] \
82007: && sqlite3StrICmp((x)+1,(y)+1)==0 )
82008:
82009: /*
82010: ** Add a new column to the table currently being constructed.
82011: **
82012: ** The parser calls this routine once for each column declaration
82013: ** in a CREATE TABLE statement. sqlite3StartTable() gets called
82014: ** first to get things going. Then this routine is called for each
82015: ** column.
82016: */
82017: SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName){
82018: Table *p;
82019: int i;
82020: char *z;
82021: Column *pCol;
82022: sqlite3 *db = pParse->db;
82023: if( (p = pParse->pNewTable)==0 ) return;
82024: #if SQLITE_MAX_COLUMN
82025: if( p->nCol+1>db->aLimit[SQLITE_LIMIT_COLUMN] ){
82026: sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
82027: return;
82028: }
82029: #endif
82030: z = sqlite3NameFromToken(db, pName);
82031: if( z==0 ) return;
82032: for(i=0; i<p->nCol; i++){
82033: if( STRICMP(z, p->aCol[i].zName) ){
82034: sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
82035: sqlite3DbFree(db, z);
82036: return;
82037: }
82038: }
82039: if( (p->nCol & 0x7)==0 ){
82040: Column *aNew;
82041: aNew = sqlite3DbRealloc(db,p->aCol,(p->nCol+8)*sizeof(p->aCol[0]));
82042: if( aNew==0 ){
82043: sqlite3DbFree(db, z);
82044: return;
82045: }
82046: p->aCol = aNew;
82047: }
82048: pCol = &p->aCol[p->nCol];
82049: memset(pCol, 0, sizeof(p->aCol[0]));
82050: pCol->zName = z;
82051:
82052: /* If there is no type specified, columns have the default affinity
82053: ** 'NONE'. If there is a type specified, then sqlite3AddColumnType() will
82054: ** be called next to set pCol->affinity correctly.
82055: */
82056: pCol->affinity = SQLITE_AFF_NONE;
82057: p->nCol++;
82058: }
82059:
82060: /*
82061: ** This routine is called by the parser while in the middle of
82062: ** parsing a CREATE TABLE statement. A "NOT NULL" constraint has
82063: ** been seen on a column. This routine sets the notNull flag on
82064: ** the column currently under construction.
82065: */
82066: SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
82067: Table *p;
82068: p = pParse->pNewTable;
82069: if( p==0 || NEVER(p->nCol<1) ) return;
82070: p->aCol[p->nCol-1].notNull = (u8)onError;
82071: }
82072:
82073: /*
82074: ** Scan the column type name zType (length nType) and return the
82075: ** associated affinity type.
82076: **
82077: ** This routine does a case-independent search of zType for the
82078: ** substrings in the following table. If one of the substrings is
82079: ** found, the corresponding affinity is returned. If zType contains
82080: ** more than one of the substrings, entries toward the top of
82081: ** the table take priority. For example, if zType is 'BLOBINT',
82082: ** SQLITE_AFF_INTEGER is returned.
82083: **
82084: ** Substring | Affinity
82085: ** --------------------------------
82086: ** 'INT' | SQLITE_AFF_INTEGER
82087: ** 'CHAR' | SQLITE_AFF_TEXT
82088: ** 'CLOB' | SQLITE_AFF_TEXT
82089: ** 'TEXT' | SQLITE_AFF_TEXT
82090: ** 'BLOB' | SQLITE_AFF_NONE
82091: ** 'REAL' | SQLITE_AFF_REAL
82092: ** 'FLOA' | SQLITE_AFF_REAL
82093: ** 'DOUB' | SQLITE_AFF_REAL
82094: **
82095: ** If none of the substrings in the above table are found,
82096: ** SQLITE_AFF_NUMERIC is returned.
82097: */
82098: SQLITE_PRIVATE char sqlite3AffinityType(const char *zIn){
82099: u32 h = 0;
82100: char aff = SQLITE_AFF_NUMERIC;
82101:
82102: if( zIn ) while( zIn[0] ){
82103: h = (h<<8) + sqlite3UpperToLower[(*zIn)&0xff];
82104: zIn++;
82105: if( h==(('c'<<24)+('h'<<16)+('a'<<8)+'r') ){ /* CHAR */
82106: aff = SQLITE_AFF_TEXT;
82107: }else if( h==(('c'<<24)+('l'<<16)+('o'<<8)+'b') ){ /* CLOB */
82108: aff = SQLITE_AFF_TEXT;
82109: }else if( h==(('t'<<24)+('e'<<16)+('x'<<8)+'t') ){ /* TEXT */
82110: aff = SQLITE_AFF_TEXT;
82111: }else if( h==(('b'<<24)+('l'<<16)+('o'<<8)+'b') /* BLOB */
82112: && (aff==SQLITE_AFF_NUMERIC || aff==SQLITE_AFF_REAL) ){
82113: aff = SQLITE_AFF_NONE;
82114: #ifndef SQLITE_OMIT_FLOATING_POINT
82115: }else if( h==(('r'<<24)+('e'<<16)+('a'<<8)+'l') /* REAL */
82116: && aff==SQLITE_AFF_NUMERIC ){
82117: aff = SQLITE_AFF_REAL;
82118: }else if( h==(('f'<<24)+('l'<<16)+('o'<<8)+'a') /* FLOA */
82119: && aff==SQLITE_AFF_NUMERIC ){
82120: aff = SQLITE_AFF_REAL;
82121: }else if( h==(('d'<<24)+('o'<<16)+('u'<<8)+'b') /* DOUB */
82122: && aff==SQLITE_AFF_NUMERIC ){
82123: aff = SQLITE_AFF_REAL;
82124: #endif
82125: }else if( (h&0x00FFFFFF)==(('i'<<16)+('n'<<8)+'t') ){ /* INT */
82126: aff = SQLITE_AFF_INTEGER;
82127: break;
82128: }
82129: }
82130:
82131: return aff;
82132: }
82133:
82134: /*
82135: ** This routine is called by the parser while in the middle of
82136: ** parsing a CREATE TABLE statement. The pFirst token is the first
82137: ** token in the sequence of tokens that describe the type of the
82138: ** column currently under construction. pLast is the last token
82139: ** in the sequence. Use this information to construct a string
82140: ** that contains the typename of the column and store that string
82141: ** in zType.
82142: */
82143: SQLITE_PRIVATE void sqlite3AddColumnType(Parse *pParse, Token *pType){
82144: Table *p;
82145: Column *pCol;
82146:
82147: p = pParse->pNewTable;
82148: if( p==0 || NEVER(p->nCol<1) ) return;
82149: pCol = &p->aCol[p->nCol-1];
82150: assert( pCol->zType==0 );
82151: pCol->zType = sqlite3NameFromToken(pParse->db, pType);
82152: pCol->affinity = sqlite3AffinityType(pCol->zType);
82153: }
82154:
82155: /*
82156: ** The expression is the default value for the most recently added column
82157: ** of the table currently under construction.
82158: **
82159: ** Default value expressions must be constant. Raise an exception if this
82160: ** is not the case.
82161: **
82162: ** This routine is called by the parser while in the middle of
82163: ** parsing a CREATE TABLE statement.
82164: */
82165: SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
82166: Table *p;
82167: Column *pCol;
82168: sqlite3 *db = pParse->db;
82169: p = pParse->pNewTable;
82170: if( p!=0 ){
82171: pCol = &(p->aCol[p->nCol-1]);
82172: if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr) ){
82173: sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
82174: pCol->zName);
82175: }else{
82176: /* A copy of pExpr is used instead of the original, as pExpr contains
82177: ** tokens that point to volatile memory. The 'span' of the expression
82178: ** is required by pragma table_info.
82179: */
82180: sqlite3ExprDelete(db, pCol->pDflt);
82181: pCol->pDflt = sqlite3ExprDup(db, pSpan->pExpr, EXPRDUP_REDUCE);
82182: sqlite3DbFree(db, pCol->zDflt);
82183: pCol->zDflt = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
82184: (int)(pSpan->zEnd - pSpan->zStart));
82185: }
82186: }
82187: sqlite3ExprDelete(db, pSpan->pExpr);
82188: }
82189:
82190: /*
82191: ** Designate the PRIMARY KEY for the table. pList is a list of names
82192: ** of columns that form the primary key. If pList is NULL, then the
82193: ** most recently added column of the table is the primary key.
82194: **
82195: ** A table can have at most one primary key. If the table already has
82196: ** a primary key (and this is the second primary key) then create an
82197: ** error.
82198: **
82199: ** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
82200: ** then we will try to use that column as the rowid. Set the Table.iPKey
82201: ** field of the table under construction to be the index of the
82202: ** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is
82203: ** no INTEGER PRIMARY KEY.
82204: **
82205: ** If the key is not an INTEGER PRIMARY KEY, then create a unique
82206: ** index for the key. No index is created for INTEGER PRIMARY KEYs.
82207: */
82208: SQLITE_PRIVATE void sqlite3AddPrimaryKey(
82209: Parse *pParse, /* Parsing context */
82210: ExprList *pList, /* List of field names to be indexed */
82211: int onError, /* What to do with a uniqueness conflict */
82212: int autoInc, /* True if the AUTOINCREMENT keyword is present */
82213: int sortOrder /* SQLITE_SO_ASC or SQLITE_SO_DESC */
82214: ){
82215: Table *pTab = pParse->pNewTable;
82216: char *zType = 0;
82217: int iCol = -1, i;
82218: if( pTab==0 || IN_DECLARE_VTAB ) goto primary_key_exit;
82219: if( pTab->tabFlags & TF_HasPrimaryKey ){
82220: sqlite3ErrorMsg(pParse,
82221: "table \"%s\" has more than one primary key", pTab->zName);
82222: goto primary_key_exit;
82223: }
82224: pTab->tabFlags |= TF_HasPrimaryKey;
82225: if( pList==0 ){
82226: iCol = pTab->nCol - 1;
82227: pTab->aCol[iCol].isPrimKey = 1;
82228: }else{
82229: for(i=0; i<pList->nExpr; i++){
82230: for(iCol=0; iCol<pTab->nCol; iCol++){
82231: if( sqlite3StrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ){
82232: break;
82233: }
82234: }
82235: if( iCol<pTab->nCol ){
82236: pTab->aCol[iCol].isPrimKey = 1;
82237: }
82238: }
82239: if( pList->nExpr>1 ) iCol = -1;
82240: }
82241: if( iCol>=0 && iCol<pTab->nCol ){
82242: zType = pTab->aCol[iCol].zType;
82243: }
82244: if( zType && sqlite3StrICmp(zType, "INTEGER")==0
82245: && sortOrder==SQLITE_SO_ASC ){
82246: pTab->iPKey = iCol;
82247: pTab->keyConf = (u8)onError;
82248: assert( autoInc==0 || autoInc==1 );
82249: pTab->tabFlags |= autoInc*TF_Autoincrement;
82250: }else if( autoInc ){
82251: #ifndef SQLITE_OMIT_AUTOINCREMENT
82252: sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
82253: "INTEGER PRIMARY KEY");
82254: #endif
82255: }else{
82256: Index *p;
82257: p = sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, 0, sortOrder, 0);
82258: if( p ){
82259: p->autoIndex = 2;
82260: }
82261: pList = 0;
82262: }
82263:
82264: primary_key_exit:
82265: sqlite3ExprListDelete(pParse->db, pList);
82266: return;
82267: }
82268:
82269: /*
82270: ** Add a new CHECK constraint to the table currently under construction.
82271: */
82272: SQLITE_PRIVATE void sqlite3AddCheckConstraint(
82273: Parse *pParse, /* Parsing context */
82274: Expr *pCheckExpr /* The check expression */
82275: ){
82276: sqlite3 *db = pParse->db;
82277: #ifndef SQLITE_OMIT_CHECK
82278: Table *pTab = pParse->pNewTable;
82279: if( pTab && !IN_DECLARE_VTAB ){
82280: pTab->pCheck = sqlite3ExprAnd(db, pTab->pCheck, pCheckExpr);
82281: }else
82282: #endif
82283: {
82284: sqlite3ExprDelete(db, pCheckExpr);
82285: }
82286: }
82287:
82288: /*
82289: ** Set the collation function of the most recently parsed table column
82290: ** to the CollSeq given.
82291: */
82292: SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){
82293: Table *p;
82294: int i;
82295: char *zColl; /* Dequoted name of collation sequence */
82296: sqlite3 *db;
82297:
82298: if( (p = pParse->pNewTable)==0 ) return;
82299: i = p->nCol-1;
82300: db = pParse->db;
82301: zColl = sqlite3NameFromToken(db, pToken);
82302: if( !zColl ) return;
82303:
82304: if( sqlite3LocateCollSeq(pParse, zColl) ){
82305: Index *pIdx;
82306: p->aCol[i].zColl = zColl;
82307:
82308: /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>",
82309: ** then an index may have been created on this column before the
82310: ** collation type was added. Correct this if it is the case.
82311: */
82312: for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
82313: assert( pIdx->nColumn==1 );
82314: if( pIdx->aiColumn[0]==i ){
82315: pIdx->azColl[0] = p->aCol[i].zColl;
82316: }
82317: }
82318: }else{
82319: sqlite3DbFree(db, zColl);
82320: }
82321: }
82322:
82323: /*
82324: ** This function returns the collation sequence for database native text
82325: ** encoding identified by the string zName, length nName.
82326: **
82327: ** If the requested collation sequence is not available, or not available
82328: ** in the database native encoding, the collation factory is invoked to
82329: ** request it. If the collation factory does not supply such a sequence,
82330: ** and the sequence is available in another text encoding, then that is
82331: ** returned instead.
82332: **
82333: ** If no versions of the requested collations sequence are available, or
82334: ** another error occurs, NULL is returned and an error message written into
82335: ** pParse.
82336: **
82337: ** This routine is a wrapper around sqlite3FindCollSeq(). This routine
82338: ** invokes the collation factory if the named collation cannot be found
82339: ** and generates an error message.
82340: **
82341: ** See also: sqlite3FindCollSeq(), sqlite3GetCollSeq()
82342: */
82343: SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
82344: sqlite3 *db = pParse->db;
82345: u8 enc = ENC(db);
82346: u8 initbusy = db->init.busy;
82347: CollSeq *pColl;
82348:
82349: pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
82350: if( !initbusy && (!pColl || !pColl->xCmp) ){
82351: pColl = sqlite3GetCollSeq(db, enc, pColl, zName);
82352: if( !pColl ){
82353: sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
82354: }
82355: }
82356:
82357: return pColl;
82358: }
82359:
82360:
82361: /*
82362: ** Generate code that will increment the schema cookie.
82363: **
82364: ** The schema cookie is used to determine when the schema for the
82365: ** database changes. After each schema change, the cookie value
82366: ** changes. When a process first reads the schema it records the
82367: ** cookie. Thereafter, whenever it goes to access the database,
82368: ** it checks the cookie to make sure the schema has not changed
82369: ** since it was last read.
82370: **
82371: ** This plan is not completely bullet-proof. It is possible for
82372: ** the schema to change multiple times and for the cookie to be
82373: ** set back to prior value. But schema changes are infrequent
82374: ** and the probability of hitting the same cookie value is only
82375: ** 1 chance in 2^32. So we're safe enough.
82376: */
82377: SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
82378: int r1 = sqlite3GetTempReg(pParse);
82379: sqlite3 *db = pParse->db;
82380: Vdbe *v = pParse->pVdbe;
82381: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
82382: sqlite3VdbeAddOp2(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, r1);
82383: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION, r1);
82384: sqlite3ReleaseTempReg(pParse, r1);
82385: }
82386:
82387: /*
82388: ** Measure the number of characters needed to output the given
82389: ** identifier. The number returned includes any quotes used
82390: ** but does not include the null terminator.
82391: **
82392: ** The estimate is conservative. It might be larger that what is
82393: ** really needed.
82394: */
82395: static int identLength(const char *z){
82396: int n;
82397: for(n=0; *z; n++, z++){
82398: if( *z=='"' ){ n++; }
82399: }
82400: return n + 2;
82401: }
82402:
82403: /*
82404: ** The first parameter is a pointer to an output buffer. The second
82405: ** parameter is a pointer to an integer that contains the offset at
82406: ** which to write into the output buffer. This function copies the
82407: ** nul-terminated string pointed to by the third parameter, zSignedIdent,
82408: ** to the specified offset in the buffer and updates *pIdx to refer
82409: ** to the first byte after the last byte written before returning.
82410: **
82411: ** If the string zSignedIdent consists entirely of alpha-numeric
82412: ** characters, does not begin with a digit and is not an SQL keyword,
82413: ** then it is copied to the output buffer exactly as it is. Otherwise,
82414: ** it is quoted using double-quotes.
82415: */
82416: static void identPut(char *z, int *pIdx, char *zSignedIdent){
82417: unsigned char *zIdent = (unsigned char*)zSignedIdent;
82418: int i, j, needQuote;
82419: i = *pIdx;
82420:
82421: for(j=0; zIdent[j]; j++){
82422: if( !sqlite3Isalnum(zIdent[j]) && zIdent[j]!='_' ) break;
82423: }
82424: needQuote = sqlite3Isdigit(zIdent[0]) || sqlite3KeywordCode(zIdent, j)!=TK_ID;
82425: if( !needQuote ){
82426: needQuote = zIdent[j];
82427: }
82428:
82429: if( needQuote ) z[i++] = '"';
82430: for(j=0; zIdent[j]; j++){
82431: z[i++] = zIdent[j];
82432: if( zIdent[j]=='"' ) z[i++] = '"';
82433: }
82434: if( needQuote ) z[i++] = '"';
82435: z[i] = 0;
82436: *pIdx = i;
82437: }
82438:
82439: /*
82440: ** Generate a CREATE TABLE statement appropriate for the given
82441: ** table. Memory to hold the text of the statement is obtained
82442: ** from sqliteMalloc() and must be freed by the calling function.
82443: */
82444: static char *createTableStmt(sqlite3 *db, Table *p){
82445: int i, k, n;
82446: char *zStmt;
82447: char *zSep, *zSep2, *zEnd;
82448: Column *pCol;
82449: n = 0;
82450: for(pCol = p->aCol, i=0; i<p->nCol; i++, pCol++){
82451: n += identLength(pCol->zName) + 5;
82452: }
82453: n += identLength(p->zName);
82454: if( n<50 ){
82455: zSep = "";
82456: zSep2 = ",";
82457: zEnd = ")";
82458: }else{
82459: zSep = "\n ";
82460: zSep2 = ",\n ";
82461: zEnd = "\n)";
82462: }
82463: n += 35 + 6*p->nCol;
82464: zStmt = sqlite3DbMallocRaw(0, n);
82465: if( zStmt==0 ){
82466: db->mallocFailed = 1;
82467: return 0;
82468: }
82469: sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
82470: k = sqlite3Strlen30(zStmt);
82471: identPut(zStmt, &k, p->zName);
82472: zStmt[k++] = '(';
82473: for(pCol=p->aCol, i=0; i<p->nCol; i++, pCol++){
82474: static const char * const azType[] = {
82475: /* SQLITE_AFF_TEXT */ " TEXT",
82476: /* SQLITE_AFF_NONE */ "",
82477: /* SQLITE_AFF_NUMERIC */ " NUM",
82478: /* SQLITE_AFF_INTEGER */ " INT",
82479: /* SQLITE_AFF_REAL */ " REAL"
82480: };
82481: int len;
82482: const char *zType;
82483:
82484: sqlite3_snprintf(n-k, &zStmt[k], zSep);
82485: k += sqlite3Strlen30(&zStmt[k]);
82486: zSep = zSep2;
82487: identPut(zStmt, &k, pCol->zName);
82488: assert( pCol->affinity-SQLITE_AFF_TEXT >= 0 );
82489: assert( pCol->affinity-SQLITE_AFF_TEXT < ArraySize(azType) );
82490: testcase( pCol->affinity==SQLITE_AFF_TEXT );
82491: testcase( pCol->affinity==SQLITE_AFF_NONE );
82492: testcase( pCol->affinity==SQLITE_AFF_NUMERIC );
82493: testcase( pCol->affinity==SQLITE_AFF_INTEGER );
82494: testcase( pCol->affinity==SQLITE_AFF_REAL );
82495:
82496: zType = azType[pCol->affinity - SQLITE_AFF_TEXT];
82497: len = sqlite3Strlen30(zType);
82498: assert( pCol->affinity==SQLITE_AFF_NONE
82499: || pCol->affinity==sqlite3AffinityType(zType) );
82500: memcpy(&zStmt[k], zType, len);
82501: k += len;
82502: assert( k<=n );
82503: }
82504: sqlite3_snprintf(n-k, &zStmt[k], "%s", zEnd);
82505: return zStmt;
82506: }
82507:
82508: /*
82509: ** This routine is called to report the final ")" that terminates
82510: ** a CREATE TABLE statement.
82511: **
82512: ** The table structure that other action routines have been building
82513: ** is added to the internal hash tables, assuming no errors have
82514: ** occurred.
82515: **
82516: ** An entry for the table is made in the master table on disk, unless
82517: ** this is a temporary table or db->init.busy==1. When db->init.busy==1
82518: ** it means we are reading the sqlite_master table because we just
82519: ** connected to the database or because the sqlite_master table has
82520: ** recently changed, so the entry for this table already exists in
82521: ** the sqlite_master table. We do not want to create it again.
82522: **
82523: ** If the pSelect argument is not NULL, it means that this routine
82524: ** was called to create a table generated from a
82525: ** "CREATE TABLE ... AS SELECT ..." statement. The column names of
82526: ** the new table will match the result set of the SELECT.
82527: */
82528: SQLITE_PRIVATE void sqlite3EndTable(
82529: Parse *pParse, /* Parse context */
82530: Token *pCons, /* The ',' token after the last column defn. */
82531: Token *pEnd, /* The final ')' token in the CREATE TABLE */
82532: Select *pSelect /* Select from a "CREATE ... AS SELECT" */
82533: ){
82534: Table *p;
82535: sqlite3 *db = pParse->db;
82536: int iDb;
82537:
82538: if( (pEnd==0 && pSelect==0) || db->mallocFailed ){
82539: return;
82540: }
82541: p = pParse->pNewTable;
82542: if( p==0 ) return;
82543:
82544: assert( !db->init.busy || !pSelect );
82545:
82546: iDb = sqlite3SchemaToIndex(db, p->pSchema);
82547:
82548: #ifndef SQLITE_OMIT_CHECK
82549: /* Resolve names in all CHECK constraint expressions.
82550: */
82551: if( p->pCheck ){
82552: SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
82553: NameContext sNC; /* Name context for pParse->pNewTable */
82554:
82555: memset(&sNC, 0, sizeof(sNC));
82556: memset(&sSrc, 0, sizeof(sSrc));
82557: sSrc.nSrc = 1;
82558: sSrc.a[0].zName = p->zName;
82559: sSrc.a[0].pTab = p;
82560: sSrc.a[0].iCursor = -1;
82561: sNC.pParse = pParse;
82562: sNC.pSrcList = &sSrc;
82563: sNC.isCheck = 1;
82564: if( sqlite3ResolveExprNames(&sNC, p->pCheck) ){
82565: return;
82566: }
82567: }
82568: #endif /* !defined(SQLITE_OMIT_CHECK) */
82569:
82570: /* If the db->init.busy is 1 it means we are reading the SQL off the
82571: ** "sqlite_master" or "sqlite_temp_master" table on the disk.
82572: ** So do not write to the disk again. Extract the root page number
82573: ** for the table from the db->init.newTnum field. (The page number
82574: ** should have been put there by the sqliteOpenCb routine.)
82575: */
82576: if( db->init.busy ){
82577: p->tnum = db->init.newTnum;
82578: }
82579:
82580: /* If not initializing, then create a record for the new table
82581: ** in the SQLITE_MASTER table of the database.
82582: **
82583: ** If this is a TEMPORARY table, write the entry into the auxiliary
82584: ** file instead of into the main database file.
82585: */
82586: if( !db->init.busy ){
82587: int n;
82588: Vdbe *v;
82589: char *zType; /* "view" or "table" */
82590: char *zType2; /* "VIEW" or "TABLE" */
82591: char *zStmt; /* Text of the CREATE TABLE or CREATE VIEW statement */
82592:
82593: v = sqlite3GetVdbe(pParse);
82594: if( NEVER(v==0) ) return;
82595:
82596: sqlite3VdbeAddOp1(v, OP_Close, 0);
82597:
82598: /*
82599: ** Initialize zType for the new view or table.
82600: */
82601: if( p->pSelect==0 ){
82602: /* A regular table */
82603: zType = "table";
82604: zType2 = "TABLE";
82605: #ifndef SQLITE_OMIT_VIEW
82606: }else{
82607: /* A view */
82608: zType = "view";
82609: zType2 = "VIEW";
82610: #endif
82611: }
82612:
82613: /* If this is a CREATE TABLE xx AS SELECT ..., execute the SELECT
82614: ** statement to populate the new table. The root-page number for the
82615: ** new table is in register pParse->regRoot.
82616: **
82617: ** Once the SELECT has been coded by sqlite3Select(), it is in a
82618: ** suitable state to query for the column names and types to be used
82619: ** by the new table.
82620: **
82621: ** A shared-cache write-lock is not required to write to the new table,
82622: ** as a schema-lock must have already been obtained to create it. Since
82623: ** a schema-lock excludes all other database users, the write-lock would
82624: ** be redundant.
82625: */
82626: if( pSelect ){
82627: SelectDest dest;
82628: Table *pSelTab;
82629:
82630: assert(pParse->nTab==1);
82631: sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
82632: sqlite3VdbeChangeP5(v, 1);
82633: pParse->nTab = 2;
82634: sqlite3SelectDestInit(&dest, SRT_Table, 1);
82635: sqlite3Select(pParse, pSelect, &dest);
82636: sqlite3VdbeAddOp1(v, OP_Close, 1);
82637: if( pParse->nErr==0 ){
82638: pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect);
82639: if( pSelTab==0 ) return;
82640: assert( p->aCol==0 );
82641: p->nCol = pSelTab->nCol;
82642: p->aCol = pSelTab->aCol;
82643: pSelTab->nCol = 0;
82644: pSelTab->aCol = 0;
82645: sqlite3DeleteTable(db, pSelTab);
82646: }
82647: }
82648:
82649: /* Compute the complete text of the CREATE statement */
82650: if( pSelect ){
82651: zStmt = createTableStmt(db, p);
82652: }else{
82653: n = (int)(pEnd->z - pParse->sNameToken.z) + 1;
82654: zStmt = sqlite3MPrintf(db,
82655: "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
82656: );
82657: }
82658:
82659: /* A slot for the record has already been allocated in the
82660: ** SQLITE_MASTER table. We just need to update that slot with all
82661: ** the information we've collected.
82662: */
82663: sqlite3NestedParse(pParse,
82664: "UPDATE %Q.%s "
82665: "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
82666: "WHERE rowid=#%d",
82667: db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
82668: zType,
82669: p->zName,
82670: p->zName,
82671: pParse->regRoot,
82672: zStmt,
82673: pParse->regRowid
82674: );
82675: sqlite3DbFree(db, zStmt);
82676: sqlite3ChangeCookie(pParse, iDb);
82677:
82678: #ifndef SQLITE_OMIT_AUTOINCREMENT
82679: /* Check to see if we need to create an sqlite_sequence table for
82680: ** keeping track of autoincrement keys.
82681: */
82682: if( p->tabFlags & TF_Autoincrement ){
82683: Db *pDb = &db->aDb[iDb];
82684: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
82685: if( pDb->pSchema->pSeqTab==0 ){
82686: sqlite3NestedParse(pParse,
82687: "CREATE TABLE %Q.sqlite_sequence(name,seq)",
82688: pDb->zName
82689: );
82690: }
82691: }
82692: #endif
82693:
82694: /* Reparse everything to update our internal data structures */
82695: sqlite3VdbeAddParseSchemaOp(v, iDb,
82696: sqlite3MPrintf(db, "tbl_name='%q'", p->zName));
82697: }
82698:
82699:
82700: /* Add the table to the in-memory representation of the database.
82701: */
82702: if( db->init.busy ){
82703: Table *pOld;
82704: Schema *pSchema = p->pSchema;
82705: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
82706: pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName,
82707: sqlite3Strlen30(p->zName),p);
82708: if( pOld ){
82709: assert( p==pOld ); /* Malloc must have failed inside HashInsert() */
82710: db->mallocFailed = 1;
82711: return;
82712: }
82713: pParse->pNewTable = 0;
82714: db->nTable++;
82715: db->flags |= SQLITE_InternChanges;
82716:
82717: #ifndef SQLITE_OMIT_ALTERTABLE
82718: if( !p->pSelect ){
82719: const char *zName = (const char *)pParse->sNameToken.z;
82720: int nName;
82721: assert( !pSelect && pCons && pEnd );
82722: if( pCons->z==0 ){
82723: pCons = pEnd;
82724: }
82725: nName = (int)((const char *)pCons->z - zName);
82726: p->addColOffset = 13 + sqlite3Utf8CharLen(zName, nName);
82727: }
82728: #endif
82729: }
82730: }
82731:
82732: #ifndef SQLITE_OMIT_VIEW
82733: /*
82734: ** The parser calls this routine in order to create a new VIEW
82735: */
82736: SQLITE_PRIVATE void sqlite3CreateView(
82737: Parse *pParse, /* The parsing context */
82738: Token *pBegin, /* The CREATE token that begins the statement */
82739: Token *pName1, /* The token that holds the name of the view */
82740: Token *pName2, /* The token that holds the name of the view */
82741: Select *pSelect, /* A SELECT statement that will become the new view */
82742: int isTemp, /* TRUE for a TEMPORARY view */
82743: int noErr /* Suppress error messages if VIEW already exists */
82744: ){
82745: Table *p;
82746: int n;
82747: const char *z;
82748: Token sEnd;
82749: DbFixer sFix;
82750: Token *pName = 0;
82751: int iDb;
82752: sqlite3 *db = pParse->db;
82753:
82754: if( pParse->nVar>0 ){
82755: sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
82756: sqlite3SelectDelete(db, pSelect);
82757: return;
82758: }
82759: sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
82760: p = pParse->pNewTable;
82761: if( p==0 || pParse->nErr ){
82762: sqlite3SelectDelete(db, pSelect);
82763: return;
82764: }
82765: sqlite3TwoPartName(pParse, pName1, pName2, &pName);
82766: iDb = sqlite3SchemaToIndex(db, p->pSchema);
82767: if( sqlite3FixInit(&sFix, pParse, iDb, "view", pName)
82768: && sqlite3FixSelect(&sFix, pSelect)
82769: ){
82770: sqlite3SelectDelete(db, pSelect);
82771: return;
82772: }
82773:
82774: /* Make a copy of the entire SELECT statement that defines the view.
82775: ** This will force all the Expr.token.z values to be dynamically
82776: ** allocated rather than point to the input string - which means that
82777: ** they will persist after the current sqlite3_exec() call returns.
82778: */
82779: p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
82780: sqlite3SelectDelete(db, pSelect);
82781: if( db->mallocFailed ){
82782: return;
82783: }
82784: if( !db->init.busy ){
82785: sqlite3ViewGetColumnNames(pParse, p);
82786: }
82787:
82788: /* Locate the end of the CREATE VIEW statement. Make sEnd point to
82789: ** the end.
82790: */
82791: sEnd = pParse->sLastToken;
82792: if( ALWAYS(sEnd.z[0]!=0) && sEnd.z[0]!=';' ){
82793: sEnd.z += sEnd.n;
82794: }
82795: sEnd.n = 0;
82796: n = (int)(sEnd.z - pBegin->z);
82797: z = pBegin->z;
82798: while( ALWAYS(n>0) && sqlite3Isspace(z[n-1]) ){ n--; }
82799: sEnd.z = &z[n-1];
82800: sEnd.n = 1;
82801:
82802: /* Use sqlite3EndTable() to add the view to the SQLITE_MASTER table */
82803: sqlite3EndTable(pParse, 0, &sEnd, 0);
82804: return;
82805: }
82806: #endif /* SQLITE_OMIT_VIEW */
82807:
82808: #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
82809: /*
82810: ** The Table structure pTable is really a VIEW. Fill in the names of
82811: ** the columns of the view in the pTable structure. Return the number
82812: ** of errors. If an error is seen leave an error message in pParse->zErrMsg.
82813: */
82814: SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
82815: Table *pSelTab; /* A fake table from which we get the result set */
82816: Select *pSel; /* Copy of the SELECT that implements the view */
82817: int nErr = 0; /* Number of errors encountered */
82818: int n; /* Temporarily holds the number of cursors assigned */
82819: sqlite3 *db = pParse->db; /* Database connection for malloc errors */
82820: int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
82821:
82822: assert( pTable );
82823:
82824: #ifndef SQLITE_OMIT_VIRTUALTABLE
82825: if( sqlite3VtabCallConnect(pParse, pTable) ){
82826: return SQLITE_ERROR;
82827: }
82828: if( IsVirtual(pTable) ) return 0;
82829: #endif
82830:
82831: #ifndef SQLITE_OMIT_VIEW
82832: /* A positive nCol means the columns names for this view are
82833: ** already known.
82834: */
82835: if( pTable->nCol>0 ) return 0;
82836:
82837: /* A negative nCol is a special marker meaning that we are currently
82838: ** trying to compute the column names. If we enter this routine with
82839: ** a negative nCol, it means two or more views form a loop, like this:
82840: **
82841: ** CREATE VIEW one AS SELECT * FROM two;
82842: ** CREATE VIEW two AS SELECT * FROM one;
82843: **
82844: ** Actually, the error above is now caught prior to reaching this point.
82845: ** But the following test is still important as it does come up
82846: ** in the following:
82847: **
82848: ** CREATE TABLE main.ex1(a);
82849: ** CREATE TEMP VIEW ex1 AS SELECT a FROM ex1;
82850: ** SELECT * FROM temp.ex1;
82851: */
82852: if( pTable->nCol<0 ){
82853: sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
82854: return 1;
82855: }
82856: assert( pTable->nCol>=0 );
82857:
82858: /* If we get this far, it means we need to compute the table names.
82859: ** Note that the call to sqlite3ResultSetOfSelect() will expand any
82860: ** "*" elements in the results set of the view and will assign cursors
82861: ** to the elements of the FROM clause. But we do not want these changes
82862: ** to be permanent. So the computation is done on a copy of the SELECT
82863: ** statement that defines the view.
82864: */
82865: assert( pTable->pSelect );
82866: pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
82867: if( pSel ){
82868: u8 enableLookaside = db->lookaside.bEnabled;
82869: n = pParse->nTab;
82870: sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
82871: pTable->nCol = -1;
82872: db->lookaside.bEnabled = 0;
82873: #ifndef SQLITE_OMIT_AUTHORIZATION
82874: xAuth = db->xAuth;
82875: db->xAuth = 0;
82876: pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
82877: db->xAuth = xAuth;
82878: #else
82879: pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
82880: #endif
82881: db->lookaside.bEnabled = enableLookaside;
82882: pParse->nTab = n;
82883: if( pSelTab ){
82884: assert( pTable->aCol==0 );
82885: pTable->nCol = pSelTab->nCol;
82886: pTable->aCol = pSelTab->aCol;
82887: pSelTab->nCol = 0;
82888: pSelTab->aCol = 0;
82889: sqlite3DeleteTable(db, pSelTab);
82890: assert( sqlite3SchemaMutexHeld(db, 0, pTable->pSchema) );
82891: pTable->pSchema->flags |= DB_UnresetViews;
82892: }else{
82893: pTable->nCol = 0;
82894: nErr++;
82895: }
82896: sqlite3SelectDelete(db, pSel);
82897: } else {
82898: nErr++;
82899: }
82900: #endif /* SQLITE_OMIT_VIEW */
82901: return nErr;
82902: }
82903: #endif /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
82904:
82905: #ifndef SQLITE_OMIT_VIEW
82906: /*
82907: ** Clear the column names from every VIEW in database idx.
82908: */
82909: static void sqliteViewResetAll(sqlite3 *db, int idx){
82910: HashElem *i;
82911: assert( sqlite3SchemaMutexHeld(db, idx, 0) );
82912: if( !DbHasProperty(db, idx, DB_UnresetViews) ) return;
82913: for(i=sqliteHashFirst(&db->aDb[idx].pSchema->tblHash); i;i=sqliteHashNext(i)){
82914: Table *pTab = sqliteHashData(i);
82915: if( pTab->pSelect ){
82916: sqliteDeleteColumnNames(db, pTab);
82917: pTab->aCol = 0;
82918: pTab->nCol = 0;
82919: }
82920: }
82921: DbClearProperty(db, idx, DB_UnresetViews);
82922: }
82923: #else
82924: # define sqliteViewResetAll(A,B)
82925: #endif /* SQLITE_OMIT_VIEW */
82926:
82927: /*
82928: ** This function is called by the VDBE to adjust the internal schema
82929: ** used by SQLite when the btree layer moves a table root page. The
82930: ** root-page of a table or index in database iDb has changed from iFrom
82931: ** to iTo.
82932: **
82933: ** Ticket #1728: The symbol table might still contain information
82934: ** on tables and/or indices that are the process of being deleted.
82935: ** If you are unlucky, one of those deleted indices or tables might
82936: ** have the same rootpage number as the real table or index that is
82937: ** being moved. So we cannot stop searching after the first match
82938: ** because the first match might be for one of the deleted indices
82939: ** or tables and not the table/index that is actually being moved.
82940: ** We must continue looping until all tables and indices with
82941: ** rootpage==iFrom have been converted to have a rootpage of iTo
82942: ** in order to be certain that we got the right one.
82943: */
82944: #ifndef SQLITE_OMIT_AUTOVACUUM
82945: SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iTo){
82946: HashElem *pElem;
82947: Hash *pHash;
82948: Db *pDb;
82949:
82950: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
82951: pDb = &db->aDb[iDb];
82952: pHash = &pDb->pSchema->tblHash;
82953: for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
82954: Table *pTab = sqliteHashData(pElem);
82955: if( pTab->tnum==iFrom ){
82956: pTab->tnum = iTo;
82957: }
82958: }
82959: pHash = &pDb->pSchema->idxHash;
82960: for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
82961: Index *pIdx = sqliteHashData(pElem);
82962: if( pIdx->tnum==iFrom ){
82963: pIdx->tnum = iTo;
82964: }
82965: }
82966: }
82967: #endif
82968:
82969: /*
82970: ** Write code to erase the table with root-page iTable from database iDb.
82971: ** Also write code to modify the sqlite_master table and internal schema
82972: ** if a root-page of another table is moved by the btree-layer whilst
82973: ** erasing iTable (this can happen with an auto-vacuum database).
82974: */
82975: static void destroyRootPage(Parse *pParse, int iTable, int iDb){
82976: Vdbe *v = sqlite3GetVdbe(pParse);
82977: int r1 = sqlite3GetTempReg(pParse);
82978: sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
82979: sqlite3MayAbort(pParse);
82980: #ifndef SQLITE_OMIT_AUTOVACUUM
82981: /* OP_Destroy stores an in integer r1. If this integer
82982: ** is non-zero, then it is the root page number of a table moved to
82983: ** location iTable. The following code modifies the sqlite_master table to
82984: ** reflect this.
82985: **
82986: ** The "#NNN" in the SQL is a special constant that means whatever value
82987: ** is in register NNN. See grammar rules associated with the TK_REGISTER
82988: ** token for additional information.
82989: */
82990: sqlite3NestedParse(pParse,
82991: "UPDATE %Q.%s SET rootpage=%d WHERE #%d AND rootpage=#%d",
82992: pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
82993: #endif
82994: sqlite3ReleaseTempReg(pParse, r1);
82995: }
82996:
82997: /*
82998: ** Write VDBE code to erase table pTab and all associated indices on disk.
82999: ** Code to update the sqlite_master tables and internal schema definitions
83000: ** in case a root-page belonging to another table is moved by the btree layer
83001: ** is also added (this can happen with an auto-vacuum database).
83002: */
83003: static void destroyTable(Parse *pParse, Table *pTab){
83004: #ifdef SQLITE_OMIT_AUTOVACUUM
83005: Index *pIdx;
83006: int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
83007: destroyRootPage(pParse, pTab->tnum, iDb);
83008: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83009: destroyRootPage(pParse, pIdx->tnum, iDb);
83010: }
83011: #else
83012: /* If the database may be auto-vacuum capable (if SQLITE_OMIT_AUTOVACUUM
83013: ** is not defined), then it is important to call OP_Destroy on the
83014: ** table and index root-pages in order, starting with the numerically
83015: ** largest root-page number. This guarantees that none of the root-pages
83016: ** to be destroyed is relocated by an earlier OP_Destroy. i.e. if the
83017: ** following were coded:
83018: **
83019: ** OP_Destroy 4 0
83020: ** ...
83021: ** OP_Destroy 5 0
83022: **
83023: ** and root page 5 happened to be the largest root-page number in the
83024: ** database, then root page 5 would be moved to page 4 by the
83025: ** "OP_Destroy 4 0" opcode. The subsequent "OP_Destroy 5 0" would hit
83026: ** a free-list page.
83027: */
83028: int iTab = pTab->tnum;
83029: int iDestroyed = 0;
83030:
83031: while( 1 ){
83032: Index *pIdx;
83033: int iLargest = 0;
83034:
83035: if( iDestroyed==0 || iTab<iDestroyed ){
83036: iLargest = iTab;
83037: }
83038: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83039: int iIdx = pIdx->tnum;
83040: assert( pIdx->pSchema==pTab->pSchema );
83041: if( (iDestroyed==0 || (iIdx<iDestroyed)) && iIdx>iLargest ){
83042: iLargest = iIdx;
83043: }
83044: }
83045: if( iLargest==0 ){
83046: return;
83047: }else{
83048: int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
83049: destroyRootPage(pParse, iLargest, iDb);
83050: iDestroyed = iLargest;
83051: }
83052: }
83053: #endif
83054: }
83055:
83056: /*
83057: ** Remove entries from the sqlite_statN tables (for N in (1,2,3))
83058: ** after a DROP INDEX or DROP TABLE command.
83059: */
83060: static void sqlite3ClearStatTables(
83061: Parse *pParse, /* The parsing context */
83062: int iDb, /* The database number */
83063: const char *zType, /* "idx" or "tbl" */
83064: const char *zName /* Name of index or table */
83065: ){
83066: int i;
83067: const char *zDbName = pParse->db->aDb[iDb].zName;
83068: for(i=1; i<=3; i++){
83069: char zTab[24];
83070: sqlite3_snprintf(sizeof(zTab),zTab,"sqlite_stat%d",i);
83071: if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
83072: sqlite3NestedParse(pParse,
83073: "DELETE FROM %Q.%s WHERE %s=%Q",
83074: zDbName, zTab, zType, zName
83075: );
83076: }
83077: }
83078: }
83079:
83080: /*
83081: ** Generate code to drop a table.
83082: */
83083: SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
83084: Vdbe *v;
83085: sqlite3 *db = pParse->db;
83086: Trigger *pTrigger;
83087: Db *pDb = &db->aDb[iDb];
83088:
83089: v = sqlite3GetVdbe(pParse);
83090: assert( v!=0 );
83091: sqlite3BeginWriteOperation(pParse, 1, iDb);
83092:
83093: #ifndef SQLITE_OMIT_VIRTUALTABLE
83094: if( IsVirtual(pTab) ){
83095: sqlite3VdbeAddOp0(v, OP_VBegin);
83096: }
83097: #endif
83098:
83099: /* Drop all triggers associated with the table being dropped. Code
83100: ** is generated to remove entries from sqlite_master and/or
83101: ** sqlite_temp_master if required.
83102: */
83103: pTrigger = sqlite3TriggerList(pParse, pTab);
83104: while( pTrigger ){
83105: assert( pTrigger->pSchema==pTab->pSchema ||
83106: pTrigger->pSchema==db->aDb[1].pSchema );
83107: sqlite3DropTriggerPtr(pParse, pTrigger);
83108: pTrigger = pTrigger->pNext;
83109: }
83110:
83111: #ifndef SQLITE_OMIT_AUTOINCREMENT
83112: /* Remove any entries of the sqlite_sequence table associated with
83113: ** the table being dropped. This is done before the table is dropped
83114: ** at the btree level, in case the sqlite_sequence table needs to
83115: ** move as a result of the drop (can happen in auto-vacuum mode).
83116: */
83117: if( pTab->tabFlags & TF_Autoincrement ){
83118: sqlite3NestedParse(pParse,
83119: "DELETE FROM %Q.sqlite_sequence WHERE name=%Q",
83120: pDb->zName, pTab->zName
83121: );
83122: }
83123: #endif
83124:
83125: /* Drop all SQLITE_MASTER table and index entries that refer to the
83126: ** table. The program name loops through the master table and deletes
83127: ** every row that refers to a table of the same name as the one being
83128: ** dropped. Triggers are handled seperately because a trigger can be
83129: ** created in the temp database that refers to a table in another
83130: ** database.
83131: */
83132: sqlite3NestedParse(pParse,
83133: "DELETE FROM %Q.%s WHERE tbl_name=%Q and type!='trigger'",
83134: pDb->zName, SCHEMA_TABLE(iDb), pTab->zName);
83135: if( !isView && !IsVirtual(pTab) ){
83136: destroyTable(pParse, pTab);
83137: }
83138:
83139: /* Remove the table entry from SQLite's internal schema and modify
83140: ** the schema cookie.
83141: */
83142: if( IsVirtual(pTab) ){
83143: sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
83144: }
83145: sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
83146: sqlite3ChangeCookie(pParse, iDb);
83147: sqliteViewResetAll(db, iDb);
83148: }
83149:
83150: /*
83151: ** This routine is called to do the work of a DROP TABLE statement.
83152: ** pName is the name of the table to be dropped.
83153: */
83154: SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
83155: Table *pTab;
83156: Vdbe *v;
83157: sqlite3 *db = pParse->db;
83158: int iDb;
83159:
83160: if( db->mallocFailed ){
83161: goto exit_drop_table;
83162: }
83163: assert( pParse->nErr==0 );
83164: assert( pName->nSrc==1 );
83165: if( noErr ) db->suppressErr++;
83166: pTab = sqlite3LocateTable(pParse, isView,
83167: pName->a[0].zName, pName->a[0].zDatabase);
83168: if( noErr ) db->suppressErr--;
83169:
83170: if( pTab==0 ){
83171: if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
83172: goto exit_drop_table;
83173: }
83174: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
83175: assert( iDb>=0 && iDb<db->nDb );
83176:
83177: /* If pTab is a virtual table, call ViewGetColumnNames() to ensure
83178: ** it is initialized.
83179: */
83180: if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
83181: goto exit_drop_table;
83182: }
83183: #ifndef SQLITE_OMIT_AUTHORIZATION
83184: {
83185: int code;
83186: const char *zTab = SCHEMA_TABLE(iDb);
83187: const char *zDb = db->aDb[iDb].zName;
83188: const char *zArg2 = 0;
83189: if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
83190: goto exit_drop_table;
83191: }
83192: if( isView ){
83193: if( !OMIT_TEMPDB && iDb==1 ){
83194: code = SQLITE_DROP_TEMP_VIEW;
83195: }else{
83196: code = SQLITE_DROP_VIEW;
83197: }
83198: #ifndef SQLITE_OMIT_VIRTUALTABLE
83199: }else if( IsVirtual(pTab) ){
83200: code = SQLITE_DROP_VTABLE;
83201: zArg2 = sqlite3GetVTable(db, pTab)->pMod->zName;
83202: #endif
83203: }else{
83204: if( !OMIT_TEMPDB && iDb==1 ){
83205: code = SQLITE_DROP_TEMP_TABLE;
83206: }else{
83207: code = SQLITE_DROP_TABLE;
83208: }
83209: }
83210: if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
83211: goto exit_drop_table;
83212: }
83213: if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
83214: goto exit_drop_table;
83215: }
83216: }
83217: #endif
83218: if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
83219: && sqlite3StrNICmp(pTab->zName, "sqlite_stat", 11)!=0 ){
83220: sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
83221: goto exit_drop_table;
83222: }
83223:
83224: #ifndef SQLITE_OMIT_VIEW
83225: /* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
83226: ** on a table.
83227: */
83228: if( isView && pTab->pSelect==0 ){
83229: sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
83230: goto exit_drop_table;
83231: }
83232: if( !isView && pTab->pSelect ){
83233: sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
83234: goto exit_drop_table;
83235: }
83236: #endif
83237:
83238: /* Generate code to remove the table from the master table
83239: ** on disk.
83240: */
83241: v = sqlite3GetVdbe(pParse);
83242: if( v ){
83243: sqlite3BeginWriteOperation(pParse, 1, iDb);
83244: sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
83245: sqlite3FkDropTable(pParse, pName, pTab);
83246: sqlite3CodeDropTable(pParse, pTab, iDb, isView);
83247: }
83248:
83249: exit_drop_table:
83250: sqlite3SrcListDelete(db, pName);
83251: }
83252:
83253: /*
83254: ** This routine is called to create a new foreign key on the table
83255: ** currently under construction. pFromCol determines which columns
83256: ** in the current table point to the foreign key. If pFromCol==0 then
83257: ** connect the key to the last column inserted. pTo is the name of
83258: ** the table referred to. pToCol is a list of tables in the other
83259: ** pTo table that the foreign key points to. flags contains all
83260: ** information about the conflict resolution algorithms specified
83261: ** in the ON DELETE, ON UPDATE and ON INSERT clauses.
83262: **
83263: ** An FKey structure is created and added to the table currently
83264: ** under construction in the pParse->pNewTable field.
83265: **
83266: ** The foreign key is set for IMMEDIATE processing. A subsequent call
83267: ** to sqlite3DeferForeignKey() might change this to DEFERRED.
83268: */
83269: SQLITE_PRIVATE void sqlite3CreateForeignKey(
83270: Parse *pParse, /* Parsing context */
83271: ExprList *pFromCol, /* Columns in this table that point to other table */
83272: Token *pTo, /* Name of the other table */
83273: ExprList *pToCol, /* Columns in the other table */
83274: int flags /* Conflict resolution algorithms. */
83275: ){
83276: sqlite3 *db = pParse->db;
83277: #ifndef SQLITE_OMIT_FOREIGN_KEY
83278: FKey *pFKey = 0;
83279: FKey *pNextTo;
83280: Table *p = pParse->pNewTable;
83281: int nByte;
83282: int i;
83283: int nCol;
83284: char *z;
83285:
83286: assert( pTo!=0 );
83287: if( p==0 || IN_DECLARE_VTAB ) goto fk_end;
83288: if( pFromCol==0 ){
83289: int iCol = p->nCol-1;
83290: if( NEVER(iCol<0) ) goto fk_end;
83291: if( pToCol && pToCol->nExpr!=1 ){
83292: sqlite3ErrorMsg(pParse, "foreign key on %s"
83293: " should reference only one column of table %T",
83294: p->aCol[iCol].zName, pTo);
83295: goto fk_end;
83296: }
83297: nCol = 1;
83298: }else if( pToCol && pToCol->nExpr!=pFromCol->nExpr ){
83299: sqlite3ErrorMsg(pParse,
83300: "number of columns in foreign key does not match the number of "
83301: "columns in the referenced table");
83302: goto fk_end;
83303: }else{
83304: nCol = pFromCol->nExpr;
83305: }
83306: nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
83307: if( pToCol ){
83308: for(i=0; i<pToCol->nExpr; i++){
83309: nByte += sqlite3Strlen30(pToCol->a[i].zName) + 1;
83310: }
83311: }
83312: pFKey = sqlite3DbMallocZero(db, nByte );
83313: if( pFKey==0 ){
83314: goto fk_end;
83315: }
83316: pFKey->pFrom = p;
83317: pFKey->pNextFrom = p->pFKey;
83318: z = (char*)&pFKey->aCol[nCol];
83319: pFKey->zTo = z;
83320: memcpy(z, pTo->z, pTo->n);
83321: z[pTo->n] = 0;
83322: sqlite3Dequote(z);
83323: z += pTo->n+1;
83324: pFKey->nCol = nCol;
83325: if( pFromCol==0 ){
83326: pFKey->aCol[0].iFrom = p->nCol-1;
83327: }else{
83328: for(i=0; i<nCol; i++){
83329: int j;
83330: for(j=0; j<p->nCol; j++){
83331: if( sqlite3StrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){
83332: pFKey->aCol[i].iFrom = j;
83333: break;
83334: }
83335: }
83336: if( j>=p->nCol ){
83337: sqlite3ErrorMsg(pParse,
83338: "unknown column \"%s\" in foreign key definition",
83339: pFromCol->a[i].zName);
83340: goto fk_end;
83341: }
83342: }
83343: }
83344: if( pToCol ){
83345: for(i=0; i<nCol; i++){
83346: int n = sqlite3Strlen30(pToCol->a[i].zName);
83347: pFKey->aCol[i].zCol = z;
83348: memcpy(z, pToCol->a[i].zName, n);
83349: z[n] = 0;
83350: z += n+1;
83351: }
83352: }
83353: pFKey->isDeferred = 0;
83354: pFKey->aAction[0] = (u8)(flags & 0xff); /* ON DELETE action */
83355: pFKey->aAction[1] = (u8)((flags >> 8 ) & 0xff); /* ON UPDATE action */
83356:
83357: assert( sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
83358: pNextTo = (FKey *)sqlite3HashInsert(&p->pSchema->fkeyHash,
83359: pFKey->zTo, sqlite3Strlen30(pFKey->zTo), (void *)pFKey
83360: );
83361: if( pNextTo==pFKey ){
83362: db->mallocFailed = 1;
83363: goto fk_end;
83364: }
83365: if( pNextTo ){
83366: assert( pNextTo->pPrevTo==0 );
83367: pFKey->pNextTo = pNextTo;
83368: pNextTo->pPrevTo = pFKey;
83369: }
83370:
83371: /* Link the foreign key to the table as the last step.
83372: */
83373: p->pFKey = pFKey;
83374: pFKey = 0;
83375:
83376: fk_end:
83377: sqlite3DbFree(db, pFKey);
83378: #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
83379: sqlite3ExprListDelete(db, pFromCol);
83380: sqlite3ExprListDelete(db, pToCol);
83381: }
83382:
83383: /*
83384: ** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED
83385: ** clause is seen as part of a foreign key definition. The isDeferred
83386: ** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE.
83387: ** The behavior of the most recently created foreign key is adjusted
83388: ** accordingly.
83389: */
83390: SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
83391: #ifndef SQLITE_OMIT_FOREIGN_KEY
83392: Table *pTab;
83393: FKey *pFKey;
83394: if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
83395: assert( isDeferred==0 || isDeferred==1 ); /* EV: R-30323-21917 */
83396: pFKey->isDeferred = (u8)isDeferred;
83397: #endif
83398: }
83399:
83400: /*
83401: ** Generate code that will erase and refill index *pIdx. This is
83402: ** used to initialize a newly created index or to recompute the
83403: ** content of an index in response to a REINDEX command.
83404: **
83405: ** if memRootPage is not negative, it means that the index is newly
83406: ** created. The register specified by memRootPage contains the
83407: ** root page number of the index. If memRootPage is negative, then
83408: ** the index already exists and must be cleared before being refilled and
83409: ** the root page number of the index is taken from pIndex->tnum.
83410: */
83411: static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
83412: Table *pTab = pIndex->pTable; /* The table that is indexed */
83413: int iTab = pParse->nTab++; /* Btree cursor used for pTab */
83414: int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
83415: int iSorter; /* Cursor opened by OpenSorter (if in use) */
83416: int addr1; /* Address of top of loop */
83417: int addr2; /* Address to jump to for next iteration */
83418: int tnum; /* Root page of index */
83419: Vdbe *v; /* Generate code into this virtual machine */
83420: KeyInfo *pKey; /* KeyInfo for index */
83421: #ifdef SQLITE_OMIT_MERGE_SORT
83422: int regIdxKey; /* Registers containing the index key */
83423: #endif
83424: int regRecord; /* Register holding assemblied index record */
83425: sqlite3 *db = pParse->db; /* The database connection */
83426: int iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
83427:
83428: #ifndef SQLITE_OMIT_AUTHORIZATION
83429: if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
83430: db->aDb[iDb].zName ) ){
83431: return;
83432: }
83433: #endif
83434:
83435: /* Require a write-lock on the table to perform this operation */
83436: sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
83437:
83438: v = sqlite3GetVdbe(pParse);
83439: if( v==0 ) return;
83440: if( memRootPage>=0 ){
83441: tnum = memRootPage;
83442: }else{
83443: tnum = pIndex->tnum;
83444: sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
83445: }
83446: pKey = sqlite3IndexKeyinfo(pParse, pIndex);
83447: sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, tnum, iDb,
83448: (char *)pKey, P4_KEYINFO_HANDOFF);
83449: if( memRootPage>=0 ){
83450: sqlite3VdbeChangeP5(v, 1);
83451: }
83452:
83453: #ifndef SQLITE_OMIT_MERGE_SORT
83454: /* Open the sorter cursor if we are to use one. */
83455: iSorter = pParse->nTab++;
83456: sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, 0, (char*)pKey, P4_KEYINFO);
83457: #else
83458: iSorter = iTab;
83459: #endif
83460:
83461: /* Open the table. Loop through all rows of the table, inserting index
83462: ** records into the sorter. */
83463: sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
83464: addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0);
83465: regRecord = sqlite3GetTempReg(pParse);
83466:
83467: #ifndef SQLITE_OMIT_MERGE_SORT
83468: sqlite3GenerateIndexKey(pParse, pIndex, iTab, regRecord, 1);
83469: sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
83470: sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1);
83471: sqlite3VdbeJumpHere(v, addr1);
83472: addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0);
83473: if( pIndex->onError!=OE_None ){
83474: int j2 = sqlite3VdbeCurrentAddr(v) + 3;
83475: sqlite3VdbeAddOp2(v, OP_Goto, 0, j2);
83476: addr2 = sqlite3VdbeCurrentAddr(v);
83477: sqlite3VdbeAddOp3(v, OP_SorterCompare, iSorter, j2, regRecord);
83478: sqlite3HaltConstraint(
83479: pParse, OE_Abort, "indexed columns are not unique", P4_STATIC
83480: );
83481: }else{
83482: addr2 = sqlite3VdbeCurrentAddr(v);
83483: }
83484: sqlite3VdbeAddOp2(v, OP_SorterData, iSorter, regRecord);
83485: sqlite3VdbeAddOp3(v, OP_IdxInsert, iIdx, regRecord, 1);
83486: sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
83487: #else
83488: regIdxKey = sqlite3GenerateIndexKey(pParse, pIndex, iTab, regRecord, 1);
83489: addr2 = addr1 + 1;
83490: if( pIndex->onError!=OE_None ){
83491: const int regRowid = regIdxKey + pIndex->nColumn;
83492: const int j2 = sqlite3VdbeCurrentAddr(v) + 2;
83493: void * const pRegKey = SQLITE_INT_TO_PTR(regIdxKey);
83494:
83495: /* The registers accessed by the OP_IsUnique opcode were allocated
83496: ** using sqlite3GetTempRange() inside of the sqlite3GenerateIndexKey()
83497: ** call above. Just before that function was freed they were released
83498: ** (made available to the compiler for reuse) using
83499: ** sqlite3ReleaseTempRange(). So in some ways having the OP_IsUnique
83500: ** opcode use the values stored within seems dangerous. However, since
83501: ** we can be sure that no other temp registers have been allocated
83502: ** since sqlite3ReleaseTempRange() was called, it is safe to do so.
83503: */
83504: sqlite3VdbeAddOp4(v, OP_IsUnique, iIdx, j2, regRowid, pRegKey, P4_INT32);
83505: sqlite3HaltConstraint(
83506: pParse, OE_Abort, "indexed columns are not unique", P4_STATIC);
83507: }
83508: sqlite3VdbeAddOp3(v, OP_IdxInsert, iIdx, regRecord, 0);
83509: sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
83510: #endif
83511: sqlite3ReleaseTempReg(pParse, regRecord);
83512: sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2);
83513: sqlite3VdbeJumpHere(v, addr1);
83514:
83515: sqlite3VdbeAddOp1(v, OP_Close, iTab);
83516: sqlite3VdbeAddOp1(v, OP_Close, iIdx);
83517: sqlite3VdbeAddOp1(v, OP_Close, iSorter);
83518: }
83519:
83520: /*
83521: ** Create a new index for an SQL table. pName1.pName2 is the name of the index
83522: ** and pTblList is the name of the table that is to be indexed. Both will
83523: ** be NULL for a primary key or an index that is created to satisfy a
83524: ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
83525: ** as the table to be indexed. pParse->pNewTable is a table that is
83526: ** currently being constructed by a CREATE TABLE statement.
83527: **
83528: ** pList is a list of columns to be indexed. pList will be NULL if this
83529: ** is a primary key or unique-constraint on the most recent column added
83530: ** to the table currently under construction.
83531: **
83532: ** If the index is created successfully, return a pointer to the new Index
83533: ** structure. This is used by sqlite3AddPrimaryKey() to mark the index
83534: ** as the tables primary key (Index.autoIndex==2).
83535: */
83536: SQLITE_PRIVATE Index *sqlite3CreateIndex(
83537: Parse *pParse, /* All information about this parse */
83538: Token *pName1, /* First part of index name. May be NULL */
83539: Token *pName2, /* Second part of index name. May be NULL */
83540: SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
83541: ExprList *pList, /* A list of columns to be indexed */
83542: int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
83543: Token *pStart, /* The CREATE token that begins this statement */
83544: Token *pEnd, /* The ")" that closes the CREATE INDEX statement */
83545: int sortOrder, /* Sort order of primary key when pList==NULL */
83546: int ifNotExist /* Omit error if index already exists */
83547: ){
83548: Index *pRet = 0; /* Pointer to return */
83549: Table *pTab = 0; /* Table to be indexed */
83550: Index *pIndex = 0; /* The index to be created */
83551: char *zName = 0; /* Name of the index */
83552: int nName; /* Number of characters in zName */
83553: int i, j;
83554: Token nullId; /* Fake token for an empty ID list */
83555: DbFixer sFix; /* For assigning database names to pTable */
83556: int sortOrderMask; /* 1 to honor DESC in index. 0 to ignore. */
83557: sqlite3 *db = pParse->db;
83558: Db *pDb; /* The specific table containing the indexed database */
83559: int iDb; /* Index of the database that is being written */
83560: Token *pName = 0; /* Unqualified name of the index to create */
83561: struct ExprList_item *pListItem; /* For looping over pList */
83562: int nCol;
83563: int nExtra = 0;
83564: char *zExtra;
83565:
83566: assert( pStart==0 || pEnd!=0 ); /* pEnd must be non-NULL if pStart is */
83567: assert( pParse->nErr==0 ); /* Never called with prior errors */
83568: if( db->mallocFailed || IN_DECLARE_VTAB ){
83569: goto exit_create_index;
83570: }
83571: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
83572: goto exit_create_index;
83573: }
83574:
83575: /*
83576: ** Find the table that is to be indexed. Return early if not found.
83577: */
83578: if( pTblName!=0 ){
83579:
83580: /* Use the two-part index name to determine the database
83581: ** to search for the table. 'Fix' the table name to this db
83582: ** before looking up the table.
83583: */
83584: assert( pName1 && pName2 );
83585: iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
83586: if( iDb<0 ) goto exit_create_index;
83587: assert( pName && pName->z );
83588:
83589: #ifndef SQLITE_OMIT_TEMPDB
83590: /* If the index name was unqualified, check if the the table
83591: ** is a temp table. If so, set the database to 1. Do not do this
83592: ** if initialising a database schema.
83593: */
83594: if( !db->init.busy ){
83595: pTab = sqlite3SrcListLookup(pParse, pTblName);
83596: if( pName2->n==0 && pTab && pTab->pSchema==db->aDb[1].pSchema ){
83597: iDb = 1;
83598: }
83599: }
83600: #endif
83601:
83602: if( sqlite3FixInit(&sFix, pParse, iDb, "index", pName) &&
83603: sqlite3FixSrcList(&sFix, pTblName)
83604: ){
83605: /* Because the parser constructs pTblName from a single identifier,
83606: ** sqlite3FixSrcList can never fail. */
83607: assert(0);
83608: }
83609: pTab = sqlite3LocateTable(pParse, 0, pTblName->a[0].zName,
83610: pTblName->a[0].zDatabase);
83611: if( !pTab || db->mallocFailed ) goto exit_create_index;
83612: assert( db->aDb[iDb].pSchema==pTab->pSchema );
83613: }else{
83614: assert( pName==0 );
83615: assert( pStart==0 );
83616: pTab = pParse->pNewTable;
83617: if( !pTab ) goto exit_create_index;
83618: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
83619: }
83620: pDb = &db->aDb[iDb];
83621:
83622: assert( pTab!=0 );
83623: assert( pParse->nErr==0 );
83624: if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
83625: && memcmp(&pTab->zName[7],"altertab_",9)!=0 ){
83626: sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
83627: goto exit_create_index;
83628: }
83629: #ifndef SQLITE_OMIT_VIEW
83630: if( pTab->pSelect ){
83631: sqlite3ErrorMsg(pParse, "views may not be indexed");
83632: goto exit_create_index;
83633: }
83634: #endif
83635: #ifndef SQLITE_OMIT_VIRTUALTABLE
83636: if( IsVirtual(pTab) ){
83637: sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
83638: goto exit_create_index;
83639: }
83640: #endif
83641:
83642: /*
83643: ** Find the name of the index. Make sure there is not already another
83644: ** index or table with the same name.
83645: **
83646: ** Exception: If we are reading the names of permanent indices from the
83647: ** sqlite_master table (because some other process changed the schema) and
83648: ** one of the index names collides with the name of a temporary table or
83649: ** index, then we will continue to process this index.
83650: **
83651: ** If pName==0 it means that we are
83652: ** dealing with a primary key or UNIQUE constraint. We have to invent our
83653: ** own name.
83654: */
83655: if( pName ){
83656: zName = sqlite3NameFromToken(db, pName);
83657: if( zName==0 ) goto exit_create_index;
83658: assert( pName->z!=0 );
83659: if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
83660: goto exit_create_index;
83661: }
83662: if( !db->init.busy ){
83663: if( sqlite3FindTable(db, zName, 0)!=0 ){
83664: sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
83665: goto exit_create_index;
83666: }
83667: }
83668: if( sqlite3FindIndex(db, zName, pDb->zName)!=0 ){
83669: if( !ifNotExist ){
83670: sqlite3ErrorMsg(pParse, "index %s already exists", zName);
83671: }else{
83672: assert( !db->init.busy );
83673: sqlite3CodeVerifySchema(pParse, iDb);
83674: }
83675: goto exit_create_index;
83676: }
83677: }else{
83678: int n;
83679: Index *pLoop;
83680: for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){}
83681: zName = sqlite3MPrintf(db, "sqlite_autoindex_%s_%d", pTab->zName, n);
83682: if( zName==0 ){
83683: goto exit_create_index;
83684: }
83685: }
83686:
83687: /* Check for authorization to create an index.
83688: */
83689: #ifndef SQLITE_OMIT_AUTHORIZATION
83690: {
83691: const char *zDb = pDb->zName;
83692: if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
83693: goto exit_create_index;
83694: }
83695: i = SQLITE_CREATE_INDEX;
83696: if( !OMIT_TEMPDB && iDb==1 ) i = SQLITE_CREATE_TEMP_INDEX;
83697: if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
83698: goto exit_create_index;
83699: }
83700: }
83701: #endif
83702:
83703: /* If pList==0, it means this routine was called to make a primary
83704: ** key out of the last column added to the table under construction.
83705: ** So create a fake list to simulate this.
83706: */
83707: if( pList==0 ){
83708: nullId.z = pTab->aCol[pTab->nCol-1].zName;
83709: nullId.n = sqlite3Strlen30((char*)nullId.z);
83710: pList = sqlite3ExprListAppend(pParse, 0, 0);
83711: if( pList==0 ) goto exit_create_index;
83712: sqlite3ExprListSetName(pParse, pList, &nullId, 0);
83713: pList->a[0].sortOrder = (u8)sortOrder;
83714: }
83715:
83716: /* Figure out how many bytes of space are required to store explicitly
83717: ** specified collation sequence names.
83718: */
83719: for(i=0; i<pList->nExpr; i++){
83720: Expr *pExpr = pList->a[i].pExpr;
83721: if( pExpr ){
83722: CollSeq *pColl = pExpr->pColl;
83723: /* Either pColl!=0 or there was an OOM failure. But if an OOM
83724: ** failure we have quit before reaching this point. */
83725: if( ALWAYS(pColl) ){
83726: nExtra += (1 + sqlite3Strlen30(pColl->zName));
83727: }
83728: }
83729: }
83730:
83731: /*
83732: ** Allocate the index structure.
83733: */
83734: nName = sqlite3Strlen30(zName);
83735: nCol = pList->nExpr;
83736: pIndex = sqlite3DbMallocZero(db,
83737: ROUND8(sizeof(Index)) + /* Index structure */
83738: ROUND8(sizeof(tRowcnt)*(nCol+1)) + /* Index.aiRowEst */
83739: sizeof(char *)*nCol + /* Index.azColl */
83740: sizeof(int)*nCol + /* Index.aiColumn */
83741: sizeof(u8)*nCol + /* Index.aSortOrder */
83742: nName + 1 + /* Index.zName */
83743: nExtra /* Collation sequence names */
83744: );
83745: if( db->mallocFailed ){
83746: goto exit_create_index;
83747: }
83748: zExtra = (char*)pIndex;
83749: pIndex->aiRowEst = (tRowcnt*)&zExtra[ROUND8(sizeof(Index))];
83750: pIndex->azColl = (char**)
83751: ((char*)pIndex->aiRowEst + ROUND8(sizeof(tRowcnt)*nCol+1));
83752: assert( EIGHT_BYTE_ALIGNMENT(pIndex->aiRowEst) );
83753: assert( EIGHT_BYTE_ALIGNMENT(pIndex->azColl) );
83754: pIndex->aiColumn = (int *)(&pIndex->azColl[nCol]);
83755: pIndex->aSortOrder = (u8 *)(&pIndex->aiColumn[nCol]);
83756: pIndex->zName = (char *)(&pIndex->aSortOrder[nCol]);
83757: zExtra = (char *)(&pIndex->zName[nName+1]);
83758: memcpy(pIndex->zName, zName, nName+1);
83759: pIndex->pTable = pTab;
83760: pIndex->nColumn = pList->nExpr;
83761: pIndex->onError = (u8)onError;
83762: pIndex->autoIndex = (u8)(pName==0);
83763: pIndex->pSchema = db->aDb[iDb].pSchema;
83764: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
83765:
83766: /* Check to see if we should honor DESC requests on index columns
83767: */
83768: if( pDb->pSchema->file_format>=4 ){
83769: sortOrderMask = -1; /* Honor DESC */
83770: }else{
83771: sortOrderMask = 0; /* Ignore DESC */
83772: }
83773:
83774: /* Scan the names of the columns of the table to be indexed and
83775: ** load the column indices into the Index structure. Report an error
83776: ** if any column is not found.
83777: **
83778: ** TODO: Add a test to make sure that the same column is not named
83779: ** more than once within the same index. Only the first instance of
83780: ** the column will ever be used by the optimizer. Note that using the
83781: ** same column more than once cannot be an error because that would
83782: ** break backwards compatibility - it needs to be a warning.
83783: */
83784: for(i=0, pListItem=pList->a; i<pList->nExpr; i++, pListItem++){
83785: const char *zColName = pListItem->zName;
83786: Column *pTabCol;
83787: int requestedSortOrder;
83788: char *zColl; /* Collation sequence name */
83789:
83790: for(j=0, pTabCol=pTab->aCol; j<pTab->nCol; j++, pTabCol++){
83791: if( sqlite3StrICmp(zColName, pTabCol->zName)==0 ) break;
83792: }
83793: if( j>=pTab->nCol ){
83794: sqlite3ErrorMsg(pParse, "table %s has no column named %s",
83795: pTab->zName, zColName);
83796: pParse->checkSchema = 1;
83797: goto exit_create_index;
83798: }
83799: pIndex->aiColumn[i] = j;
83800: /* Justification of the ALWAYS(pListItem->pExpr->pColl): Because of
83801: ** the way the "idxlist" non-terminal is constructed by the parser,
83802: ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
83803: ** must exist or else there must have been an OOM error. But if there
83804: ** was an OOM error, we would never reach this point. */
83805: if( pListItem->pExpr && ALWAYS(pListItem->pExpr->pColl) ){
83806: int nColl;
83807: zColl = pListItem->pExpr->pColl->zName;
83808: nColl = sqlite3Strlen30(zColl) + 1;
83809: assert( nExtra>=nColl );
83810: memcpy(zExtra, zColl, nColl);
83811: zColl = zExtra;
83812: zExtra += nColl;
83813: nExtra -= nColl;
83814: }else{
83815: zColl = pTab->aCol[j].zColl;
83816: if( !zColl ){
83817: zColl = db->pDfltColl->zName;
83818: }
83819: }
83820: if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
83821: goto exit_create_index;
83822: }
83823: pIndex->azColl[i] = zColl;
83824: requestedSortOrder = pListItem->sortOrder & sortOrderMask;
83825: pIndex->aSortOrder[i] = (u8)requestedSortOrder;
83826: }
83827: sqlite3DefaultRowEst(pIndex);
83828:
83829: if( pTab==pParse->pNewTable ){
83830: /* This routine has been called to create an automatic index as a
83831: ** result of a PRIMARY KEY or UNIQUE clause on a column definition, or
83832: ** a PRIMARY KEY or UNIQUE clause following the column definitions.
83833: ** i.e. one of:
83834: **
83835: ** CREATE TABLE t(x PRIMARY KEY, y);
83836: ** CREATE TABLE t(x, y, UNIQUE(x, y));
83837: **
83838: ** Either way, check to see if the table already has such an index. If
83839: ** so, don't bother creating this one. This only applies to
83840: ** automatically created indices. Users can do as they wish with
83841: ** explicit indices.
83842: **
83843: ** Two UNIQUE or PRIMARY KEY constraints are considered equivalent
83844: ** (and thus suppressing the second one) even if they have different
83845: ** sort orders.
83846: **
83847: ** If there are different collating sequences or if the columns of
83848: ** the constraint occur in different orders, then the constraints are
83849: ** considered distinct and both result in separate indices.
83850: */
83851: Index *pIdx;
83852: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
83853: int k;
83854: assert( pIdx->onError!=OE_None );
83855: assert( pIdx->autoIndex );
83856: assert( pIndex->onError!=OE_None );
83857:
83858: if( pIdx->nColumn!=pIndex->nColumn ) continue;
83859: for(k=0; k<pIdx->nColumn; k++){
83860: const char *z1;
83861: const char *z2;
83862: if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
83863: z1 = pIdx->azColl[k];
83864: z2 = pIndex->azColl[k];
83865: if( z1!=z2 && sqlite3StrICmp(z1, z2) ) break;
83866: }
83867: if( k==pIdx->nColumn ){
83868: if( pIdx->onError!=pIndex->onError ){
83869: /* This constraint creates the same index as a previous
83870: ** constraint specified somewhere in the CREATE TABLE statement.
83871: ** However the ON CONFLICT clauses are different. If both this
83872: ** constraint and the previous equivalent constraint have explicit
83873: ** ON CONFLICT clauses this is an error. Otherwise, use the
83874: ** explicitly specified behaviour for the index.
83875: */
83876: if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
83877: sqlite3ErrorMsg(pParse,
83878: "conflicting ON CONFLICT clauses specified", 0);
83879: }
83880: if( pIdx->onError==OE_Default ){
83881: pIdx->onError = pIndex->onError;
83882: }
83883: }
83884: goto exit_create_index;
83885: }
83886: }
83887: }
83888:
83889: /* Link the new Index structure to its table and to the other
83890: ** in-memory database structures.
83891: */
83892: if( db->init.busy ){
83893: Index *p;
83894: assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
83895: p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
83896: pIndex->zName, sqlite3Strlen30(pIndex->zName),
83897: pIndex);
83898: if( p ){
83899: assert( p==pIndex ); /* Malloc must have failed */
83900: db->mallocFailed = 1;
83901: goto exit_create_index;
83902: }
83903: db->flags |= SQLITE_InternChanges;
83904: if( pTblName!=0 ){
83905: pIndex->tnum = db->init.newTnum;
83906: }
83907: }
83908:
83909: /* If the db->init.busy is 0 then create the index on disk. This
83910: ** involves writing the index into the master table and filling in the
83911: ** index with the current table contents.
83912: **
83913: ** The db->init.busy is 0 when the user first enters a CREATE INDEX
83914: ** command. db->init.busy is 1 when a database is opened and
83915: ** CREATE INDEX statements are read out of the master table. In
83916: ** the latter case the index already exists on disk, which is why
83917: ** we don't want to recreate it.
83918: **
83919: ** If pTblName==0 it means this index is generated as a primary key
83920: ** or UNIQUE constraint of a CREATE TABLE statement. Since the table
83921: ** has just been created, it contains no data and the index initialization
83922: ** step can be skipped.
83923: */
83924: else{ /* if( db->init.busy==0 ) */
83925: Vdbe *v;
83926: char *zStmt;
83927: int iMem = ++pParse->nMem;
83928:
83929: v = sqlite3GetVdbe(pParse);
83930: if( v==0 ) goto exit_create_index;
83931:
83932:
83933: /* Create the rootpage for the index
83934: */
83935: sqlite3BeginWriteOperation(pParse, 1, iDb);
83936: sqlite3VdbeAddOp2(v, OP_CreateIndex, iDb, iMem);
83937:
83938: /* Gather the complete text of the CREATE INDEX statement into
83939: ** the zStmt variable
83940: */
83941: if( pStart ){
83942: assert( pEnd!=0 );
83943: /* A named index with an explicit CREATE INDEX statement */
83944: zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
83945: onError==OE_None ? "" : " UNIQUE",
83946: (int)(pEnd->z - pName->z) + 1,
83947: pName->z);
83948: }else{
83949: /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
83950: /* zStmt = sqlite3MPrintf(""); */
83951: zStmt = 0;
83952: }
83953:
83954: /* Add an entry in sqlite_master for this index
83955: */
83956: sqlite3NestedParse(pParse,
83957: "INSERT INTO %Q.%s VALUES('index',%Q,%Q,#%d,%Q);",
83958: db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
83959: pIndex->zName,
83960: pTab->zName,
83961: iMem,
83962: zStmt
83963: );
83964: sqlite3DbFree(db, zStmt);
83965:
83966: /* Fill the index with data and reparse the schema. Code an OP_Expire
83967: ** to invalidate all pre-compiled statements.
83968: */
83969: if( pTblName ){
83970: sqlite3RefillIndex(pParse, pIndex, iMem);
83971: sqlite3ChangeCookie(pParse, iDb);
83972: sqlite3VdbeAddParseSchemaOp(v, iDb,
83973: sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName));
83974: sqlite3VdbeAddOp1(v, OP_Expire, 0);
83975: }
83976: }
83977:
83978: /* When adding an index to the list of indices for a table, make
83979: ** sure all indices labeled OE_Replace come after all those labeled
83980: ** OE_Ignore. This is necessary for the correct constraint check
83981: ** processing (in sqlite3GenerateConstraintChecks()) as part of
83982: ** UPDATE and INSERT statements.
83983: */
83984: if( db->init.busy || pTblName==0 ){
83985: if( onError!=OE_Replace || pTab->pIndex==0
83986: || pTab->pIndex->onError==OE_Replace){
83987: pIndex->pNext = pTab->pIndex;
83988: pTab->pIndex = pIndex;
83989: }else{
83990: Index *pOther = pTab->pIndex;
83991: while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){
83992: pOther = pOther->pNext;
83993: }
83994: pIndex->pNext = pOther->pNext;
83995: pOther->pNext = pIndex;
83996: }
83997: pRet = pIndex;
83998: pIndex = 0;
83999: }
84000:
84001: /* Clean up before exiting */
84002: exit_create_index:
84003: if( pIndex ){
84004: sqlite3DbFree(db, pIndex->zColAff);
84005: sqlite3DbFree(db, pIndex);
84006: }
84007: sqlite3ExprListDelete(db, pList);
84008: sqlite3SrcListDelete(db, pTblName);
84009: sqlite3DbFree(db, zName);
84010: return pRet;
84011: }
84012:
84013: /*
84014: ** Fill the Index.aiRowEst[] array with default information - information
84015: ** to be used when we have not run the ANALYZE command.
84016: **
84017: ** aiRowEst[0] is suppose to contain the number of elements in the index.
84018: ** Since we do not know, guess 1 million. aiRowEst[1] is an estimate of the
84019: ** number of rows in the table that match any particular value of the
84020: ** first column of the index. aiRowEst[2] is an estimate of the number
84021: ** of rows that match any particular combiniation of the first 2 columns
84022: ** of the index. And so forth. It must always be the case that
84023: *
84024: ** aiRowEst[N]<=aiRowEst[N-1]
84025: ** aiRowEst[N]>=1
84026: **
84027: ** Apart from that, we have little to go on besides intuition as to
84028: ** how aiRowEst[] should be initialized. The numbers generated here
84029: ** are based on typical values found in actual indices.
84030: */
84031: SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){
84032: tRowcnt *a = pIdx->aiRowEst;
84033: int i;
84034: tRowcnt n;
84035: assert( a!=0 );
84036: a[0] = pIdx->pTable->nRowEst;
84037: if( a[0]<10 ) a[0] = 10;
84038: n = 10;
84039: for(i=1; i<=pIdx->nColumn; i++){
84040: a[i] = n;
84041: if( n>5 ) n--;
84042: }
84043: if( pIdx->onError!=OE_None ){
84044: a[pIdx->nColumn] = 1;
84045: }
84046: }
84047:
84048: /*
84049: ** This routine will drop an existing named index. This routine
84050: ** implements the DROP INDEX statement.
84051: */
84052: SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
84053: Index *pIndex;
84054: Vdbe *v;
84055: sqlite3 *db = pParse->db;
84056: int iDb;
84057:
84058: assert( pParse->nErr==0 ); /* Never called with prior errors */
84059: if( db->mallocFailed ){
84060: goto exit_drop_index;
84061: }
84062: assert( pName->nSrc==1 );
84063: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
84064: goto exit_drop_index;
84065: }
84066: pIndex = sqlite3FindIndex(db, pName->a[0].zName, pName->a[0].zDatabase);
84067: if( pIndex==0 ){
84068: if( !ifExists ){
84069: sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
84070: }else{
84071: sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
84072: }
84073: pParse->checkSchema = 1;
84074: goto exit_drop_index;
84075: }
84076: if( pIndex->autoIndex ){
84077: sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
84078: "or PRIMARY KEY constraint cannot be dropped", 0);
84079: goto exit_drop_index;
84080: }
84081: iDb = sqlite3SchemaToIndex(db, pIndex->pSchema);
84082: #ifndef SQLITE_OMIT_AUTHORIZATION
84083: {
84084: int code = SQLITE_DROP_INDEX;
84085: Table *pTab = pIndex->pTable;
84086: const char *zDb = db->aDb[iDb].zName;
84087: const char *zTab = SCHEMA_TABLE(iDb);
84088: if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
84089: goto exit_drop_index;
84090: }
84091: if( !OMIT_TEMPDB && iDb ) code = SQLITE_DROP_TEMP_INDEX;
84092: if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
84093: goto exit_drop_index;
84094: }
84095: }
84096: #endif
84097:
84098: /* Generate code to remove the index and from the master table */
84099: v = sqlite3GetVdbe(pParse);
84100: if( v ){
84101: sqlite3BeginWriteOperation(pParse, 1, iDb);
84102: sqlite3NestedParse(pParse,
84103: "DELETE FROM %Q.%s WHERE name=%Q AND type='index'",
84104: db->aDb[iDb].zName, SCHEMA_TABLE(iDb), pIndex->zName
84105: );
84106: sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
84107: sqlite3ChangeCookie(pParse, iDb);
84108: destroyRootPage(pParse, pIndex->tnum, iDb);
84109: sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
84110: }
84111:
84112: exit_drop_index:
84113: sqlite3SrcListDelete(db, pName);
84114: }
84115:
84116: /*
84117: ** pArray is a pointer to an array of objects. Each object in the
84118: ** array is szEntry bytes in size. This routine allocates a new
84119: ** object on the end of the array.
84120: **
84121: ** *pnEntry is the number of entries already in use. *pnAlloc is
84122: ** the previously allocated size of the array. initSize is the
84123: ** suggested initial array size allocation.
84124: **
84125: ** The index of the new entry is returned in *pIdx.
84126: **
84127: ** This routine returns a pointer to the array of objects. This
84128: ** might be the same as the pArray parameter or it might be a different
84129: ** pointer if the array was resized.
84130: */
84131: SQLITE_PRIVATE void *sqlite3ArrayAllocate(
84132: sqlite3 *db, /* Connection to notify of malloc failures */
84133: void *pArray, /* Array of objects. Might be reallocated */
84134: int szEntry, /* Size of each object in the array */
84135: int initSize, /* Suggested initial allocation, in elements */
84136: int *pnEntry, /* Number of objects currently in use */
84137: int *pnAlloc, /* Current size of the allocation, in elements */
84138: int *pIdx /* Write the index of a new slot here */
84139: ){
84140: char *z;
84141: if( *pnEntry >= *pnAlloc ){
84142: void *pNew;
84143: int newSize;
84144: newSize = (*pnAlloc)*2 + initSize;
84145: pNew = sqlite3DbRealloc(db, pArray, newSize*szEntry);
84146: if( pNew==0 ){
84147: *pIdx = -1;
84148: return pArray;
84149: }
84150: *pnAlloc = sqlite3DbMallocSize(db, pNew)/szEntry;
84151: pArray = pNew;
84152: }
84153: z = (char*)pArray;
84154: memset(&z[*pnEntry * szEntry], 0, szEntry);
84155: *pIdx = *pnEntry;
84156: ++*pnEntry;
84157: return pArray;
84158: }
84159:
84160: /*
84161: ** Append a new element to the given IdList. Create a new IdList if
84162: ** need be.
84163: **
84164: ** A new IdList is returned, or NULL if malloc() fails.
84165: */
84166: SQLITE_PRIVATE IdList *sqlite3IdListAppend(sqlite3 *db, IdList *pList, Token *pToken){
84167: int i;
84168: if( pList==0 ){
84169: pList = sqlite3DbMallocZero(db, sizeof(IdList) );
84170: if( pList==0 ) return 0;
84171: pList->nAlloc = 0;
84172: }
84173: pList->a = sqlite3ArrayAllocate(
84174: db,
84175: pList->a,
84176: sizeof(pList->a[0]),
84177: 5,
84178: &pList->nId,
84179: &pList->nAlloc,
84180: &i
84181: );
84182: if( i<0 ){
84183: sqlite3IdListDelete(db, pList);
84184: return 0;
84185: }
84186: pList->a[i].zName = sqlite3NameFromToken(db, pToken);
84187: return pList;
84188: }
84189:
84190: /*
84191: ** Delete an IdList.
84192: */
84193: SQLITE_PRIVATE void sqlite3IdListDelete(sqlite3 *db, IdList *pList){
84194: int i;
84195: if( pList==0 ) return;
84196: for(i=0; i<pList->nId; i++){
84197: sqlite3DbFree(db, pList->a[i].zName);
84198: }
84199: sqlite3DbFree(db, pList->a);
84200: sqlite3DbFree(db, pList);
84201: }
84202:
84203: /*
84204: ** Return the index in pList of the identifier named zId. Return -1
84205: ** if not found.
84206: */
84207: SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
84208: int i;
84209: if( pList==0 ) return -1;
84210: for(i=0; i<pList->nId; i++){
84211: if( sqlite3StrICmp(pList->a[i].zName, zName)==0 ) return i;
84212: }
84213: return -1;
84214: }
84215:
84216: /*
84217: ** Expand the space allocated for the given SrcList object by
84218: ** creating nExtra new slots beginning at iStart. iStart is zero based.
84219: ** New slots are zeroed.
84220: **
84221: ** For example, suppose a SrcList initially contains two entries: A,B.
84222: ** To append 3 new entries onto the end, do this:
84223: **
84224: ** sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
84225: **
84226: ** After the call above it would contain: A, B, nil, nil, nil.
84227: ** If the iStart argument had been 1 instead of 2, then the result
84228: ** would have been: A, nil, nil, nil, B. To prepend the new slots,
84229: ** the iStart value would be 0. The result then would
84230: ** be: nil, nil, nil, A, B.
84231: **
84232: ** If a memory allocation fails the SrcList is unchanged. The
84233: ** db->mallocFailed flag will be set to true.
84234: */
84235: SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(
84236: sqlite3 *db, /* Database connection to notify of OOM errors */
84237: SrcList *pSrc, /* The SrcList to be enlarged */
84238: int nExtra, /* Number of new slots to add to pSrc->a[] */
84239: int iStart /* Index in pSrc->a[] of first new slot */
84240: ){
84241: int i;
84242:
84243: /* Sanity checking on calling parameters */
84244: assert( iStart>=0 );
84245: assert( nExtra>=1 );
84246: assert( pSrc!=0 );
84247: assert( iStart<=pSrc->nSrc );
84248:
84249: /* Allocate additional space if needed */
84250: if( pSrc->nSrc+nExtra>pSrc->nAlloc ){
84251: SrcList *pNew;
84252: int nAlloc = pSrc->nSrc+nExtra;
84253: int nGot;
84254: pNew = sqlite3DbRealloc(db, pSrc,
84255: sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
84256: if( pNew==0 ){
84257: assert( db->mallocFailed );
84258: return pSrc;
84259: }
84260: pSrc = pNew;
84261: nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1;
84262: pSrc->nAlloc = (u16)nGot;
84263: }
84264:
84265: /* Move existing slots that come after the newly inserted slots
84266: ** out of the way */
84267: for(i=pSrc->nSrc-1; i>=iStart; i--){
84268: pSrc->a[i+nExtra] = pSrc->a[i];
84269: }
84270: pSrc->nSrc += (i16)nExtra;
84271:
84272: /* Zero the newly allocated slots */
84273: memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra);
84274: for(i=iStart; i<iStart+nExtra; i++){
84275: pSrc->a[i].iCursor = -1;
84276: }
84277:
84278: /* Return a pointer to the enlarged SrcList */
84279: return pSrc;
84280: }
84281:
84282:
84283: /*
84284: ** Append a new table name to the given SrcList. Create a new SrcList if
84285: ** need be. A new entry is created in the SrcList even if pTable is NULL.
84286: **
84287: ** A SrcList is returned, or NULL if there is an OOM error. The returned
84288: ** SrcList might be the same as the SrcList that was input or it might be
84289: ** a new one. If an OOM error does occurs, then the prior value of pList
84290: ** that is input to this routine is automatically freed.
84291: **
84292: ** If pDatabase is not null, it means that the table has an optional
84293: ** database name prefix. Like this: "database.table". The pDatabase
84294: ** points to the table name and the pTable points to the database name.
84295: ** The SrcList.a[].zName field is filled with the table name which might
84296: ** come from pTable (if pDatabase is NULL) or from pDatabase.
84297: ** SrcList.a[].zDatabase is filled with the database name from pTable,
84298: ** or with NULL if no database is specified.
84299: **
84300: ** In other words, if call like this:
84301: **
84302: ** sqlite3SrcListAppend(D,A,B,0);
84303: **
84304: ** Then B is a table name and the database name is unspecified. If called
84305: ** like this:
84306: **
84307: ** sqlite3SrcListAppend(D,A,B,C);
84308: **
84309: ** Then C is the table name and B is the database name. If C is defined
84310: ** then so is B. In other words, we never have a case where:
84311: **
84312: ** sqlite3SrcListAppend(D,A,0,C);
84313: **
84314: ** Both pTable and pDatabase are assumed to be quoted. They are dequoted
84315: ** before being added to the SrcList.
84316: */
84317: SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(
84318: sqlite3 *db, /* Connection to notify of malloc failures */
84319: SrcList *pList, /* Append to this SrcList. NULL creates a new SrcList */
84320: Token *pTable, /* Table to append */
84321: Token *pDatabase /* Database of the table */
84322: ){
84323: struct SrcList_item *pItem;
84324: assert( pDatabase==0 || pTable!=0 ); /* Cannot have C without B */
84325: if( pList==0 ){
84326: pList = sqlite3DbMallocZero(db, sizeof(SrcList) );
84327: if( pList==0 ) return 0;
84328: pList->nAlloc = 1;
84329: }
84330: pList = sqlite3SrcListEnlarge(db, pList, 1, pList->nSrc);
84331: if( db->mallocFailed ){
84332: sqlite3SrcListDelete(db, pList);
84333: return 0;
84334: }
84335: pItem = &pList->a[pList->nSrc-1];
84336: if( pDatabase && pDatabase->z==0 ){
84337: pDatabase = 0;
84338: }
84339: if( pDatabase ){
84340: Token *pTemp = pDatabase;
84341: pDatabase = pTable;
84342: pTable = pTemp;
84343: }
84344: pItem->zName = sqlite3NameFromToken(db, pTable);
84345: pItem->zDatabase = sqlite3NameFromToken(db, pDatabase);
84346: return pList;
84347: }
84348:
84349: /*
84350: ** Assign VdbeCursor index numbers to all tables in a SrcList
84351: */
84352: SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
84353: int i;
84354: struct SrcList_item *pItem;
84355: assert(pList || pParse->db->mallocFailed );
84356: if( pList ){
84357: for(i=0, pItem=pList->a; i<pList->nSrc; i++, pItem++){
84358: if( pItem->iCursor>=0 ) break;
84359: pItem->iCursor = pParse->nTab++;
84360: if( pItem->pSelect ){
84361: sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
84362: }
84363: }
84364: }
84365: }
84366:
84367: /*
84368: ** Delete an entire SrcList including all its substructure.
84369: */
84370: SQLITE_PRIVATE void sqlite3SrcListDelete(sqlite3 *db, SrcList *pList){
84371: int i;
84372: struct SrcList_item *pItem;
84373: if( pList==0 ) return;
84374: for(pItem=pList->a, i=0; i<pList->nSrc; i++, pItem++){
84375: sqlite3DbFree(db, pItem->zDatabase);
84376: sqlite3DbFree(db, pItem->zName);
84377: sqlite3DbFree(db, pItem->zAlias);
84378: sqlite3DbFree(db, pItem->zIndex);
84379: sqlite3DeleteTable(db, pItem->pTab);
84380: sqlite3SelectDelete(db, pItem->pSelect);
84381: sqlite3ExprDelete(db, pItem->pOn);
84382: sqlite3IdListDelete(db, pItem->pUsing);
84383: }
84384: sqlite3DbFree(db, pList);
84385: }
84386:
84387: /*
84388: ** This routine is called by the parser to add a new term to the
84389: ** end of a growing FROM clause. The "p" parameter is the part of
84390: ** the FROM clause that has already been constructed. "p" is NULL
84391: ** if this is the first term of the FROM clause. pTable and pDatabase
84392: ** are the name of the table and database named in the FROM clause term.
84393: ** pDatabase is NULL if the database name qualifier is missing - the
84394: ** usual case. If the term has a alias, then pAlias points to the
84395: ** alias token. If the term is a subquery, then pSubquery is the
84396: ** SELECT statement that the subquery encodes. The pTable and
84397: ** pDatabase parameters are NULL for subqueries. The pOn and pUsing
84398: ** parameters are the content of the ON and USING clauses.
84399: **
84400: ** Return a new SrcList which encodes is the FROM with the new
84401: ** term added.
84402: */
84403: SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(
84404: Parse *pParse, /* Parsing context */
84405: SrcList *p, /* The left part of the FROM clause already seen */
84406: Token *pTable, /* Name of the table to add to the FROM clause */
84407: Token *pDatabase, /* Name of the database containing pTable */
84408: Token *pAlias, /* The right-hand side of the AS subexpression */
84409: Select *pSubquery, /* A subquery used in place of a table name */
84410: Expr *pOn, /* The ON clause of a join */
84411: IdList *pUsing /* The USING clause of a join */
84412: ){
84413: struct SrcList_item *pItem;
84414: sqlite3 *db = pParse->db;
84415: if( !p && (pOn || pUsing) ){
84416: sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
84417: (pOn ? "ON" : "USING")
84418: );
84419: goto append_from_error;
84420: }
84421: p = sqlite3SrcListAppend(db, p, pTable, pDatabase);
84422: if( p==0 || NEVER(p->nSrc==0) ){
84423: goto append_from_error;
84424: }
84425: pItem = &p->a[p->nSrc-1];
84426: assert( pAlias!=0 );
84427: if( pAlias->n ){
84428: pItem->zAlias = sqlite3NameFromToken(db, pAlias);
84429: }
84430: pItem->pSelect = pSubquery;
84431: pItem->pOn = pOn;
84432: pItem->pUsing = pUsing;
84433: return p;
84434:
84435: append_from_error:
84436: assert( p==0 );
84437: sqlite3ExprDelete(db, pOn);
84438: sqlite3IdListDelete(db, pUsing);
84439: sqlite3SelectDelete(db, pSubquery);
84440: return 0;
84441: }
84442:
84443: /*
84444: ** Add an INDEXED BY or NOT INDEXED clause to the most recently added
84445: ** element of the source-list passed as the second argument.
84446: */
84447: SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
84448: assert( pIndexedBy!=0 );
84449: if( p && ALWAYS(p->nSrc>0) ){
84450: struct SrcList_item *pItem = &p->a[p->nSrc-1];
84451: assert( pItem->notIndexed==0 && pItem->zIndex==0 );
84452: if( pIndexedBy->n==1 && !pIndexedBy->z ){
84453: /* A "NOT INDEXED" clause was supplied. See parse.y
84454: ** construct "indexed_opt" for details. */
84455: pItem->notIndexed = 1;
84456: }else{
84457: pItem->zIndex = sqlite3NameFromToken(pParse->db, pIndexedBy);
84458: }
84459: }
84460: }
84461:
84462: /*
84463: ** When building up a FROM clause in the parser, the join operator
84464: ** is initially attached to the left operand. But the code generator
84465: ** expects the join operator to be on the right operand. This routine
84466: ** Shifts all join operators from left to right for an entire FROM
84467: ** clause.
84468: **
84469: ** Example: Suppose the join is like this:
84470: **
84471: ** A natural cross join B
84472: **
84473: ** The operator is "natural cross join". The A and B operands are stored
84474: ** in p->a[0] and p->a[1], respectively. The parser initially stores the
84475: ** operator with A. This routine shifts that operator over to B.
84476: */
84477: SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList *p){
84478: if( p ){
84479: int i;
84480: assert( p->a || p->nSrc==0 );
84481: for(i=p->nSrc-1; i>0; i--){
84482: p->a[i].jointype = p->a[i-1].jointype;
84483: }
84484: p->a[0].jointype = 0;
84485: }
84486: }
84487:
84488: /*
84489: ** Begin a transaction
84490: */
84491: SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
84492: sqlite3 *db;
84493: Vdbe *v;
84494: int i;
84495:
84496: assert( pParse!=0 );
84497: db = pParse->db;
84498: assert( db!=0 );
84499: /* if( db->aDb[0].pBt==0 ) return; */
84500: if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
84501: return;
84502: }
84503: v = sqlite3GetVdbe(pParse);
84504: if( !v ) return;
84505: if( type!=TK_DEFERRED ){
84506: for(i=0; i<db->nDb; i++){
84507: sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
84508: sqlite3VdbeUsesBtree(v, i);
84509: }
84510: }
84511: sqlite3VdbeAddOp2(v, OP_AutoCommit, 0, 0);
84512: }
84513:
84514: /*
84515: ** Commit a transaction
84516: */
84517: SQLITE_PRIVATE void sqlite3CommitTransaction(Parse *pParse){
84518: Vdbe *v;
84519:
84520: assert( pParse!=0 );
84521: assert( pParse->db!=0 );
84522: if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ){
84523: return;
84524: }
84525: v = sqlite3GetVdbe(pParse);
84526: if( v ){
84527: sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 0);
84528: }
84529: }
84530:
84531: /*
84532: ** Rollback a transaction
84533: */
84534: SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse *pParse){
84535: Vdbe *v;
84536:
84537: assert( pParse!=0 );
84538: assert( pParse->db!=0 );
84539: if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ){
84540: return;
84541: }
84542: v = sqlite3GetVdbe(pParse);
84543: if( v ){
84544: sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 1);
84545: }
84546: }
84547:
84548: /*
84549: ** This function is called by the parser when it parses a command to create,
84550: ** release or rollback an SQL savepoint.
84551: */
84552: SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
84553: char *zName = sqlite3NameFromToken(pParse->db, pName);
84554: if( zName ){
84555: Vdbe *v = sqlite3GetVdbe(pParse);
84556: #ifndef SQLITE_OMIT_AUTHORIZATION
84557: static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
84558: assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
84559: #endif
84560: if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
84561: sqlite3DbFree(pParse->db, zName);
84562: return;
84563: }
84564: sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
84565: }
84566: }
84567:
84568: /*
84569: ** Make sure the TEMP database is open and available for use. Return
84570: ** the number of errors. Leave any error messages in the pParse structure.
84571: */
84572: SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){
84573: sqlite3 *db = pParse->db;
84574: if( db->aDb[1].pBt==0 && !pParse->explain ){
84575: int rc;
84576: Btree *pBt;
84577: static const int flags =
84578: SQLITE_OPEN_READWRITE |
84579: SQLITE_OPEN_CREATE |
84580: SQLITE_OPEN_EXCLUSIVE |
84581: SQLITE_OPEN_DELETEONCLOSE |
84582: SQLITE_OPEN_TEMP_DB;
84583:
84584: rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
84585: if( rc!=SQLITE_OK ){
84586: sqlite3ErrorMsg(pParse, "unable to open a temporary database "
84587: "file for storing temporary tables");
84588: pParse->rc = rc;
84589: return 1;
84590: }
84591: db->aDb[1].pBt = pBt;
84592: assert( db->aDb[1].pSchema );
84593: if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
84594: db->mallocFailed = 1;
84595: return 1;
84596: }
84597: }
84598: return 0;
84599: }
84600:
84601: /*
84602: ** Generate VDBE code that will verify the schema cookie and start
84603: ** a read-transaction for all named database files.
84604: **
84605: ** It is important that all schema cookies be verified and all
84606: ** read transactions be started before anything else happens in
84607: ** the VDBE program. But this routine can be called after much other
84608: ** code has been generated. So here is what we do:
84609: **
84610: ** The first time this routine is called, we code an OP_Goto that
84611: ** will jump to a subroutine at the end of the program. Then we
84612: ** record every database that needs its schema verified in the
84613: ** pParse->cookieMask field. Later, after all other code has been
84614: ** generated, the subroutine that does the cookie verifications and
84615: ** starts the transactions will be coded and the OP_Goto P2 value
84616: ** will be made to point to that subroutine. The generation of the
84617: ** cookie verification subroutine code happens in sqlite3FinishCoding().
84618: **
84619: ** If iDb<0 then code the OP_Goto only - don't set flag to verify the
84620: ** schema on any databases. This can be used to position the OP_Goto
84621: ** early in the code, before we know if any database tables will be used.
84622: */
84623: SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
84624: Parse *pToplevel = sqlite3ParseToplevel(pParse);
84625:
84626: if( pToplevel->cookieGoto==0 ){
84627: Vdbe *v = sqlite3GetVdbe(pToplevel);
84628: if( v==0 ) return; /* This only happens if there was a prior error */
84629: pToplevel->cookieGoto = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0)+1;
84630: }
84631: if( iDb>=0 ){
84632: sqlite3 *db = pToplevel->db;
84633: yDbMask mask;
84634:
84635: assert( iDb<db->nDb );
84636: assert( db->aDb[iDb].pBt!=0 || iDb==1 );
84637: assert( iDb<SQLITE_MAX_ATTACHED+2 );
84638: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
84639: mask = ((yDbMask)1)<<iDb;
84640: if( (pToplevel->cookieMask & mask)==0 ){
84641: pToplevel->cookieMask |= mask;
84642: pToplevel->cookieValue[iDb] = db->aDb[iDb].pSchema->schema_cookie;
84643: if( !OMIT_TEMPDB && iDb==1 ){
84644: sqlite3OpenTempDatabase(pToplevel);
84645: }
84646: }
84647: }
84648: }
84649:
84650: /*
84651: ** If argument zDb is NULL, then call sqlite3CodeVerifySchema() for each
84652: ** attached database. Otherwise, invoke it for the database named zDb only.
84653: */
84654: SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
84655: sqlite3 *db = pParse->db;
84656: int i;
84657: for(i=0; i<db->nDb; i++){
84658: Db *pDb = &db->aDb[i];
84659: if( pDb->pBt && (!zDb || 0==sqlite3StrICmp(zDb, pDb->zName)) ){
84660: sqlite3CodeVerifySchema(pParse, i);
84661: }
84662: }
84663: }
84664:
84665: /*
84666: ** Generate VDBE code that prepares for doing an operation that
84667: ** might change the database.
84668: **
84669: ** This routine starts a new transaction if we are not already within
84670: ** a transaction. If we are already within a transaction, then a checkpoint
84671: ** is set if the setStatement parameter is true. A checkpoint should
84672: ** be set for operations that might fail (due to a constraint) part of
84673: ** the way through and which will need to undo some writes without having to
84674: ** rollback the whole transaction. For operations where all constraints
84675: ** can be checked before any changes are made to the database, it is never
84676: ** necessary to undo a write and the checkpoint should not be set.
84677: */
84678: SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
84679: Parse *pToplevel = sqlite3ParseToplevel(pParse);
84680: sqlite3CodeVerifySchema(pParse, iDb);
84681: pToplevel->writeMask |= ((yDbMask)1)<<iDb;
84682: pToplevel->isMultiWrite |= setStatement;
84683: }
84684:
84685: /*
84686: ** Indicate that the statement currently under construction might write
84687: ** more than one entry (example: deleting one row then inserting another,
84688: ** inserting multiple rows in a table, or inserting a row and index entries.)
84689: ** If an abort occurs after some of these writes have completed, then it will
84690: ** be necessary to undo the completed writes.
84691: */
84692: SQLITE_PRIVATE void sqlite3MultiWrite(Parse *pParse){
84693: Parse *pToplevel = sqlite3ParseToplevel(pParse);
84694: pToplevel->isMultiWrite = 1;
84695: }
84696:
84697: /*
84698: ** The code generator calls this routine if is discovers that it is
84699: ** possible to abort a statement prior to completion. In order to
84700: ** perform this abort without corrupting the database, we need to make
84701: ** sure that the statement is protected by a statement transaction.
84702: **
84703: ** Technically, we only need to set the mayAbort flag if the
84704: ** isMultiWrite flag was previously set. There is a time dependency
84705: ** such that the abort must occur after the multiwrite. This makes
84706: ** some statements involving the REPLACE conflict resolution algorithm
84707: ** go a little faster. But taking advantage of this time dependency
84708: ** makes it more difficult to prove that the code is correct (in
84709: ** particular, it prevents us from writing an effective
84710: ** implementation of sqlite3AssertMayAbort()) and so we have chosen
84711: ** to take the safe route and skip the optimization.
84712: */
84713: SQLITE_PRIVATE void sqlite3MayAbort(Parse *pParse){
84714: Parse *pToplevel = sqlite3ParseToplevel(pParse);
84715: pToplevel->mayAbort = 1;
84716: }
84717:
84718: /*
84719: ** Code an OP_Halt that causes the vdbe to return an SQLITE_CONSTRAINT
84720: ** error. The onError parameter determines which (if any) of the statement
84721: ** and/or current transaction is rolled back.
84722: */
84723: SQLITE_PRIVATE void sqlite3HaltConstraint(Parse *pParse, int onError, char *p4, int p4type){
84724: Vdbe *v = sqlite3GetVdbe(pParse);
84725: if( onError==OE_Abort ){
84726: sqlite3MayAbort(pParse);
84727: }
84728: sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CONSTRAINT, onError, 0, p4, p4type);
84729: }
84730:
84731: /*
84732: ** Check to see if pIndex uses the collating sequence pColl. Return
84733: ** true if it does and false if it does not.
84734: */
84735: #ifndef SQLITE_OMIT_REINDEX
84736: static int collationMatch(const char *zColl, Index *pIndex){
84737: int i;
84738: assert( zColl!=0 );
84739: for(i=0; i<pIndex->nColumn; i++){
84740: const char *z = pIndex->azColl[i];
84741: assert( z!=0 );
84742: if( 0==sqlite3StrICmp(z, zColl) ){
84743: return 1;
84744: }
84745: }
84746: return 0;
84747: }
84748: #endif
84749:
84750: /*
84751: ** Recompute all indices of pTab that use the collating sequence pColl.
84752: ** If pColl==0 then recompute all indices of pTab.
84753: */
84754: #ifndef SQLITE_OMIT_REINDEX
84755: static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
84756: Index *pIndex; /* An index associated with pTab */
84757:
84758: for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
84759: if( zColl==0 || collationMatch(zColl, pIndex) ){
84760: int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
84761: sqlite3BeginWriteOperation(pParse, 0, iDb);
84762: sqlite3RefillIndex(pParse, pIndex, -1);
84763: }
84764: }
84765: }
84766: #endif
84767:
84768: /*
84769: ** Recompute all indices of all tables in all databases where the
84770: ** indices use the collating sequence pColl. If pColl==0 then recompute
84771: ** all indices everywhere.
84772: */
84773: #ifndef SQLITE_OMIT_REINDEX
84774: static void reindexDatabases(Parse *pParse, char const *zColl){
84775: Db *pDb; /* A single database */
84776: int iDb; /* The database index number */
84777: sqlite3 *db = pParse->db; /* The database connection */
84778: HashElem *k; /* For looping over tables in pDb */
84779: Table *pTab; /* A table in the database */
84780:
84781: assert( sqlite3BtreeHoldsAllMutexes(db) ); /* Needed for schema access */
84782: for(iDb=0, pDb=db->aDb; iDb<db->nDb; iDb++, pDb++){
84783: assert( pDb!=0 );
84784: for(k=sqliteHashFirst(&pDb->pSchema->tblHash); k; k=sqliteHashNext(k)){
84785: pTab = (Table*)sqliteHashData(k);
84786: reindexTable(pParse, pTab, zColl);
84787: }
84788: }
84789: }
84790: #endif
84791:
84792: /*
84793: ** Generate code for the REINDEX command.
84794: **
84795: ** REINDEX -- 1
84796: ** REINDEX <collation> -- 2
84797: ** REINDEX ?<database>.?<tablename> -- 3
84798: ** REINDEX ?<database>.?<indexname> -- 4
84799: **
84800: ** Form 1 causes all indices in all attached databases to be rebuilt.
84801: ** Form 2 rebuilds all indices in all databases that use the named
84802: ** collating function. Forms 3 and 4 rebuild the named index or all
84803: ** indices associated with the named table.
84804: */
84805: #ifndef SQLITE_OMIT_REINDEX
84806: SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
84807: CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
84808: char *z; /* Name of a table or index */
84809: const char *zDb; /* Name of the database */
84810: Table *pTab; /* A table in the database */
84811: Index *pIndex; /* An index associated with pTab */
84812: int iDb; /* The database index number */
84813: sqlite3 *db = pParse->db; /* The database connection */
84814: Token *pObjName; /* Name of the table or index to be reindexed */
84815:
84816: /* Read the database schema. If an error occurs, leave an error message
84817: ** and code in pParse and return NULL. */
84818: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
84819: return;
84820: }
84821:
84822: if( pName1==0 ){
84823: reindexDatabases(pParse, 0);
84824: return;
84825: }else if( NEVER(pName2==0) || pName2->z==0 ){
84826: char *zColl;
84827: assert( pName1->z );
84828: zColl = sqlite3NameFromToken(pParse->db, pName1);
84829: if( !zColl ) return;
84830: pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
84831: if( pColl ){
84832: reindexDatabases(pParse, zColl);
84833: sqlite3DbFree(db, zColl);
84834: return;
84835: }
84836: sqlite3DbFree(db, zColl);
84837: }
84838: iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
84839: if( iDb<0 ) return;
84840: z = sqlite3NameFromToken(db, pObjName);
84841: if( z==0 ) return;
84842: zDb = db->aDb[iDb].zName;
84843: pTab = sqlite3FindTable(db, z, zDb);
84844: if( pTab ){
84845: reindexTable(pParse, pTab, 0);
84846: sqlite3DbFree(db, z);
84847: return;
84848: }
84849: pIndex = sqlite3FindIndex(db, z, zDb);
84850: sqlite3DbFree(db, z);
84851: if( pIndex ){
84852: sqlite3BeginWriteOperation(pParse, 0, iDb);
84853: sqlite3RefillIndex(pParse, pIndex, -1);
84854: return;
84855: }
84856: sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
84857: }
84858: #endif
84859:
84860: /*
84861: ** Return a dynamicly allocated KeyInfo structure that can be used
84862: ** with OP_OpenRead or OP_OpenWrite to access database index pIdx.
84863: **
84864: ** If successful, a pointer to the new structure is returned. In this case
84865: ** the caller is responsible for calling sqlite3DbFree(db, ) on the returned
84866: ** pointer. If an error occurs (out of memory or missing collation
84867: ** sequence), NULL is returned and the state of pParse updated to reflect
84868: ** the error.
84869: */
84870: SQLITE_PRIVATE KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){
84871: int i;
84872: int nCol = pIdx->nColumn;
84873: int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
84874: sqlite3 *db = pParse->db;
84875: KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZero(db, nBytes);
84876:
84877: if( pKey ){
84878: pKey->db = pParse->db;
84879: pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
84880: assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
84881: for(i=0; i<nCol; i++){
84882: char *zColl = pIdx->azColl[i];
84883: assert( zColl );
84884: pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl);
84885: pKey->aSortOrder[i] = pIdx->aSortOrder[i];
84886: }
84887: pKey->nField = (u16)nCol;
84888: }
84889:
84890: if( pParse->nErr ){
84891: sqlite3DbFree(db, pKey);
84892: pKey = 0;
84893: }
84894: return pKey;
84895: }
84896:
84897: /************** End of build.c ***********************************************/
84898: /************** Begin file callback.c ****************************************/
84899: /*
84900: ** 2005 May 23
84901: **
84902: ** The author disclaims copyright to this source code. In place of
84903: ** a legal notice, here is a blessing:
84904: **
84905: ** May you do good and not evil.
84906: ** May you find forgiveness for yourself and forgive others.
84907: ** May you share freely, never taking more than you give.
84908: **
84909: *************************************************************************
84910: **
84911: ** This file contains functions used to access the internal hash tables
84912: ** of user defined functions and collation sequences.
84913: */
84914:
84915:
84916: /*
84917: ** Invoke the 'collation needed' callback to request a collation sequence
84918: ** in the encoding enc of name zName, length nName.
84919: */
84920: static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
84921: assert( !db->xCollNeeded || !db->xCollNeeded16 );
84922: if( db->xCollNeeded ){
84923: char *zExternal = sqlite3DbStrDup(db, zName);
84924: if( !zExternal ) return;
84925: db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);
84926: sqlite3DbFree(db, zExternal);
84927: }
84928: #ifndef SQLITE_OMIT_UTF16
84929: if( db->xCollNeeded16 ){
84930: char const *zExternal;
84931: sqlite3_value *pTmp = sqlite3ValueNew(db);
84932: sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);
84933: zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE);
84934: if( zExternal ){
84935: db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);
84936: }
84937: sqlite3ValueFree(pTmp);
84938: }
84939: #endif
84940: }
84941:
84942: /*
84943: ** This routine is called if the collation factory fails to deliver a
84944: ** collation function in the best encoding but there may be other versions
84945: ** of this collation function (for other text encodings) available. Use one
84946: ** of these instead if they exist. Avoid a UTF-8 <-> UTF-16 conversion if
84947: ** possible.
84948: */
84949: static int synthCollSeq(sqlite3 *db, CollSeq *pColl){
84950: CollSeq *pColl2;
84951: char *z = pColl->zName;
84952: int i;
84953: static const u8 aEnc[] = { SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8 };
84954: for(i=0; i<3; i++){
84955: pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, 0);
84956: if( pColl2->xCmp!=0 ){
84957: memcpy(pColl, pColl2, sizeof(CollSeq));
84958: pColl->xDel = 0; /* Do not copy the destructor */
84959: return SQLITE_OK;
84960: }
84961: }
84962: return SQLITE_ERROR;
84963: }
84964:
84965: /*
84966: ** This function is responsible for invoking the collation factory callback
84967: ** or substituting a collation sequence of a different encoding when the
84968: ** requested collation sequence is not available in the desired encoding.
84969: **
84970: ** If it is not NULL, then pColl must point to the database native encoding
84971: ** collation sequence with name zName, length nName.
84972: **
84973: ** The return value is either the collation sequence to be used in database
84974: ** db for collation type name zName, length nName, or NULL, if no collation
84975: ** sequence can be found.
84976: **
84977: ** See also: sqlite3LocateCollSeq(), sqlite3FindCollSeq()
84978: */
84979: SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(
84980: sqlite3* db, /* The database connection */
84981: u8 enc, /* The desired encoding for the collating sequence */
84982: CollSeq *pColl, /* Collating sequence with native encoding, or NULL */
84983: const char *zName /* Collating sequence name */
84984: ){
84985: CollSeq *p;
84986:
84987: p = pColl;
84988: if( !p ){
84989: p = sqlite3FindCollSeq(db, enc, zName, 0);
84990: }
84991: if( !p || !p->xCmp ){
84992: /* No collation sequence of this type for this encoding is registered.
84993: ** Call the collation factory to see if it can supply us with one.
84994: */
84995: callCollNeeded(db, enc, zName);
84996: p = sqlite3FindCollSeq(db, enc, zName, 0);
84997: }
84998: if( p && !p->xCmp && synthCollSeq(db, p) ){
84999: p = 0;
85000: }
85001: assert( !p || p->xCmp );
85002: return p;
85003: }
85004:
85005: /*
85006: ** This routine is called on a collation sequence before it is used to
85007: ** check that it is defined. An undefined collation sequence exists when
85008: ** a database is loaded that contains references to collation sequences
85009: ** that have not been defined by sqlite3_create_collation() etc.
85010: **
85011: ** If required, this routine calls the 'collation needed' callback to
85012: ** request a definition of the collating sequence. If this doesn't work,
85013: ** an equivalent collating sequence that uses a text encoding different
85014: ** from the main database is substituted, if one is available.
85015: */
85016: SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){
85017: if( pColl ){
85018: const char *zName = pColl->zName;
85019: sqlite3 *db = pParse->db;
85020: CollSeq *p = sqlite3GetCollSeq(db, ENC(db), pColl, zName);
85021: if( !p ){
85022: sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
85023: pParse->nErr++;
85024: return SQLITE_ERROR;
85025: }
85026: assert( p==pColl );
85027: }
85028: return SQLITE_OK;
85029: }
85030:
85031:
85032:
85033: /*
85034: ** Locate and return an entry from the db.aCollSeq hash table. If the entry
85035: ** specified by zName and nName is not found and parameter 'create' is
85036: ** true, then create a new entry. Otherwise return NULL.
85037: **
85038: ** Each pointer stored in the sqlite3.aCollSeq hash table contains an
85039: ** array of three CollSeq structures. The first is the collation sequence
85040: ** prefferred for UTF-8, the second UTF-16le, and the third UTF-16be.
85041: **
85042: ** Stored immediately after the three collation sequences is a copy of
85043: ** the collation sequence name. A pointer to this string is stored in
85044: ** each collation sequence structure.
85045: */
85046: static CollSeq *findCollSeqEntry(
85047: sqlite3 *db, /* Database connection */
85048: const char *zName, /* Name of the collating sequence */
85049: int create /* Create a new entry if true */
85050: ){
85051: CollSeq *pColl;
85052: int nName = sqlite3Strlen30(zName);
85053: pColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
85054:
85055: if( 0==pColl && create ){
85056: pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1 );
85057: if( pColl ){
85058: CollSeq *pDel = 0;
85059: pColl[0].zName = (char*)&pColl[3];
85060: pColl[0].enc = SQLITE_UTF8;
85061: pColl[1].zName = (char*)&pColl[3];
85062: pColl[1].enc = SQLITE_UTF16LE;
85063: pColl[2].zName = (char*)&pColl[3];
85064: pColl[2].enc = SQLITE_UTF16BE;
85065: memcpy(pColl[0].zName, zName, nName);
85066: pColl[0].zName[nName] = 0;
85067: pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl);
85068:
85069: /* If a malloc() failure occurred in sqlite3HashInsert(), it will
85070: ** return the pColl pointer to be deleted (because it wasn't added
85071: ** to the hash table).
85072: */
85073: assert( pDel==0 || pDel==pColl );
85074: if( pDel!=0 ){
85075: db->mallocFailed = 1;
85076: sqlite3DbFree(db, pDel);
85077: pColl = 0;
85078: }
85079: }
85080: }
85081: return pColl;
85082: }
85083:
85084: /*
85085: ** Parameter zName points to a UTF-8 encoded string nName bytes long.
85086: ** Return the CollSeq* pointer for the collation sequence named zName
85087: ** for the encoding 'enc' from the database 'db'.
85088: **
85089: ** If the entry specified is not found and 'create' is true, then create a
85090: ** new entry. Otherwise return NULL.
85091: **
85092: ** A separate function sqlite3LocateCollSeq() is a wrapper around
85093: ** this routine. sqlite3LocateCollSeq() invokes the collation factory
85094: ** if necessary and generates an error message if the collating sequence
85095: ** cannot be found.
85096: **
85097: ** See also: sqlite3LocateCollSeq(), sqlite3GetCollSeq()
85098: */
85099: SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(
85100: sqlite3 *db,
85101: u8 enc,
85102: const char *zName,
85103: int create
85104: ){
85105: CollSeq *pColl;
85106: if( zName ){
85107: pColl = findCollSeqEntry(db, zName, create);
85108: }else{
85109: pColl = db->pDfltColl;
85110: }
85111: assert( SQLITE_UTF8==1 && SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
85112: assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
85113: if( pColl ) pColl += enc-1;
85114: return pColl;
85115: }
85116:
85117: /* During the search for the best function definition, this procedure
85118: ** is called to test how well the function passed as the first argument
85119: ** matches the request for a function with nArg arguments in a system
85120: ** that uses encoding enc. The value returned indicates how well the
85121: ** request is matched. A higher value indicates a better match.
85122: **
85123: ** The returned value is always between 0 and 6, as follows:
85124: **
85125: ** 0: Not a match, or if nArg<0 and the function is has no implementation.
85126: ** 1: A variable arguments function that prefers UTF-8 when a UTF-16
85127: ** encoding is requested, or vice versa.
85128: ** 2: A variable arguments function that uses UTF-16BE when UTF-16LE is
85129: ** requested, or vice versa.
85130: ** 3: A variable arguments function using the same text encoding.
85131: ** 4: A function with the exact number of arguments requested that
85132: ** prefers UTF-8 when a UTF-16 encoding is requested, or vice versa.
85133: ** 5: A function with the exact number of arguments requested that
85134: ** prefers UTF-16LE when UTF-16BE is requested, or vice versa.
85135: ** 6: An exact match.
85136: **
85137: */
85138: static int matchQuality(FuncDef *p, int nArg, u8 enc){
85139: int match = 0;
85140: if( p->nArg==-1 || p->nArg==nArg
85141: || (nArg==-1 && (p->xFunc!=0 || p->xStep!=0))
85142: ){
85143: match = 1;
85144: if( p->nArg==nArg || nArg==-1 ){
85145: match = 4;
85146: }
85147: if( enc==p->iPrefEnc ){
85148: match += 2;
85149: }
85150: else if( (enc==SQLITE_UTF16LE && p->iPrefEnc==SQLITE_UTF16BE) ||
85151: (enc==SQLITE_UTF16BE && p->iPrefEnc==SQLITE_UTF16LE) ){
85152: match += 1;
85153: }
85154: }
85155: return match;
85156: }
85157:
85158: /*
85159: ** Search a FuncDefHash for a function with the given name. Return
85160: ** a pointer to the matching FuncDef if found, or 0 if there is no match.
85161: */
85162: static FuncDef *functionSearch(
85163: FuncDefHash *pHash, /* Hash table to search */
85164: int h, /* Hash of the name */
85165: const char *zFunc, /* Name of function */
85166: int nFunc /* Number of bytes in zFunc */
85167: ){
85168: FuncDef *p;
85169: for(p=pHash->a[h]; p; p=p->pHash){
85170: if( sqlite3StrNICmp(p->zName, zFunc, nFunc)==0 && p->zName[nFunc]==0 ){
85171: return p;
85172: }
85173: }
85174: return 0;
85175: }
85176:
85177: /*
85178: ** Insert a new FuncDef into a FuncDefHash hash table.
85179: */
85180: SQLITE_PRIVATE void sqlite3FuncDefInsert(
85181: FuncDefHash *pHash, /* The hash table into which to insert */
85182: FuncDef *pDef /* The function definition to insert */
85183: ){
85184: FuncDef *pOther;
85185: int nName = sqlite3Strlen30(pDef->zName);
85186: u8 c1 = (u8)pDef->zName[0];
85187: int h = (sqlite3UpperToLower[c1] + nName) % ArraySize(pHash->a);
85188: pOther = functionSearch(pHash, h, pDef->zName, nName);
85189: if( pOther ){
85190: assert( pOther!=pDef && pOther->pNext!=pDef );
85191: pDef->pNext = pOther->pNext;
85192: pOther->pNext = pDef;
85193: }else{
85194: pDef->pNext = 0;
85195: pDef->pHash = pHash->a[h];
85196: pHash->a[h] = pDef;
85197: }
85198: }
85199:
85200:
85201:
85202: /*
85203: ** Locate a user function given a name, a number of arguments and a flag
85204: ** indicating whether the function prefers UTF-16 over UTF-8. Return a
85205: ** pointer to the FuncDef structure that defines that function, or return
85206: ** NULL if the function does not exist.
85207: **
85208: ** If the createFlag argument is true, then a new (blank) FuncDef
85209: ** structure is created and liked into the "db" structure if a
85210: ** no matching function previously existed. When createFlag is true
85211: ** and the nArg parameter is -1, then only a function that accepts
85212: ** any number of arguments will be returned.
85213: **
85214: ** If createFlag is false and nArg is -1, then the first valid
85215: ** function found is returned. A function is valid if either xFunc
85216: ** or xStep is non-zero.
85217: **
85218: ** If createFlag is false, then a function with the required name and
85219: ** number of arguments may be returned even if the eTextRep flag does not
85220: ** match that requested.
85221: */
85222: SQLITE_PRIVATE FuncDef *sqlite3FindFunction(
85223: sqlite3 *db, /* An open database */
85224: const char *zName, /* Name of the function. Not null-terminated */
85225: int nName, /* Number of characters in the name */
85226: int nArg, /* Number of arguments. -1 means any number */
85227: u8 enc, /* Preferred text encoding */
85228: int createFlag /* Create new entry if true and does not otherwise exist */
85229: ){
85230: FuncDef *p; /* Iterator variable */
85231: FuncDef *pBest = 0; /* Best match found so far */
85232: int bestScore = 0; /* Score of best match */
85233: int h; /* Hash value */
85234:
85235:
85236: assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
85237: h = (sqlite3UpperToLower[(u8)zName[0]] + nName) % ArraySize(db->aFunc.a);
85238:
85239: /* First search for a match amongst the application-defined functions.
85240: */
85241: p = functionSearch(&db->aFunc, h, zName, nName);
85242: while( p ){
85243: int score = matchQuality(p, nArg, enc);
85244: if( score>bestScore ){
85245: pBest = p;
85246: bestScore = score;
85247: }
85248: p = p->pNext;
85249: }
85250:
85251: /* If no match is found, search the built-in functions.
85252: **
85253: ** If the SQLITE_PreferBuiltin flag is set, then search the built-in
85254: ** functions even if a prior app-defined function was found. And give
85255: ** priority to built-in functions.
85256: **
85257: ** Except, if createFlag is true, that means that we are trying to
85258: ** install a new function. Whatever FuncDef structure is returned it will
85259: ** have fields overwritten with new information appropriate for the
85260: ** new function. But the FuncDefs for built-in functions are read-only.
85261: ** So we must not search for built-ins when creating a new function.
85262: */
85263: if( !createFlag && (pBest==0 || (db->flags & SQLITE_PreferBuiltin)!=0) ){
85264: FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
85265: bestScore = 0;
85266: p = functionSearch(pHash, h, zName, nName);
85267: while( p ){
85268: int score = matchQuality(p, nArg, enc);
85269: if( score>bestScore ){
85270: pBest = p;
85271: bestScore = score;
85272: }
85273: p = p->pNext;
85274: }
85275: }
85276:
85277: /* If the createFlag parameter is true and the search did not reveal an
85278: ** exact match for the name, number of arguments and encoding, then add a
85279: ** new entry to the hash table and return it.
85280: */
85281: if( createFlag && (bestScore<6 || pBest->nArg!=nArg) &&
85282: (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
85283: pBest->zName = (char *)&pBest[1];
85284: pBest->nArg = (u16)nArg;
85285: pBest->iPrefEnc = enc;
85286: memcpy(pBest->zName, zName, nName);
85287: pBest->zName[nName] = 0;
85288: sqlite3FuncDefInsert(&db->aFunc, pBest);
85289: }
85290:
85291: if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){
85292: return pBest;
85293: }
85294: return 0;
85295: }
85296:
85297: /*
85298: ** Free all resources held by the schema structure. The void* argument points
85299: ** at a Schema struct. This function does not call sqlite3DbFree(db, ) on the
85300: ** pointer itself, it just cleans up subsidiary resources (i.e. the contents
85301: ** of the schema hash tables).
85302: **
85303: ** The Schema.cache_size variable is not cleared.
85304: */
85305: SQLITE_PRIVATE void sqlite3SchemaClear(void *p){
85306: Hash temp1;
85307: Hash temp2;
85308: HashElem *pElem;
85309: Schema *pSchema = (Schema *)p;
85310:
85311: temp1 = pSchema->tblHash;
85312: temp2 = pSchema->trigHash;
85313: sqlite3HashInit(&pSchema->trigHash);
85314: sqlite3HashClear(&pSchema->idxHash);
85315: for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){
85316: sqlite3DeleteTrigger(0, (Trigger*)sqliteHashData(pElem));
85317: }
85318: sqlite3HashClear(&temp2);
85319: sqlite3HashInit(&pSchema->tblHash);
85320: for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){
85321: Table *pTab = sqliteHashData(pElem);
85322: sqlite3DeleteTable(0, pTab);
85323: }
85324: sqlite3HashClear(&temp1);
85325: sqlite3HashClear(&pSchema->fkeyHash);
85326: pSchema->pSeqTab = 0;
85327: if( pSchema->flags & DB_SchemaLoaded ){
85328: pSchema->iGeneration++;
85329: pSchema->flags &= ~DB_SchemaLoaded;
85330: }
85331: }
85332:
85333: /*
85334: ** Find and return the schema associated with a BTree. Create
85335: ** a new one if necessary.
85336: */
85337: SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
85338: Schema * p;
85339: if( pBt ){
85340: p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaClear);
85341: }else{
85342: p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
85343: }
85344: if( !p ){
85345: db->mallocFailed = 1;
85346: }else if ( 0==p->file_format ){
85347: sqlite3HashInit(&p->tblHash);
85348: sqlite3HashInit(&p->idxHash);
85349: sqlite3HashInit(&p->trigHash);
85350: sqlite3HashInit(&p->fkeyHash);
85351: p->enc = SQLITE_UTF8;
85352: }
85353: return p;
85354: }
85355:
85356: /************** End of callback.c ********************************************/
85357: /************** Begin file delete.c ******************************************/
85358: /*
85359: ** 2001 September 15
85360: **
85361: ** The author disclaims copyright to this source code. In place of
85362: ** a legal notice, here is a blessing:
85363: **
85364: ** May you do good and not evil.
85365: ** May you find forgiveness for yourself and forgive others.
85366: ** May you share freely, never taking more than you give.
85367: **
85368: *************************************************************************
85369: ** This file contains C code routines that are called by the parser
85370: ** in order to generate code for DELETE FROM statements.
85371: */
85372:
85373: /*
85374: ** While a SrcList can in general represent multiple tables and subqueries
85375: ** (as in the FROM clause of a SELECT statement) in this case it contains
85376: ** the name of a single table, as one might find in an INSERT, DELETE,
85377: ** or UPDATE statement. Look up that table in the symbol table and
85378: ** return a pointer. Set an error message and return NULL if the table
85379: ** name is not found or if any other error occurs.
85380: **
85381: ** The following fields are initialized appropriate in pSrc:
85382: **
85383: ** pSrc->a[0].pTab Pointer to the Table object
85384: ** pSrc->a[0].pIndex Pointer to the INDEXED BY index, if there is one
85385: **
85386: */
85387: SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
85388: struct SrcList_item *pItem = pSrc->a;
85389: Table *pTab;
85390: assert( pItem && pSrc->nSrc==1 );
85391: pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
85392: sqlite3DeleteTable(pParse->db, pItem->pTab);
85393: pItem->pTab = pTab;
85394: if( pTab ){
85395: pTab->nRef++;
85396: }
85397: if( sqlite3IndexedByLookup(pParse, pItem) ){
85398: pTab = 0;
85399: }
85400: return pTab;
85401: }
85402:
85403: /*
85404: ** Check to make sure the given table is writable. If it is not
85405: ** writable, generate an error message and return 1. If it is
85406: ** writable return 0;
85407: */
85408: SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
85409: /* A table is not writable under the following circumstances:
85410: **
85411: ** 1) It is a virtual table and no implementation of the xUpdate method
85412: ** has been provided, or
85413: ** 2) It is a system table (i.e. sqlite_master), this call is not
85414: ** part of a nested parse and writable_schema pragma has not
85415: ** been specified.
85416: **
85417: ** In either case leave an error message in pParse and return non-zero.
85418: */
85419: if( ( IsVirtual(pTab)
85420: && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 )
85421: || ( (pTab->tabFlags & TF_Readonly)!=0
85422: && (pParse->db->flags & SQLITE_WriteSchema)==0
85423: && pParse->nested==0 )
85424: ){
85425: sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
85426: return 1;
85427: }
85428:
85429: #ifndef SQLITE_OMIT_VIEW
85430: if( !viewOk && pTab->pSelect ){
85431: sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
85432: return 1;
85433: }
85434: #endif
85435: return 0;
85436: }
85437:
85438:
85439: #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
85440: /*
85441: ** Evaluate a view and store its result in an ephemeral table. The
85442: ** pWhere argument is an optional WHERE clause that restricts the
85443: ** set of rows in the view that are to be added to the ephemeral table.
85444: */
85445: SQLITE_PRIVATE void sqlite3MaterializeView(
85446: Parse *pParse, /* Parsing context */
85447: Table *pView, /* View definition */
85448: Expr *pWhere, /* Optional WHERE clause to be added */
85449: int iCur /* Cursor number for ephemerial table */
85450: ){
85451: SelectDest dest;
85452: Select *pDup;
85453: sqlite3 *db = pParse->db;
85454:
85455: pDup = sqlite3SelectDup(db, pView->pSelect, 0);
85456: if( pWhere ){
85457: SrcList *pFrom;
85458:
85459: pWhere = sqlite3ExprDup(db, pWhere, 0);
85460: pFrom = sqlite3SrcListAppend(db, 0, 0, 0);
85461: if( pFrom ){
85462: assert( pFrom->nSrc==1 );
85463: pFrom->a[0].zAlias = sqlite3DbStrDup(db, pView->zName);
85464: pFrom->a[0].pSelect = pDup;
85465: assert( pFrom->a[0].pOn==0 );
85466: assert( pFrom->a[0].pUsing==0 );
85467: }else{
85468: sqlite3SelectDelete(db, pDup);
85469: }
85470: pDup = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);
85471: }
85472: sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
85473: sqlite3Select(pParse, pDup, &dest);
85474: sqlite3SelectDelete(db, pDup);
85475: }
85476: #endif /* !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) */
85477:
85478: #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY)
85479: /*
85480: ** Generate an expression tree to implement the WHERE, ORDER BY,
85481: ** and LIMIT/OFFSET portion of DELETE and UPDATE statements.
85482: **
85483: ** DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;
85484: ** \__________________________/
85485: ** pLimitWhere (pInClause)
85486: */
85487: SQLITE_PRIVATE Expr *sqlite3LimitWhere(
85488: Parse *pParse, /* The parser context */
85489: SrcList *pSrc, /* the FROM clause -- which tables to scan */
85490: Expr *pWhere, /* The WHERE clause. May be null */
85491: ExprList *pOrderBy, /* The ORDER BY clause. May be null */
85492: Expr *pLimit, /* The LIMIT clause. May be null */
85493: Expr *pOffset, /* The OFFSET clause. May be null */
85494: char *zStmtType /* Either DELETE or UPDATE. For error messages. */
85495: ){
85496: Expr *pWhereRowid = NULL; /* WHERE rowid .. */
85497: Expr *pInClause = NULL; /* WHERE rowid IN ( select ) */
85498: Expr *pSelectRowid = NULL; /* SELECT rowid ... */
85499: ExprList *pEList = NULL; /* Expression list contaning only pSelectRowid */
85500: SrcList *pSelectSrc = NULL; /* SELECT rowid FROM x ... (dup of pSrc) */
85501: Select *pSelect = NULL; /* Complete SELECT tree */
85502:
85503: /* Check that there isn't an ORDER BY without a LIMIT clause.
85504: */
85505: if( pOrderBy && (pLimit == 0) ) {
85506: sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);
85507: goto limit_where_cleanup_2;
85508: }
85509:
85510: /* We only need to generate a select expression if there
85511: ** is a limit/offset term to enforce.
85512: */
85513: if( pLimit == 0 ) {
85514: /* if pLimit is null, pOffset will always be null as well. */
85515: assert( pOffset == 0 );
85516: return pWhere;
85517: }
85518:
85519: /* Generate a select expression tree to enforce the limit/offset
85520: ** term for the DELETE or UPDATE statement. For example:
85521: ** DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
85522: ** becomes:
85523: ** DELETE FROM table_a WHERE rowid IN (
85524: ** SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
85525: ** );
85526: */
85527:
85528: pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
85529: if( pSelectRowid == 0 ) goto limit_where_cleanup_2;
85530: pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid);
85531: if( pEList == 0 ) goto limit_where_cleanup_2;
85532:
85533: /* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
85534: ** and the SELECT subtree. */
85535: pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);
85536: if( pSelectSrc == 0 ) {
85537: sqlite3ExprListDelete(pParse->db, pEList);
85538: goto limit_where_cleanup_2;
85539: }
85540:
85541: /* generate the SELECT expression tree. */
85542: pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0,
85543: pOrderBy,0,pLimit,pOffset);
85544: if( pSelect == 0 ) return 0;
85545:
85546: /* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
85547: pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
85548: if( pWhereRowid == 0 ) goto limit_where_cleanup_1;
85549: pInClause = sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0);
85550: if( pInClause == 0 ) goto limit_where_cleanup_1;
85551:
85552: pInClause->x.pSelect = pSelect;
85553: pInClause->flags |= EP_xIsSelect;
85554: sqlite3ExprSetHeight(pParse, pInClause);
85555: return pInClause;
85556:
85557: /* something went wrong. clean up anything allocated. */
85558: limit_where_cleanup_1:
85559: sqlite3SelectDelete(pParse->db, pSelect);
85560: return 0;
85561:
85562: limit_where_cleanup_2:
85563: sqlite3ExprDelete(pParse->db, pWhere);
85564: sqlite3ExprListDelete(pParse->db, pOrderBy);
85565: sqlite3ExprDelete(pParse->db, pLimit);
85566: sqlite3ExprDelete(pParse->db, pOffset);
85567: return 0;
85568: }
85569: #endif /* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
85570:
85571: /*
85572: ** Generate code for a DELETE FROM statement.
85573: **
85574: ** DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
85575: ** \________/ \________________/
85576: ** pTabList pWhere
85577: */
85578: SQLITE_PRIVATE void sqlite3DeleteFrom(
85579: Parse *pParse, /* The parser context */
85580: SrcList *pTabList, /* The table from which we should delete things */
85581: Expr *pWhere /* The WHERE clause. May be null */
85582: ){
85583: Vdbe *v; /* The virtual database engine */
85584: Table *pTab; /* The table from which records will be deleted */
85585: const char *zDb; /* Name of database holding pTab */
85586: int end, addr = 0; /* A couple addresses of generated code */
85587: int i; /* Loop counter */
85588: WhereInfo *pWInfo; /* Information about the WHERE clause */
85589: Index *pIdx; /* For looping over indices of the table */
85590: int iCur; /* VDBE Cursor number for pTab */
85591: sqlite3 *db; /* Main database structure */
85592: AuthContext sContext; /* Authorization context */
85593: NameContext sNC; /* Name context to resolve expressions in */
85594: int iDb; /* Database number */
85595: int memCnt = -1; /* Memory cell used for change counting */
85596: int rcauth; /* Value returned by authorization callback */
85597:
85598: #ifndef SQLITE_OMIT_TRIGGER
85599: int isView; /* True if attempting to delete from a view */
85600: Trigger *pTrigger; /* List of table triggers, if required */
85601: #endif
85602:
85603: memset(&sContext, 0, sizeof(sContext));
85604: db = pParse->db;
85605: if( pParse->nErr || db->mallocFailed ){
85606: goto delete_from_cleanup;
85607: }
85608: assert( pTabList->nSrc==1 );
85609:
85610: /* Locate the table which we want to delete. This table has to be
85611: ** put in an SrcList structure because some of the subroutines we
85612: ** will be calling are designed to work with multiple tables and expect
85613: ** an SrcList* parameter instead of just a Table* parameter.
85614: */
85615: pTab = sqlite3SrcListLookup(pParse, pTabList);
85616: if( pTab==0 ) goto delete_from_cleanup;
85617:
85618: /* Figure out if we have any triggers and if the table being
85619: ** deleted from is a view
85620: */
85621: #ifndef SQLITE_OMIT_TRIGGER
85622: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
85623: isView = pTab->pSelect!=0;
85624: #else
85625: # define pTrigger 0
85626: # define isView 0
85627: #endif
85628: #ifdef SQLITE_OMIT_VIEW
85629: # undef isView
85630: # define isView 0
85631: #endif
85632:
85633: /* If pTab is really a view, make sure it has been initialized.
85634: */
85635: if( sqlite3ViewGetColumnNames(pParse, pTab) ){
85636: goto delete_from_cleanup;
85637: }
85638:
85639: if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
85640: goto delete_from_cleanup;
85641: }
85642: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
85643: assert( iDb<db->nDb );
85644: zDb = db->aDb[iDb].zName;
85645: rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
85646: assert( rcauth==SQLITE_OK || rcauth==SQLITE_DENY || rcauth==SQLITE_IGNORE );
85647: if( rcauth==SQLITE_DENY ){
85648: goto delete_from_cleanup;
85649: }
85650: assert(!isView || pTrigger);
85651:
85652: /* Assign cursor number to the table and all its indices.
85653: */
85654: assert( pTabList->nSrc==1 );
85655: iCur = pTabList->a[0].iCursor = pParse->nTab++;
85656: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85657: pParse->nTab++;
85658: }
85659:
85660: /* Start the view context
85661: */
85662: if( isView ){
85663: sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
85664: }
85665:
85666: /* Begin generating code.
85667: */
85668: v = sqlite3GetVdbe(pParse);
85669: if( v==0 ){
85670: goto delete_from_cleanup;
85671: }
85672: if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
85673: sqlite3BeginWriteOperation(pParse, 1, iDb);
85674:
85675: /* If we are trying to delete from a view, realize that view into
85676: ** a ephemeral table.
85677: */
85678: #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
85679: if( isView ){
85680: sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
85681: }
85682: #endif
85683:
85684: /* Resolve the column names in the WHERE clause.
85685: */
85686: memset(&sNC, 0, sizeof(sNC));
85687: sNC.pParse = pParse;
85688: sNC.pSrcList = pTabList;
85689: if( sqlite3ResolveExprNames(&sNC, pWhere) ){
85690: goto delete_from_cleanup;
85691: }
85692:
85693: /* Initialize the counter of the number of rows deleted, if
85694: ** we are counting rows.
85695: */
85696: if( db->flags & SQLITE_CountRows ){
85697: memCnt = ++pParse->nMem;
85698: sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
85699: }
85700:
85701: #ifndef SQLITE_OMIT_TRUNCATE_OPTIMIZATION
85702: /* Special case: A DELETE without a WHERE clause deletes everything.
85703: ** It is easier just to erase the whole table. Prior to version 3.6.5,
85704: ** this optimization caused the row change count (the value returned by
85705: ** API function sqlite3_count_changes) to be set incorrectly. */
85706: if( rcauth==SQLITE_OK && pWhere==0 && !pTrigger && !IsVirtual(pTab)
85707: && 0==sqlite3FkRequired(pParse, pTab, 0, 0)
85708: ){
85709: assert( !isView );
85710: sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt,
85711: pTab->zName, P4_STATIC);
85712: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
85713: assert( pIdx->pSchema==pTab->pSchema );
85714: sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
85715: }
85716: }else
85717: #endif /* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
85718: /* The usual case: There is a WHERE clause so we have to scan through
85719: ** the table and pick which records to delete.
85720: */
85721: {
85722: int iRowSet = ++pParse->nMem; /* Register for rowset of rows to delete */
85723: int iRowid = ++pParse->nMem; /* Used for storing rowid values. */
85724: int regRowid; /* Actual register containing rowids */
85725:
85726: /* Collect rowids of every row to be deleted.
85727: */
85728: sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);
85729: pWInfo = sqlite3WhereBegin(
85730: pParse, pTabList, pWhere, 0, 0, WHERE_DUPLICATES_OK
85731: );
85732: if( pWInfo==0 ) goto delete_from_cleanup;
85733: regRowid = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, iRowid);
85734: sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, regRowid);
85735: if( db->flags & SQLITE_CountRows ){
85736: sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
85737: }
85738: sqlite3WhereEnd(pWInfo);
85739:
85740: /* Delete every item whose key was written to the list during the
85741: ** database scan. We have to delete items after the scan is complete
85742: ** because deleting an item can change the scan order. */
85743: end = sqlite3VdbeMakeLabel(v);
85744:
85745: /* Unless this is a view, open cursors for the table we are
85746: ** deleting from and all its indices. If this is a view, then the
85747: ** only effect this statement has is to fire the INSTEAD OF
85748: ** triggers. */
85749: if( !isView ){
85750: sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
85751: }
85752:
85753: addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, end, iRowid);
85754:
85755: /* Delete the row */
85756: #ifndef SQLITE_OMIT_VIRTUALTABLE
85757: if( IsVirtual(pTab) ){
85758: const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
85759: sqlite3VtabMakeWritable(pParse, pTab);
85760: sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVTab, P4_VTAB);
85761: sqlite3VdbeChangeP5(v, OE_Abort);
85762: sqlite3MayAbort(pParse);
85763: }else
85764: #endif
85765: {
85766: int count = (pParse->nested==0); /* True to count changes */
85767: sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default);
85768: }
85769:
85770: /* End of the delete loop */
85771: sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
85772: sqlite3VdbeResolveLabel(v, end);
85773:
85774: /* Close the cursors open on the table and its indexes. */
85775: if( !isView && !IsVirtual(pTab) ){
85776: for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
85777: sqlite3VdbeAddOp2(v, OP_Close, iCur + i, pIdx->tnum);
85778: }
85779: sqlite3VdbeAddOp1(v, OP_Close, iCur);
85780: }
85781: }
85782:
85783: /* Update the sqlite_sequence table by storing the content of the
85784: ** maximum rowid counter values recorded while inserting into
85785: ** autoincrement tables.
85786: */
85787: if( pParse->nested==0 && pParse->pTriggerTab==0 ){
85788: sqlite3AutoincrementEnd(pParse);
85789: }
85790:
85791: /* Return the number of rows that were deleted. If this routine is
85792: ** generating code because of a call to sqlite3NestedParse(), do not
85793: ** invoke the callback function.
85794: */
85795: if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
85796: sqlite3VdbeAddOp2(v, OP_ResultRow, memCnt, 1);
85797: sqlite3VdbeSetNumCols(v, 1);
85798: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC);
85799: }
85800:
85801: delete_from_cleanup:
85802: sqlite3AuthContextPop(&sContext);
85803: sqlite3SrcListDelete(db, pTabList);
85804: sqlite3ExprDelete(db, pWhere);
85805: return;
85806: }
85807: /* Make sure "isView" and other macros defined above are undefined. Otherwise
85808: ** thely may interfere with compilation of other functions in this file
85809: ** (or in another file, if this file becomes part of the amalgamation). */
85810: #ifdef isView
85811: #undef isView
85812: #endif
85813: #ifdef pTrigger
85814: #undef pTrigger
85815: #endif
85816:
85817: /*
85818: ** This routine generates VDBE code that causes a single row of a
85819: ** single table to be deleted.
85820: **
85821: ** The VDBE must be in a particular state when this routine is called.
85822: ** These are the requirements:
85823: **
85824: ** 1. A read/write cursor pointing to pTab, the table containing the row
85825: ** to be deleted, must be opened as cursor number $iCur.
85826: **
85827: ** 2. Read/write cursors for all indices of pTab must be open as
85828: ** cursor number base+i for the i-th index.
85829: **
85830: ** 3. The record number of the row to be deleted must be stored in
85831: ** memory cell iRowid.
85832: **
85833: ** This routine generates code to remove both the table record and all
85834: ** index entries that point to that record.
85835: */
85836: SQLITE_PRIVATE void sqlite3GenerateRowDelete(
85837: Parse *pParse, /* Parsing context */
85838: Table *pTab, /* Table containing the row to be deleted */
85839: int iCur, /* Cursor number for the table */
85840: int iRowid, /* Memory cell that contains the rowid to delete */
85841: int count, /* If non-zero, increment the row change counter */
85842: Trigger *pTrigger, /* List of triggers to (potentially) fire */
85843: int onconf /* Default ON CONFLICT policy for triggers */
85844: ){
85845: Vdbe *v = pParse->pVdbe; /* Vdbe */
85846: int iOld = 0; /* First register in OLD.* array */
85847: int iLabel; /* Label resolved to end of generated code */
85848:
85849: /* Vdbe is guaranteed to have been allocated by this stage. */
85850: assert( v );
85851:
85852: /* Seek cursor iCur to the row to delete. If this row no longer exists
85853: ** (this can happen if a trigger program has already deleted it), do
85854: ** not attempt to delete it or fire any DELETE triggers. */
85855: iLabel = sqlite3VdbeMakeLabel(v);
85856: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
85857:
85858: /* If there are any triggers to fire, allocate a range of registers to
85859: ** use for the old.* references in the triggers. */
85860: if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
85861: u32 mask; /* Mask of OLD.* columns in use */
85862: int iCol; /* Iterator used while populating OLD.* */
85863:
85864: /* TODO: Could use temporary registers here. Also could attempt to
85865: ** avoid copying the contents of the rowid register. */
85866: mask = sqlite3TriggerColmask(
85867: pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
85868: );
85869: mask |= sqlite3FkOldmask(pParse, pTab);
85870: iOld = pParse->nMem+1;
85871: pParse->nMem += (1 + pTab->nCol);
85872:
85873: /* Populate the OLD.* pseudo-table register array. These values will be
85874: ** used by any BEFORE and AFTER triggers that exist. */
85875: sqlite3VdbeAddOp2(v, OP_Copy, iRowid, iOld);
85876: for(iCol=0; iCol<pTab->nCol; iCol++){
85877: if( mask==0xffffffff || mask&(1<<iCol) ){
85878: sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol, iOld+iCol+1);
85879: }
85880: }
85881:
85882: /* Invoke BEFORE DELETE trigger programs. */
85883: sqlite3CodeRowTrigger(pParse, pTrigger,
85884: TK_DELETE, 0, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
85885: );
85886:
85887: /* Seek the cursor to the row to be deleted again. It may be that
85888: ** the BEFORE triggers coded above have already removed the row
85889: ** being deleted. Do not attempt to delete the row a second time, and
85890: ** do not fire AFTER triggers. */
85891: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, iLabel, iRowid);
85892:
85893: /* Do FK processing. This call checks that any FK constraints that
85894: ** refer to this table (i.e. constraints attached to other tables)
85895: ** are not violated by deleting this row. */
85896: sqlite3FkCheck(pParse, pTab, iOld, 0);
85897: }
85898:
85899: /* Delete the index and table entries. Skip this step if pTab is really
85900: ** a view (in which case the only effect of the DELETE statement is to
85901: ** fire the INSTEAD OF triggers). */
85902: if( pTab->pSelect==0 ){
85903: sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);
85904: sqlite3VdbeAddOp2(v, OP_Delete, iCur, (count?OPFLAG_NCHANGE:0));
85905: if( count ){
85906: sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
85907: }
85908: }
85909:
85910: /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
85911: ** handle rows (possibly in other tables) that refer via a foreign key
85912: ** to the row just deleted. */
85913: sqlite3FkActions(pParse, pTab, 0, iOld);
85914:
85915: /* Invoke AFTER DELETE trigger programs. */
85916: sqlite3CodeRowTrigger(pParse, pTrigger,
85917: TK_DELETE, 0, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
85918: );
85919:
85920: /* Jump here if the row had already been deleted before any BEFORE
85921: ** trigger programs were invoked. Or if a trigger program throws a
85922: ** RAISE(IGNORE) exception. */
85923: sqlite3VdbeResolveLabel(v, iLabel);
85924: }
85925:
85926: /*
85927: ** This routine generates VDBE code that causes the deletion of all
85928: ** index entries associated with a single row of a single table.
85929: **
85930: ** The VDBE must be in a particular state when this routine is called.
85931: ** These are the requirements:
85932: **
85933: ** 1. A read/write cursor pointing to pTab, the table containing the row
85934: ** to be deleted, must be opened as cursor number "iCur".
85935: **
85936: ** 2. Read/write cursors for all indices of pTab must be open as
85937: ** cursor number iCur+i for the i-th index.
85938: **
85939: ** 3. The "iCur" cursor must be pointing to the row that is to be
85940: ** deleted.
85941: */
85942: SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(
85943: Parse *pParse, /* Parsing and code generating context */
85944: Table *pTab, /* Table containing the row to be deleted */
85945: int iCur, /* Cursor number for the table */
85946: int *aRegIdx /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
85947: ){
85948: int i;
85949: Index *pIdx;
85950: int r1;
85951:
85952: for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
85953: if( aRegIdx!=0 && aRegIdx[i-1]==0 ) continue;
85954: r1 = sqlite3GenerateIndexKey(pParse, pIdx, iCur, 0, 0);
85955: sqlite3VdbeAddOp3(pParse->pVdbe, OP_IdxDelete, iCur+i, r1,pIdx->nColumn+1);
85956: }
85957: }
85958:
85959: /*
85960: ** Generate code that will assemble an index key and put it in register
85961: ** regOut. The key with be for index pIdx which is an index on pTab.
85962: ** iCur is the index of a cursor open on the pTab table and pointing to
85963: ** the entry that needs indexing.
85964: **
85965: ** Return a register number which is the first in a block of
85966: ** registers that holds the elements of the index key. The
85967: ** block of registers has already been deallocated by the time
85968: ** this routine returns.
85969: */
85970: SQLITE_PRIVATE int sqlite3GenerateIndexKey(
85971: Parse *pParse, /* Parsing context */
85972: Index *pIdx, /* The index for which to generate a key */
85973: int iCur, /* Cursor number for the pIdx->pTable table */
85974: int regOut, /* Write the new index key to this register */
85975: int doMakeRec /* Run the OP_MakeRecord instruction if true */
85976: ){
85977: Vdbe *v = pParse->pVdbe;
85978: int j;
85979: Table *pTab = pIdx->pTable;
85980: int regBase;
85981: int nCol;
85982:
85983: nCol = pIdx->nColumn;
85984: regBase = sqlite3GetTempRange(pParse, nCol+1);
85985: sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regBase+nCol);
85986: for(j=0; j<nCol; j++){
85987: int idx = pIdx->aiColumn[j];
85988: if( idx==pTab->iPKey ){
85989: sqlite3VdbeAddOp2(v, OP_SCopy, regBase+nCol, regBase+j);
85990: }else{
85991: sqlite3VdbeAddOp3(v, OP_Column, iCur, idx, regBase+j);
85992: sqlite3ColumnDefault(v, pTab, idx, -1);
85993: }
85994: }
85995: if( doMakeRec ){
85996: const char *zAff;
85997: if( pTab->pSelect || (pParse->db->flags & SQLITE_IdxRealAsInt)!=0 ){
85998: zAff = 0;
85999: }else{
86000: zAff = sqlite3IndexAffinityStr(v, pIdx);
86001: }
86002: sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol+1, regOut);
86003: sqlite3VdbeChangeP4(v, -1, zAff, P4_TRANSIENT);
86004: }
86005: sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
86006: return regBase;
86007: }
86008:
86009: /************** End of delete.c **********************************************/
86010: /************** Begin file func.c ********************************************/
86011: /*
86012: ** 2002 February 23
86013: **
86014: ** The author disclaims copyright to this source code. In place of
86015: ** a legal notice, here is a blessing:
86016: **
86017: ** May you do good and not evil.
86018: ** May you find forgiveness for yourself and forgive others.
86019: ** May you share freely, never taking more than you give.
86020: **
86021: *************************************************************************
86022: ** This file contains the C functions that implement various SQL
86023: ** functions of SQLite.
86024: **
86025: ** There is only one exported symbol in this file - the function
86026: ** sqliteRegisterBuildinFunctions() found at the bottom of the file.
86027: ** All other code has file scope.
86028: */
86029: /* #include <stdlib.h> */
86030: /* #include <assert.h> */
86031:
86032: /*
86033: ** Return the collating function associated with a function.
86034: */
86035: static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
86036: return context->pColl;
86037: }
86038:
86039: /*
86040: ** Implementation of the non-aggregate min() and max() functions
86041: */
86042: static void minmaxFunc(
86043: sqlite3_context *context,
86044: int argc,
86045: sqlite3_value **argv
86046: ){
86047: int i;
86048: int mask; /* 0 for min() or 0xffffffff for max() */
86049: int iBest;
86050: CollSeq *pColl;
86051:
86052: assert( argc>1 );
86053: mask = sqlite3_user_data(context)==0 ? 0 : -1;
86054: pColl = sqlite3GetFuncCollSeq(context);
86055: assert( pColl );
86056: assert( mask==-1 || mask==0 );
86057: iBest = 0;
86058: if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
86059: for(i=1; i<argc; i++){
86060: if( sqlite3_value_type(argv[i])==SQLITE_NULL ) return;
86061: if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
86062: testcase( mask==0 );
86063: iBest = i;
86064: }
86065: }
86066: sqlite3_result_value(context, argv[iBest]);
86067: }
86068:
86069: /*
86070: ** Return the type of the argument.
86071: */
86072: static void typeofFunc(
86073: sqlite3_context *context,
86074: int NotUsed,
86075: sqlite3_value **argv
86076: ){
86077: const char *z = 0;
86078: UNUSED_PARAMETER(NotUsed);
86079: switch( sqlite3_value_type(argv[0]) ){
86080: case SQLITE_INTEGER: z = "integer"; break;
86081: case SQLITE_TEXT: z = "text"; break;
86082: case SQLITE_FLOAT: z = "real"; break;
86083: case SQLITE_BLOB: z = "blob"; break;
86084: default: z = "null"; break;
86085: }
86086: sqlite3_result_text(context, z, -1, SQLITE_STATIC);
86087: }
86088:
86089:
86090: /*
86091: ** Implementation of the length() function
86092: */
86093: static void lengthFunc(
86094: sqlite3_context *context,
86095: int argc,
86096: sqlite3_value **argv
86097: ){
86098: int len;
86099:
86100: assert( argc==1 );
86101: UNUSED_PARAMETER(argc);
86102: switch( sqlite3_value_type(argv[0]) ){
86103: case SQLITE_BLOB:
86104: case SQLITE_INTEGER:
86105: case SQLITE_FLOAT: {
86106: sqlite3_result_int(context, sqlite3_value_bytes(argv[0]));
86107: break;
86108: }
86109: case SQLITE_TEXT: {
86110: const unsigned char *z = sqlite3_value_text(argv[0]);
86111: if( z==0 ) return;
86112: len = 0;
86113: while( *z ){
86114: len++;
86115: SQLITE_SKIP_UTF8(z);
86116: }
86117: sqlite3_result_int(context, len);
86118: break;
86119: }
86120: default: {
86121: sqlite3_result_null(context);
86122: break;
86123: }
86124: }
86125: }
86126:
86127: /*
86128: ** Implementation of the abs() function.
86129: **
86130: ** IMP: R-23979-26855 The abs(X) function returns the absolute value of
86131: ** the numeric argument X.
86132: */
86133: static void absFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
86134: assert( argc==1 );
86135: UNUSED_PARAMETER(argc);
86136: switch( sqlite3_value_type(argv[0]) ){
86137: case SQLITE_INTEGER: {
86138: i64 iVal = sqlite3_value_int64(argv[0]);
86139: if( iVal<0 ){
86140: if( (iVal<<1)==0 ){
86141: /* IMP: R-35460-15084 If X is the integer -9223372036854775807 then
86142: ** abs(X) throws an integer overflow error since there is no
86143: ** equivalent positive 64-bit two complement value. */
86144: sqlite3_result_error(context, "integer overflow", -1);
86145: return;
86146: }
86147: iVal = -iVal;
86148: }
86149: sqlite3_result_int64(context, iVal);
86150: break;
86151: }
86152: case SQLITE_NULL: {
86153: /* IMP: R-37434-19929 Abs(X) returns NULL if X is NULL. */
86154: sqlite3_result_null(context);
86155: break;
86156: }
86157: default: {
86158: /* Because sqlite3_value_double() returns 0.0 if the argument is not
86159: ** something that can be converted into a number, we have:
86160: ** IMP: R-57326-31541 Abs(X) return 0.0 if X is a string or blob that
86161: ** cannot be converted to a numeric value.
86162: */
86163: double rVal = sqlite3_value_double(argv[0]);
86164: if( rVal<0 ) rVal = -rVal;
86165: sqlite3_result_double(context, rVal);
86166: break;
86167: }
86168: }
86169: }
86170:
86171: /*
86172: ** Implementation of the substr() function.
86173: **
86174: ** substr(x,p1,p2) returns p2 characters of x[] beginning with p1.
86175: ** p1 is 1-indexed. So substr(x,1,1) returns the first character
86176: ** of x. If x is text, then we actually count UTF-8 characters.
86177: ** If x is a blob, then we count bytes.
86178: **
86179: ** If p1 is negative, then we begin abs(p1) from the end of x[].
86180: **
86181: ** If p2 is negative, return the p2 characters preceeding p1.
86182: */
86183: static void substrFunc(
86184: sqlite3_context *context,
86185: int argc,
86186: sqlite3_value **argv
86187: ){
86188: const unsigned char *z;
86189: const unsigned char *z2;
86190: int len;
86191: int p0type;
86192: i64 p1, p2;
86193: int negP2 = 0;
86194:
86195: assert( argc==3 || argc==2 );
86196: if( sqlite3_value_type(argv[1])==SQLITE_NULL
86197: || (argc==3 && sqlite3_value_type(argv[2])==SQLITE_NULL)
86198: ){
86199: return;
86200: }
86201: p0type = sqlite3_value_type(argv[0]);
86202: p1 = sqlite3_value_int(argv[1]);
86203: if( p0type==SQLITE_BLOB ){
86204: len = sqlite3_value_bytes(argv[0]);
86205: z = sqlite3_value_blob(argv[0]);
86206: if( z==0 ) return;
86207: assert( len==sqlite3_value_bytes(argv[0]) );
86208: }else{
86209: z = sqlite3_value_text(argv[0]);
86210: if( z==0 ) return;
86211: len = 0;
86212: if( p1<0 ){
86213: for(z2=z; *z2; len++){
86214: SQLITE_SKIP_UTF8(z2);
86215: }
86216: }
86217: }
86218: if( argc==3 ){
86219: p2 = sqlite3_value_int(argv[2]);
86220: if( p2<0 ){
86221: p2 = -p2;
86222: negP2 = 1;
86223: }
86224: }else{
86225: p2 = sqlite3_context_db_handle(context)->aLimit[SQLITE_LIMIT_LENGTH];
86226: }
86227: if( p1<0 ){
86228: p1 += len;
86229: if( p1<0 ){
86230: p2 += p1;
86231: if( p2<0 ) p2 = 0;
86232: p1 = 0;
86233: }
86234: }else if( p1>0 ){
86235: p1--;
86236: }else if( p2>0 ){
86237: p2--;
86238: }
86239: if( negP2 ){
86240: p1 -= p2;
86241: if( p1<0 ){
86242: p2 += p1;
86243: p1 = 0;
86244: }
86245: }
86246: assert( p1>=0 && p2>=0 );
86247: if( p0type!=SQLITE_BLOB ){
86248: while( *z && p1 ){
86249: SQLITE_SKIP_UTF8(z);
86250: p1--;
86251: }
86252: for(z2=z; *z2 && p2; p2--){
86253: SQLITE_SKIP_UTF8(z2);
86254: }
86255: sqlite3_result_text(context, (char*)z, (int)(z2-z), SQLITE_TRANSIENT);
86256: }else{
86257: if( p1+p2>len ){
86258: p2 = len-p1;
86259: if( p2<0 ) p2 = 0;
86260: }
86261: sqlite3_result_blob(context, (char*)&z[p1], (int)p2, SQLITE_TRANSIENT);
86262: }
86263: }
86264:
86265: /*
86266: ** Implementation of the round() function
86267: */
86268: #ifndef SQLITE_OMIT_FLOATING_POINT
86269: static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
86270: int n = 0;
86271: double r;
86272: char *zBuf;
86273: assert( argc==1 || argc==2 );
86274: if( argc==2 ){
86275: if( SQLITE_NULL==sqlite3_value_type(argv[1]) ) return;
86276: n = sqlite3_value_int(argv[1]);
86277: if( n>30 ) n = 30;
86278: if( n<0 ) n = 0;
86279: }
86280: if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
86281: r = sqlite3_value_double(argv[0]);
86282: /* If Y==0 and X will fit in a 64-bit int,
86283: ** handle the rounding directly,
86284: ** otherwise use printf.
86285: */
86286: if( n==0 && r>=0 && r<LARGEST_INT64-1 ){
86287: r = (double)((sqlite_int64)(r+0.5));
86288: }else if( n==0 && r<0 && (-r)<LARGEST_INT64-1 ){
86289: r = -(double)((sqlite_int64)((-r)+0.5));
86290: }else{
86291: zBuf = sqlite3_mprintf("%.*f",n,r);
86292: if( zBuf==0 ){
86293: sqlite3_result_error_nomem(context);
86294: return;
86295: }
86296: sqlite3AtoF(zBuf, &r, sqlite3Strlen30(zBuf), SQLITE_UTF8);
86297: sqlite3_free(zBuf);
86298: }
86299: sqlite3_result_double(context, r);
86300: }
86301: #endif
86302:
86303: /*
86304: ** Allocate nByte bytes of space using sqlite3_malloc(). If the
86305: ** allocation fails, call sqlite3_result_error_nomem() to notify
86306: ** the database handle that malloc() has failed and return NULL.
86307: ** If nByte is larger than the maximum string or blob length, then
86308: ** raise an SQLITE_TOOBIG exception and return NULL.
86309: */
86310: static void *contextMalloc(sqlite3_context *context, i64 nByte){
86311: char *z;
86312: sqlite3 *db = sqlite3_context_db_handle(context);
86313: assert( nByte>0 );
86314: testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
86315: testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
86316: if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
86317: sqlite3_result_error_toobig(context);
86318: z = 0;
86319: }else{
86320: z = sqlite3Malloc((int)nByte);
86321: if( !z ){
86322: sqlite3_result_error_nomem(context);
86323: }
86324: }
86325: return z;
86326: }
86327:
86328: /*
86329: ** Implementation of the upper() and lower() SQL functions.
86330: */
86331: static void upperFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
86332: char *z1;
86333: const char *z2;
86334: int i, n;
86335: UNUSED_PARAMETER(argc);
86336: z2 = (char*)sqlite3_value_text(argv[0]);
86337: n = sqlite3_value_bytes(argv[0]);
86338: /* Verify that the call to _bytes() does not invalidate the _text() pointer */
86339: assert( z2==(char*)sqlite3_value_text(argv[0]) );
86340: if( z2 ){
86341: z1 = contextMalloc(context, ((i64)n)+1);
86342: if( z1 ){
86343: for(i=0; i<n; i++){
86344: z1[i] = (char)sqlite3Toupper(z2[i]);
86345: }
86346: sqlite3_result_text(context, z1, n, sqlite3_free);
86347: }
86348: }
86349: }
86350: static void lowerFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
86351: char *z1;
86352: const char *z2;
86353: int i, n;
86354: UNUSED_PARAMETER(argc);
86355: z2 = (char*)sqlite3_value_text(argv[0]);
86356: n = sqlite3_value_bytes(argv[0]);
86357: /* Verify that the call to _bytes() does not invalidate the _text() pointer */
86358: assert( z2==(char*)sqlite3_value_text(argv[0]) );
86359: if( z2 ){
86360: z1 = contextMalloc(context, ((i64)n)+1);
86361: if( z1 ){
86362: for(i=0; i<n; i++){
86363: z1[i] = sqlite3Tolower(z2[i]);
86364: }
86365: sqlite3_result_text(context, z1, n, sqlite3_free);
86366: }
86367: }
86368: }
86369:
86370:
86371: #if 0 /* This function is never used. */
86372: /*
86373: ** The COALESCE() and IFNULL() functions used to be implemented as shown
86374: ** here. But now they are implemented as VDBE code so that unused arguments
86375: ** do not have to be computed. This legacy implementation is retained as
86376: ** comment.
86377: */
86378: /*
86379: ** Implementation of the IFNULL(), NVL(), and COALESCE() functions.
86380: ** All three do the same thing. They return the first non-NULL
86381: ** argument.
86382: */
86383: static void ifnullFunc(
86384: sqlite3_context *context,
86385: int argc,
86386: sqlite3_value **argv
86387: ){
86388: int i;
86389: for(i=0; i<argc; i++){
86390: if( SQLITE_NULL!=sqlite3_value_type(argv[i]) ){
86391: sqlite3_result_value(context, argv[i]);
86392: break;
86393: }
86394: }
86395: }
86396: #endif /* NOT USED */
86397: #define ifnullFunc versionFunc /* Substitute function - never called */
86398:
86399: /*
86400: ** Implementation of random(). Return a random integer.
86401: */
86402: static void randomFunc(
86403: sqlite3_context *context,
86404: int NotUsed,
86405: sqlite3_value **NotUsed2
86406: ){
86407: sqlite_int64 r;
86408: UNUSED_PARAMETER2(NotUsed, NotUsed2);
86409: sqlite3_randomness(sizeof(r), &r);
86410: if( r<0 ){
86411: /* We need to prevent a random number of 0x8000000000000000
86412: ** (or -9223372036854775808) since when you do abs() of that
86413: ** number of you get the same value back again. To do this
86414: ** in a way that is testable, mask the sign bit off of negative
86415: ** values, resulting in a positive value. Then take the
86416: ** 2s complement of that positive value. The end result can
86417: ** therefore be no less than -9223372036854775807.
86418: */
86419: r = -(r ^ (((sqlite3_int64)1)<<63));
86420: }
86421: sqlite3_result_int64(context, r);
86422: }
86423:
86424: /*
86425: ** Implementation of randomblob(N). Return a random blob
86426: ** that is N bytes long.
86427: */
86428: static void randomBlob(
86429: sqlite3_context *context,
86430: int argc,
86431: sqlite3_value **argv
86432: ){
86433: int n;
86434: unsigned char *p;
86435: assert( argc==1 );
86436: UNUSED_PARAMETER(argc);
86437: n = sqlite3_value_int(argv[0]);
86438: if( n<1 ){
86439: n = 1;
86440: }
86441: p = contextMalloc(context, n);
86442: if( p ){
86443: sqlite3_randomness(n, p);
86444: sqlite3_result_blob(context, (char*)p, n, sqlite3_free);
86445: }
86446: }
86447:
86448: /*
86449: ** Implementation of the last_insert_rowid() SQL function. The return
86450: ** value is the same as the sqlite3_last_insert_rowid() API function.
86451: */
86452: static void last_insert_rowid(
86453: sqlite3_context *context,
86454: int NotUsed,
86455: sqlite3_value **NotUsed2
86456: ){
86457: sqlite3 *db = sqlite3_context_db_handle(context);
86458: UNUSED_PARAMETER2(NotUsed, NotUsed2);
86459: /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
86460: ** wrapper around the sqlite3_last_insert_rowid() C/C++ interface
86461: ** function. */
86462: sqlite3_result_int64(context, sqlite3_last_insert_rowid(db));
86463: }
86464:
86465: /*
86466: ** Implementation of the changes() SQL function.
86467: **
86468: ** IMP: R-62073-11209 The changes() SQL function is a wrapper
86469: ** around the sqlite3_changes() C/C++ function and hence follows the same
86470: ** rules for counting changes.
86471: */
86472: static void changes(
86473: sqlite3_context *context,
86474: int NotUsed,
86475: sqlite3_value **NotUsed2
86476: ){
86477: sqlite3 *db = sqlite3_context_db_handle(context);
86478: UNUSED_PARAMETER2(NotUsed, NotUsed2);
86479: sqlite3_result_int(context, sqlite3_changes(db));
86480: }
86481:
86482: /*
86483: ** Implementation of the total_changes() SQL function. The return value is
86484: ** the same as the sqlite3_total_changes() API function.
86485: */
86486: static void total_changes(
86487: sqlite3_context *context,
86488: int NotUsed,
86489: sqlite3_value **NotUsed2
86490: ){
86491: sqlite3 *db = sqlite3_context_db_handle(context);
86492: UNUSED_PARAMETER2(NotUsed, NotUsed2);
86493: /* IMP: R-52756-41993 This function is a wrapper around the
86494: ** sqlite3_total_changes() C/C++ interface. */
86495: sqlite3_result_int(context, sqlite3_total_changes(db));
86496: }
86497:
86498: /*
86499: ** A structure defining how to do GLOB-style comparisons.
86500: */
86501: struct compareInfo {
86502: u8 matchAll;
86503: u8 matchOne;
86504: u8 matchSet;
86505: u8 noCase;
86506: };
86507:
86508: /*
86509: ** For LIKE and GLOB matching on EBCDIC machines, assume that every
86510: ** character is exactly one byte in size. Also, all characters are
86511: ** able to participate in upper-case-to-lower-case mappings in EBCDIC
86512: ** whereas only characters less than 0x80 do in ASCII.
86513: */
86514: #if defined(SQLITE_EBCDIC)
86515: # define sqlite3Utf8Read(A,C) (*(A++))
86516: # define GlogUpperToLower(A) A = sqlite3UpperToLower[A]
86517: #else
86518: # define GlogUpperToLower(A) if( !((A)&~0x7f) ){ A = sqlite3UpperToLower[A]; }
86519: #endif
86520:
86521: static const struct compareInfo globInfo = { '*', '?', '[', 0 };
86522: /* The correct SQL-92 behavior is for the LIKE operator to ignore
86523: ** case. Thus 'a' LIKE 'A' would be true. */
86524: static const struct compareInfo likeInfoNorm = { '%', '_', 0, 1 };
86525: /* If SQLITE_CASE_SENSITIVE_LIKE is defined, then the LIKE operator
86526: ** is case sensitive causing 'a' LIKE 'A' to be false */
86527: static const struct compareInfo likeInfoAlt = { '%', '_', 0, 0 };
86528:
86529: /*
86530: ** Compare two UTF-8 strings for equality where the first string can
86531: ** potentially be a "glob" expression. Return true (1) if they
86532: ** are the same and false (0) if they are different.
86533: **
86534: ** Globbing rules:
86535: **
86536: ** '*' Matches any sequence of zero or more characters.
86537: **
86538: ** '?' Matches exactly one character.
86539: **
86540: ** [...] Matches one character from the enclosed list of
86541: ** characters.
86542: **
86543: ** [^...] Matches one character not in the enclosed list.
86544: **
86545: ** With the [...] and [^...] matching, a ']' character can be included
86546: ** in the list by making it the first character after '[' or '^'. A
86547: ** range of characters can be specified using '-'. Example:
86548: ** "[a-z]" matches any single lower-case letter. To match a '-', make
86549: ** it the last character in the list.
86550: **
86551: ** This routine is usually quick, but can be N**2 in the worst case.
86552: **
86553: ** Hints: to match '*' or '?', put them in "[]". Like this:
86554: **
86555: ** abc[*]xyz Matches "abc*xyz" only
86556: */
86557: static int patternCompare(
86558: const u8 *zPattern, /* The glob pattern */
86559: const u8 *zString, /* The string to compare against the glob */
86560: const struct compareInfo *pInfo, /* Information about how to do the compare */
86561: u32 esc /* The escape character */
86562: ){
86563: u32 c, c2;
86564: int invert;
86565: int seen;
86566: u8 matchOne = pInfo->matchOne;
86567: u8 matchAll = pInfo->matchAll;
86568: u8 matchSet = pInfo->matchSet;
86569: u8 noCase = pInfo->noCase;
86570: int prevEscape = 0; /* True if the previous character was 'escape' */
86571:
86572: while( (c = sqlite3Utf8Read(zPattern,&zPattern))!=0 ){
86573: if( !prevEscape && c==matchAll ){
86574: while( (c=sqlite3Utf8Read(zPattern,&zPattern)) == matchAll
86575: || c == matchOne ){
86576: if( c==matchOne && sqlite3Utf8Read(zString, &zString)==0 ){
86577: return 0;
86578: }
86579: }
86580: if( c==0 ){
86581: return 1;
86582: }else if( c==esc ){
86583: c = sqlite3Utf8Read(zPattern, &zPattern);
86584: if( c==0 ){
86585: return 0;
86586: }
86587: }else if( c==matchSet ){
86588: assert( esc==0 ); /* This is GLOB, not LIKE */
86589: assert( matchSet<0x80 ); /* '[' is a single-byte character */
86590: while( *zString && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){
86591: SQLITE_SKIP_UTF8(zString);
86592: }
86593: return *zString!=0;
86594: }
86595: while( (c2 = sqlite3Utf8Read(zString,&zString))!=0 ){
86596: if( noCase ){
86597: GlogUpperToLower(c2);
86598: GlogUpperToLower(c);
86599: while( c2 != 0 && c2 != c ){
86600: c2 = sqlite3Utf8Read(zString, &zString);
86601: GlogUpperToLower(c2);
86602: }
86603: }else{
86604: while( c2 != 0 && c2 != c ){
86605: c2 = sqlite3Utf8Read(zString, &zString);
86606: }
86607: }
86608: if( c2==0 ) return 0;
86609: if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;
86610: }
86611: return 0;
86612: }else if( !prevEscape && c==matchOne ){
86613: if( sqlite3Utf8Read(zString, &zString)==0 ){
86614: return 0;
86615: }
86616: }else if( c==matchSet ){
86617: u32 prior_c = 0;
86618: assert( esc==0 ); /* This only occurs for GLOB, not LIKE */
86619: seen = 0;
86620: invert = 0;
86621: c = sqlite3Utf8Read(zString, &zString);
86622: if( c==0 ) return 0;
86623: c2 = sqlite3Utf8Read(zPattern, &zPattern);
86624: if( c2=='^' ){
86625: invert = 1;
86626: c2 = sqlite3Utf8Read(zPattern, &zPattern);
86627: }
86628: if( c2==']' ){
86629: if( c==']' ) seen = 1;
86630: c2 = sqlite3Utf8Read(zPattern, &zPattern);
86631: }
86632: while( c2 && c2!=']' ){
86633: if( c2=='-' && zPattern[0]!=']' && zPattern[0]!=0 && prior_c>0 ){
86634: c2 = sqlite3Utf8Read(zPattern, &zPattern);
86635: if( c>=prior_c && c<=c2 ) seen = 1;
86636: prior_c = 0;
86637: }else{
86638: if( c==c2 ){
86639: seen = 1;
86640: }
86641: prior_c = c2;
86642: }
86643: c2 = sqlite3Utf8Read(zPattern, &zPattern);
86644: }
86645: if( c2==0 || (seen ^ invert)==0 ){
86646: return 0;
86647: }
86648: }else if( esc==c && !prevEscape ){
86649: prevEscape = 1;
86650: }else{
86651: c2 = sqlite3Utf8Read(zString, &zString);
86652: if( noCase ){
86653: GlogUpperToLower(c);
86654: GlogUpperToLower(c2);
86655: }
86656: if( c!=c2 ){
86657: return 0;
86658: }
86659: prevEscape = 0;
86660: }
86661: }
86662: return *zString==0;
86663: }
86664:
86665: /*
86666: ** Count the number of times that the LIKE operator (or GLOB which is
86667: ** just a variation of LIKE) gets called. This is used for testing
86668: ** only.
86669: */
86670: #ifdef SQLITE_TEST
86671: SQLITE_API int sqlite3_like_count = 0;
86672: #endif
86673:
86674:
86675: /*
86676: ** Implementation of the like() SQL function. This function implements
86677: ** the build-in LIKE operator. The first argument to the function is the
86678: ** pattern and the second argument is the string. So, the SQL statements:
86679: **
86680: ** A LIKE B
86681: **
86682: ** is implemented as like(B,A).
86683: **
86684: ** This same function (with a different compareInfo structure) computes
86685: ** the GLOB operator.
86686: */
86687: static void likeFunc(
86688: sqlite3_context *context,
86689: int argc,
86690: sqlite3_value **argv
86691: ){
86692: const unsigned char *zA, *zB;
86693: u32 escape = 0;
86694: int nPat;
86695: sqlite3 *db = sqlite3_context_db_handle(context);
86696:
86697: zB = sqlite3_value_text(argv[0]);
86698: zA = sqlite3_value_text(argv[1]);
86699:
86700: /* Limit the length of the LIKE or GLOB pattern to avoid problems
86701: ** of deep recursion and N*N behavior in patternCompare().
86702: */
86703: nPat = sqlite3_value_bytes(argv[0]);
86704: testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] );
86705: testcase( nPat==db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]+1 );
86706: if( nPat > db->aLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH] ){
86707: sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
86708: return;
86709: }
86710: assert( zB==sqlite3_value_text(argv[0]) ); /* Encoding did not change */
86711:
86712: if( argc==3 ){
86713: /* The escape character string must consist of a single UTF-8 character.
86714: ** Otherwise, return an error.
86715: */
86716: const unsigned char *zEsc = sqlite3_value_text(argv[2]);
86717: if( zEsc==0 ) return;
86718: if( sqlite3Utf8CharLen((char*)zEsc, -1)!=1 ){
86719: sqlite3_result_error(context,
86720: "ESCAPE expression must be a single character", -1);
86721: return;
86722: }
86723: escape = sqlite3Utf8Read(zEsc, &zEsc);
86724: }
86725: if( zA && zB ){
86726: struct compareInfo *pInfo = sqlite3_user_data(context);
86727: #ifdef SQLITE_TEST
86728: sqlite3_like_count++;
86729: #endif
86730:
86731: sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape));
86732: }
86733: }
86734:
86735: /*
86736: ** Implementation of the NULLIF(x,y) function. The result is the first
86737: ** argument if the arguments are different. The result is NULL if the
86738: ** arguments are equal to each other.
86739: */
86740: static void nullifFunc(
86741: sqlite3_context *context,
86742: int NotUsed,
86743: sqlite3_value **argv
86744: ){
86745: CollSeq *pColl = sqlite3GetFuncCollSeq(context);
86746: UNUSED_PARAMETER(NotUsed);
86747: if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
86748: sqlite3_result_value(context, argv[0]);
86749: }
86750: }
86751:
86752: /*
86753: ** Implementation of the sqlite_version() function. The result is the version
86754: ** of the SQLite library that is running.
86755: */
86756: static void versionFunc(
86757: sqlite3_context *context,
86758: int NotUsed,
86759: sqlite3_value **NotUsed2
86760: ){
86761: UNUSED_PARAMETER2(NotUsed, NotUsed2);
86762: /* IMP: R-48699-48617 This function is an SQL wrapper around the
86763: ** sqlite3_libversion() C-interface. */
86764: sqlite3_result_text(context, sqlite3_libversion(), -1, SQLITE_STATIC);
86765: }
86766:
86767: /*
86768: ** Implementation of the sqlite_source_id() function. The result is a string
86769: ** that identifies the particular version of the source code used to build
86770: ** SQLite.
86771: */
86772: static void sourceidFunc(
86773: sqlite3_context *context,
86774: int NotUsed,
86775: sqlite3_value **NotUsed2
86776: ){
86777: UNUSED_PARAMETER2(NotUsed, NotUsed2);
86778: /* IMP: R-24470-31136 This function is an SQL wrapper around the
86779: ** sqlite3_sourceid() C interface. */
86780: sqlite3_result_text(context, sqlite3_sourceid(), -1, SQLITE_STATIC);
86781: }
86782:
86783: /*
86784: ** Implementation of the sqlite_log() function. This is a wrapper around
86785: ** sqlite3_log(). The return value is NULL. The function exists purely for
86786: ** its side-effects.
86787: */
86788: static void errlogFunc(
86789: sqlite3_context *context,
86790: int argc,
86791: sqlite3_value **argv
86792: ){
86793: UNUSED_PARAMETER(argc);
86794: UNUSED_PARAMETER(context);
86795: sqlite3_log(sqlite3_value_int(argv[0]), "%s", sqlite3_value_text(argv[1]));
86796: }
86797:
86798: /*
86799: ** Implementation of the sqlite_compileoption_used() function.
86800: ** The result is an integer that identifies if the compiler option
86801: ** was used to build SQLite.
86802: */
86803: #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
86804: static void compileoptionusedFunc(
86805: sqlite3_context *context,
86806: int argc,
86807: sqlite3_value **argv
86808: ){
86809: const char *zOptName;
86810: assert( argc==1 );
86811: UNUSED_PARAMETER(argc);
86812: /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
86813: ** function is a wrapper around the sqlite3_compileoption_used() C/C++
86814: ** function.
86815: */
86816: if( (zOptName = (const char*)sqlite3_value_text(argv[0]))!=0 ){
86817: sqlite3_result_int(context, sqlite3_compileoption_used(zOptName));
86818: }
86819: }
86820: #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
86821:
86822: /*
86823: ** Implementation of the sqlite_compileoption_get() function.
86824: ** The result is a string that identifies the compiler options
86825: ** used to build SQLite.
86826: */
86827: #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
86828: static void compileoptiongetFunc(
86829: sqlite3_context *context,
86830: int argc,
86831: sqlite3_value **argv
86832: ){
86833: int n;
86834: assert( argc==1 );
86835: UNUSED_PARAMETER(argc);
86836: /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
86837: ** is a wrapper around the sqlite3_compileoption_get() C/C++ function.
86838: */
86839: n = sqlite3_value_int(argv[0]);
86840: sqlite3_result_text(context, sqlite3_compileoption_get(n), -1, SQLITE_STATIC);
86841: }
86842: #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
86843:
86844: /* Array for converting from half-bytes (nybbles) into ASCII hex
86845: ** digits. */
86846: static const char hexdigits[] = {
86847: '0', '1', '2', '3', '4', '5', '6', '7',
86848: '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
86849: };
86850:
86851: /*
86852: ** EXPERIMENTAL - This is not an official function. The interface may
86853: ** change. This function may disappear. Do not write code that depends
86854: ** on this function.
86855: **
86856: ** Implementation of the QUOTE() function. This function takes a single
86857: ** argument. If the argument is numeric, the return value is the same as
86858: ** the argument. If the argument is NULL, the return value is the string
86859: ** "NULL". Otherwise, the argument is enclosed in single quotes with
86860: ** single-quote escapes.
86861: */
86862: static void quoteFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
86863: assert( argc==1 );
86864: UNUSED_PARAMETER(argc);
86865: switch( sqlite3_value_type(argv[0]) ){
86866: case SQLITE_INTEGER:
86867: case SQLITE_FLOAT: {
86868: sqlite3_result_value(context, argv[0]);
86869: break;
86870: }
86871: case SQLITE_BLOB: {
86872: char *zText = 0;
86873: char const *zBlob = sqlite3_value_blob(argv[0]);
86874: int nBlob = sqlite3_value_bytes(argv[0]);
86875: assert( zBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
86876: zText = (char *)contextMalloc(context, (2*(i64)nBlob)+4);
86877: if( zText ){
86878: int i;
86879: for(i=0; i<nBlob; i++){
86880: zText[(i*2)+2] = hexdigits[(zBlob[i]>>4)&0x0F];
86881: zText[(i*2)+3] = hexdigits[(zBlob[i])&0x0F];
86882: }
86883: zText[(nBlob*2)+2] = '\'';
86884: zText[(nBlob*2)+3] = '\0';
86885: zText[0] = 'X';
86886: zText[1] = '\'';
86887: sqlite3_result_text(context, zText, -1, SQLITE_TRANSIENT);
86888: sqlite3_free(zText);
86889: }
86890: break;
86891: }
86892: case SQLITE_TEXT: {
86893: int i,j;
86894: u64 n;
86895: const unsigned char *zArg = sqlite3_value_text(argv[0]);
86896: char *z;
86897:
86898: if( zArg==0 ) return;
86899: for(i=0, n=0; zArg[i]; i++){ if( zArg[i]=='\'' ) n++; }
86900: z = contextMalloc(context, ((i64)i)+((i64)n)+3);
86901: if( z ){
86902: z[0] = '\'';
86903: for(i=0, j=1; zArg[i]; i++){
86904: z[j++] = zArg[i];
86905: if( zArg[i]=='\'' ){
86906: z[j++] = '\'';
86907: }
86908: }
86909: z[j++] = '\'';
86910: z[j] = 0;
86911: sqlite3_result_text(context, z, j, sqlite3_free);
86912: }
86913: break;
86914: }
86915: default: {
86916: assert( sqlite3_value_type(argv[0])==SQLITE_NULL );
86917: sqlite3_result_text(context, "NULL", 4, SQLITE_STATIC);
86918: break;
86919: }
86920: }
86921: }
86922:
86923: /*
86924: ** The hex() function. Interpret the argument as a blob. Return
86925: ** a hexadecimal rendering as text.
86926: */
86927: static void hexFunc(
86928: sqlite3_context *context,
86929: int argc,
86930: sqlite3_value **argv
86931: ){
86932: int i, n;
86933: const unsigned char *pBlob;
86934: char *zHex, *z;
86935: assert( argc==1 );
86936: UNUSED_PARAMETER(argc);
86937: pBlob = sqlite3_value_blob(argv[0]);
86938: n = sqlite3_value_bytes(argv[0]);
86939: assert( pBlob==sqlite3_value_blob(argv[0]) ); /* No encoding change */
86940: z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
86941: if( zHex ){
86942: for(i=0; i<n; i++, pBlob++){
86943: unsigned char c = *pBlob;
86944: *(z++) = hexdigits[(c>>4)&0xf];
86945: *(z++) = hexdigits[c&0xf];
86946: }
86947: *z = 0;
86948: sqlite3_result_text(context, zHex, n*2, sqlite3_free);
86949: }
86950: }
86951:
86952: /*
86953: ** The zeroblob(N) function returns a zero-filled blob of size N bytes.
86954: */
86955: static void zeroblobFunc(
86956: sqlite3_context *context,
86957: int argc,
86958: sqlite3_value **argv
86959: ){
86960: i64 n;
86961: sqlite3 *db = sqlite3_context_db_handle(context);
86962: assert( argc==1 );
86963: UNUSED_PARAMETER(argc);
86964: n = sqlite3_value_int64(argv[0]);
86965: testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH] );
86966: testcase( n==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
86967: if( n>db->aLimit[SQLITE_LIMIT_LENGTH] ){
86968: sqlite3_result_error_toobig(context);
86969: }else{
86970: sqlite3_result_zeroblob(context, (int)n); /* IMP: R-00293-64994 */
86971: }
86972: }
86973:
86974: /*
86975: ** The replace() function. Three arguments are all strings: call
86976: ** them A, B, and C. The result is also a string which is derived
86977: ** from A by replacing every occurance of B with C. The match
86978: ** must be exact. Collating sequences are not used.
86979: */
86980: static void replaceFunc(
86981: sqlite3_context *context,
86982: int argc,
86983: sqlite3_value **argv
86984: ){
86985: const unsigned char *zStr; /* The input string A */
86986: const unsigned char *zPattern; /* The pattern string B */
86987: const unsigned char *zRep; /* The replacement string C */
86988: unsigned char *zOut; /* The output */
86989: int nStr; /* Size of zStr */
86990: int nPattern; /* Size of zPattern */
86991: int nRep; /* Size of zRep */
86992: i64 nOut; /* Maximum size of zOut */
86993: int loopLimit; /* Last zStr[] that might match zPattern[] */
86994: int i, j; /* Loop counters */
86995:
86996: assert( argc==3 );
86997: UNUSED_PARAMETER(argc);
86998: zStr = sqlite3_value_text(argv[0]);
86999: if( zStr==0 ) return;
87000: nStr = sqlite3_value_bytes(argv[0]);
87001: assert( zStr==sqlite3_value_text(argv[0]) ); /* No encoding change */
87002: zPattern = sqlite3_value_text(argv[1]);
87003: if( zPattern==0 ){
87004: assert( sqlite3_value_type(argv[1])==SQLITE_NULL
87005: || sqlite3_context_db_handle(context)->mallocFailed );
87006: return;
87007: }
87008: if( zPattern[0]==0 ){
87009: assert( sqlite3_value_type(argv[1])!=SQLITE_NULL );
87010: sqlite3_result_value(context, argv[0]);
87011: return;
87012: }
87013: nPattern = sqlite3_value_bytes(argv[1]);
87014: assert( zPattern==sqlite3_value_text(argv[1]) ); /* No encoding change */
87015: zRep = sqlite3_value_text(argv[2]);
87016: if( zRep==0 ) return;
87017: nRep = sqlite3_value_bytes(argv[2]);
87018: assert( zRep==sqlite3_value_text(argv[2]) );
87019: nOut = nStr + 1;
87020: assert( nOut<SQLITE_MAX_LENGTH );
87021: zOut = contextMalloc(context, (i64)nOut);
87022: if( zOut==0 ){
87023: return;
87024: }
87025: loopLimit = nStr - nPattern;
87026: for(i=j=0; i<=loopLimit; i++){
87027: if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
87028: zOut[j++] = zStr[i];
87029: }else{
87030: u8 *zOld;
87031: sqlite3 *db = sqlite3_context_db_handle(context);
87032: nOut += nRep - nPattern;
87033: testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
87034: testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
87035: if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
87036: sqlite3_result_error_toobig(context);
87037: sqlite3_free(zOut);
87038: return;
87039: }
87040: zOld = zOut;
87041: zOut = sqlite3_realloc(zOut, (int)nOut);
87042: if( zOut==0 ){
87043: sqlite3_result_error_nomem(context);
87044: sqlite3_free(zOld);
87045: return;
87046: }
87047: memcpy(&zOut[j], zRep, nRep);
87048: j += nRep;
87049: i += nPattern-1;
87050: }
87051: }
87052: assert( j+nStr-i+1==nOut );
87053: memcpy(&zOut[j], &zStr[i], nStr-i);
87054: j += nStr - i;
87055: assert( j<=nOut );
87056: zOut[j] = 0;
87057: sqlite3_result_text(context, (char*)zOut, j, sqlite3_free);
87058: }
87059:
87060: /*
87061: ** Implementation of the TRIM(), LTRIM(), and RTRIM() functions.
87062: ** The userdata is 0x1 for left trim, 0x2 for right trim, 0x3 for both.
87063: */
87064: static void trimFunc(
87065: sqlite3_context *context,
87066: int argc,
87067: sqlite3_value **argv
87068: ){
87069: const unsigned char *zIn; /* Input string */
87070: const unsigned char *zCharSet; /* Set of characters to trim */
87071: int nIn; /* Number of bytes in input */
87072: int flags; /* 1: trimleft 2: trimright 3: trim */
87073: int i; /* Loop counter */
87074: unsigned char *aLen = 0; /* Length of each character in zCharSet */
87075: unsigned char **azChar = 0; /* Individual characters in zCharSet */
87076: int nChar; /* Number of characters in zCharSet */
87077:
87078: if( sqlite3_value_type(argv[0])==SQLITE_NULL ){
87079: return;
87080: }
87081: zIn = sqlite3_value_text(argv[0]);
87082: if( zIn==0 ) return;
87083: nIn = sqlite3_value_bytes(argv[0]);
87084: assert( zIn==sqlite3_value_text(argv[0]) );
87085: if( argc==1 ){
87086: static const unsigned char lenOne[] = { 1 };
87087: static unsigned char * const azOne[] = { (u8*)" " };
87088: nChar = 1;
87089: aLen = (u8*)lenOne;
87090: azChar = (unsigned char **)azOne;
87091: zCharSet = 0;
87092: }else if( (zCharSet = sqlite3_value_text(argv[1]))==0 ){
87093: return;
87094: }else{
87095: const unsigned char *z;
87096: for(z=zCharSet, nChar=0; *z; nChar++){
87097: SQLITE_SKIP_UTF8(z);
87098: }
87099: if( nChar>0 ){
87100: azChar = contextMalloc(context, ((i64)nChar)*(sizeof(char*)+1));
87101: if( azChar==0 ){
87102: return;
87103: }
87104: aLen = (unsigned char*)&azChar[nChar];
87105: for(z=zCharSet, nChar=0; *z; nChar++){
87106: azChar[nChar] = (unsigned char *)z;
87107: SQLITE_SKIP_UTF8(z);
87108: aLen[nChar] = (u8)(z - azChar[nChar]);
87109: }
87110: }
87111: }
87112: if( nChar>0 ){
87113: flags = SQLITE_PTR_TO_INT(sqlite3_user_data(context));
87114: if( flags & 1 ){
87115: while( nIn>0 ){
87116: int len = 0;
87117: for(i=0; i<nChar; i++){
87118: len = aLen[i];
87119: if( len<=nIn && memcmp(zIn, azChar[i], len)==0 ) break;
87120: }
87121: if( i>=nChar ) break;
87122: zIn += len;
87123: nIn -= len;
87124: }
87125: }
87126: if( flags & 2 ){
87127: while( nIn>0 ){
87128: int len = 0;
87129: for(i=0; i<nChar; i++){
87130: len = aLen[i];
87131: if( len<=nIn && memcmp(&zIn[nIn-len],azChar[i],len)==0 ) break;
87132: }
87133: if( i>=nChar ) break;
87134: nIn -= len;
87135: }
87136: }
87137: if( zCharSet ){
87138: sqlite3_free(azChar);
87139: }
87140: }
87141: sqlite3_result_text(context, (char*)zIn, nIn, SQLITE_TRANSIENT);
87142: }
87143:
87144:
87145: /* IMP: R-25361-16150 This function is omitted from SQLite by default. It
87146: ** is only available if the SQLITE_SOUNDEX compile-time option is used
87147: ** when SQLite is built.
87148: */
87149: #ifdef SQLITE_SOUNDEX
87150: /*
87151: ** Compute the soundex encoding of a word.
87152: **
87153: ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
87154: ** soundex encoding of the string X.
87155: */
87156: static void soundexFunc(
87157: sqlite3_context *context,
87158: int argc,
87159: sqlite3_value **argv
87160: ){
87161: char zResult[8];
87162: const u8 *zIn;
87163: int i, j;
87164: static const unsigned char iCode[] = {
87165: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
87166: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
87167: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
87168: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
87169: 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
87170: 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
87171: 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0,
87172: 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0,
87173: };
87174: assert( argc==1 );
87175: zIn = (u8*)sqlite3_value_text(argv[0]);
87176: if( zIn==0 ) zIn = (u8*)"";
87177: for(i=0; zIn[i] && !sqlite3Isalpha(zIn[i]); i++){}
87178: if( zIn[i] ){
87179: u8 prevcode = iCode[zIn[i]&0x7f];
87180: zResult[0] = sqlite3Toupper(zIn[i]);
87181: for(j=1; j<4 && zIn[i]; i++){
87182: int code = iCode[zIn[i]&0x7f];
87183: if( code>0 ){
87184: if( code!=prevcode ){
87185: prevcode = code;
87186: zResult[j++] = code + '0';
87187: }
87188: }else{
87189: prevcode = 0;
87190: }
87191: }
87192: while( j<4 ){
87193: zResult[j++] = '0';
87194: }
87195: zResult[j] = 0;
87196: sqlite3_result_text(context, zResult, 4, SQLITE_TRANSIENT);
87197: }else{
87198: /* IMP: R-64894-50321 The string "?000" is returned if the argument
87199: ** is NULL or contains no ASCII alphabetic characters. */
87200: sqlite3_result_text(context, "?000", 4, SQLITE_STATIC);
87201: }
87202: }
87203: #endif /* SQLITE_SOUNDEX */
87204:
87205: #ifndef SQLITE_OMIT_LOAD_EXTENSION
87206: /*
87207: ** A function that loads a shared-library extension then returns NULL.
87208: */
87209: static void loadExt(sqlite3_context *context, int argc, sqlite3_value **argv){
87210: const char *zFile = (const char *)sqlite3_value_text(argv[0]);
87211: const char *zProc;
87212: sqlite3 *db = sqlite3_context_db_handle(context);
87213: char *zErrMsg = 0;
87214:
87215: if( argc==2 ){
87216: zProc = (const char *)sqlite3_value_text(argv[1]);
87217: }else{
87218: zProc = 0;
87219: }
87220: if( zFile && sqlite3_load_extension(db, zFile, zProc, &zErrMsg) ){
87221: sqlite3_result_error(context, zErrMsg, -1);
87222: sqlite3_free(zErrMsg);
87223: }
87224: }
87225: #endif
87226:
87227:
87228: /*
87229: ** An instance of the following structure holds the context of a
87230: ** sum() or avg() aggregate computation.
87231: */
87232: typedef struct SumCtx SumCtx;
87233: struct SumCtx {
87234: double rSum; /* Floating point sum */
87235: i64 iSum; /* Integer sum */
87236: i64 cnt; /* Number of elements summed */
87237: u8 overflow; /* True if integer overflow seen */
87238: u8 approx; /* True if non-integer value was input to the sum */
87239: };
87240:
87241: /*
87242: ** Routines used to compute the sum, average, and total.
87243: **
87244: ** The SUM() function follows the (broken) SQL standard which means
87245: ** that it returns NULL if it sums over no inputs. TOTAL returns
87246: ** 0.0 in that case. In addition, TOTAL always returns a float where
87247: ** SUM might return an integer if it never encounters a floating point
87248: ** value. TOTAL never fails, but SUM might through an exception if
87249: ** it overflows an integer.
87250: */
87251: static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
87252: SumCtx *p;
87253: int type;
87254: assert( argc==1 );
87255: UNUSED_PARAMETER(argc);
87256: p = sqlite3_aggregate_context(context, sizeof(*p));
87257: type = sqlite3_value_numeric_type(argv[0]);
87258: if( p && type!=SQLITE_NULL ){
87259: p->cnt++;
87260: if( type==SQLITE_INTEGER ){
87261: i64 v = sqlite3_value_int64(argv[0]);
87262: p->rSum += v;
87263: if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
87264: p->overflow = 1;
87265: }
87266: }else{
87267: p->rSum += sqlite3_value_double(argv[0]);
87268: p->approx = 1;
87269: }
87270: }
87271: }
87272: static void sumFinalize(sqlite3_context *context){
87273: SumCtx *p;
87274: p = sqlite3_aggregate_context(context, 0);
87275: if( p && p->cnt>0 ){
87276: if( p->overflow ){
87277: sqlite3_result_error(context,"integer overflow",-1);
87278: }else if( p->approx ){
87279: sqlite3_result_double(context, p->rSum);
87280: }else{
87281: sqlite3_result_int64(context, p->iSum);
87282: }
87283: }
87284: }
87285: static void avgFinalize(sqlite3_context *context){
87286: SumCtx *p;
87287: p = sqlite3_aggregate_context(context, 0);
87288: if( p && p->cnt>0 ){
87289: sqlite3_result_double(context, p->rSum/(double)p->cnt);
87290: }
87291: }
87292: static void totalFinalize(sqlite3_context *context){
87293: SumCtx *p;
87294: p = sqlite3_aggregate_context(context, 0);
87295: /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
87296: sqlite3_result_double(context, p ? p->rSum : (double)0);
87297: }
87298:
87299: /*
87300: ** The following structure keeps track of state information for the
87301: ** count() aggregate function.
87302: */
87303: typedef struct CountCtx CountCtx;
87304: struct CountCtx {
87305: i64 n;
87306: };
87307:
87308: /*
87309: ** Routines to implement the count() aggregate function.
87310: */
87311: static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
87312: CountCtx *p;
87313: p = sqlite3_aggregate_context(context, sizeof(*p));
87314: if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
87315: p->n++;
87316: }
87317:
87318: #ifndef SQLITE_OMIT_DEPRECATED
87319: /* The sqlite3_aggregate_count() function is deprecated. But just to make
87320: ** sure it still operates correctly, verify that its count agrees with our
87321: ** internal count when using count(*) and when the total count can be
87322: ** expressed as a 32-bit integer. */
87323: assert( argc==1 || p==0 || p->n>0x7fffffff
87324: || p->n==sqlite3_aggregate_count(context) );
87325: #endif
87326: }
87327: static void countFinalize(sqlite3_context *context){
87328: CountCtx *p;
87329: p = sqlite3_aggregate_context(context, 0);
87330: sqlite3_result_int64(context, p ? p->n : 0);
87331: }
87332:
87333: /*
87334: ** Routines to implement min() and max() aggregate functions.
87335: */
87336: static void minmaxStep(
87337: sqlite3_context *context,
87338: int NotUsed,
87339: sqlite3_value **argv
87340: ){
87341: Mem *pArg = (Mem *)argv[0];
87342: Mem *pBest;
87343: UNUSED_PARAMETER(NotUsed);
87344:
87345: if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
87346: pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
87347: if( !pBest ) return;
87348:
87349: if( pBest->flags ){
87350: int max;
87351: int cmp;
87352: CollSeq *pColl = sqlite3GetFuncCollSeq(context);
87353: /* This step function is used for both the min() and max() aggregates,
87354: ** the only difference between the two being that the sense of the
87355: ** comparison is inverted. For the max() aggregate, the
87356: ** sqlite3_user_data() function returns (void *)-1. For min() it
87357: ** returns (void *)db, where db is the sqlite3* database pointer.
87358: ** Therefore the next statement sets variable 'max' to 1 for the max()
87359: ** aggregate, or 0 for min().
87360: */
87361: max = sqlite3_user_data(context)!=0;
87362: cmp = sqlite3MemCompare(pBest, pArg, pColl);
87363: if( (max && cmp<0) || (!max && cmp>0) ){
87364: sqlite3VdbeMemCopy(pBest, pArg);
87365: }
87366: }else{
87367: sqlite3VdbeMemCopy(pBest, pArg);
87368: }
87369: }
87370: static void minMaxFinalize(sqlite3_context *context){
87371: sqlite3_value *pRes;
87372: pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
87373: if( pRes ){
87374: if( ALWAYS(pRes->flags) ){
87375: sqlite3_result_value(context, pRes);
87376: }
87377: sqlite3VdbeMemRelease(pRes);
87378: }
87379: }
87380:
87381: /*
87382: ** group_concat(EXPR, ?SEPARATOR?)
87383: */
87384: static void groupConcatStep(
87385: sqlite3_context *context,
87386: int argc,
87387: sqlite3_value **argv
87388: ){
87389: const char *zVal;
87390: StrAccum *pAccum;
87391: const char *zSep;
87392: int nVal, nSep;
87393: assert( argc==1 || argc==2 );
87394: if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
87395: pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));
87396:
87397: if( pAccum ){
87398: sqlite3 *db = sqlite3_context_db_handle(context);
87399: int firstTerm = pAccum->useMalloc==0;
87400: pAccum->useMalloc = 2;
87401: pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
87402: if( !firstTerm ){
87403: if( argc==2 ){
87404: zSep = (char*)sqlite3_value_text(argv[1]);
87405: nSep = sqlite3_value_bytes(argv[1]);
87406: }else{
87407: zSep = ",";
87408: nSep = 1;
87409: }
87410: sqlite3StrAccumAppend(pAccum, zSep, nSep);
87411: }
87412: zVal = (char*)sqlite3_value_text(argv[0]);
87413: nVal = sqlite3_value_bytes(argv[0]);
87414: sqlite3StrAccumAppend(pAccum, zVal, nVal);
87415: }
87416: }
87417: static void groupConcatFinalize(sqlite3_context *context){
87418: StrAccum *pAccum;
87419: pAccum = sqlite3_aggregate_context(context, 0);
87420: if( pAccum ){
87421: if( pAccum->tooBig ){
87422: sqlite3_result_error_toobig(context);
87423: }else if( pAccum->mallocFailed ){
87424: sqlite3_result_error_nomem(context);
87425: }else{
87426: sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1,
87427: sqlite3_free);
87428: }
87429: }
87430: }
87431:
87432: /*
87433: ** This routine does per-connection function registration. Most
87434: ** of the built-in functions above are part of the global function set.
87435: ** This routine only deals with those that are not global.
87436: */
87437: SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
87438: int rc = sqlite3_overload_function(db, "MATCH", 2);
87439: assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
87440: if( rc==SQLITE_NOMEM ){
87441: db->mallocFailed = 1;
87442: }
87443: }
87444:
87445: /*
87446: ** Set the LIKEOPT flag on the 2-argument function with the given name.
87447: */
87448: static void setLikeOptFlag(sqlite3 *db, const char *zName, u8 flagVal){
87449: FuncDef *pDef;
87450: pDef = sqlite3FindFunction(db, zName, sqlite3Strlen30(zName),
87451: 2, SQLITE_UTF8, 0);
87452: if( ALWAYS(pDef) ){
87453: pDef->flags = flagVal;
87454: }
87455: }
87456:
87457: /*
87458: ** Register the built-in LIKE and GLOB functions. The caseSensitive
87459: ** parameter determines whether or not the LIKE operator is case
87460: ** sensitive. GLOB is always case sensitive.
87461: */
87462: SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
87463: struct compareInfo *pInfo;
87464: if( caseSensitive ){
87465: pInfo = (struct compareInfo*)&likeInfoAlt;
87466: }else{
87467: pInfo = (struct compareInfo*)&likeInfoNorm;
87468: }
87469: sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
87470: sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0);
87471: sqlite3CreateFunc(db, "glob", 2, SQLITE_UTF8,
87472: (struct compareInfo*)&globInfo, likeFunc, 0, 0, 0);
87473: setLikeOptFlag(db, "glob", SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE);
87474: setLikeOptFlag(db, "like",
87475: caseSensitive ? (SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE) : SQLITE_FUNC_LIKE);
87476: }
87477:
87478: /*
87479: ** pExpr points to an expression which implements a function. If
87480: ** it is appropriate to apply the LIKE optimization to that function
87481: ** then set aWc[0] through aWc[2] to the wildcard characters and
87482: ** return TRUE. If the function is not a LIKE-style function then
87483: ** return FALSE.
87484: */
87485: SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3 *db, Expr *pExpr, int *pIsNocase, char *aWc){
87486: FuncDef *pDef;
87487: if( pExpr->op!=TK_FUNCTION
87488: || !pExpr->x.pList
87489: || pExpr->x.pList->nExpr!=2
87490: ){
87491: return 0;
87492: }
87493: assert( !ExprHasProperty(pExpr, EP_xIsSelect) );
87494: pDef = sqlite3FindFunction(db, pExpr->u.zToken,
87495: sqlite3Strlen30(pExpr->u.zToken),
87496: 2, SQLITE_UTF8, 0);
87497: if( NEVER(pDef==0) || (pDef->flags & SQLITE_FUNC_LIKE)==0 ){
87498: return 0;
87499: }
87500:
87501: /* The memcpy() statement assumes that the wildcard characters are
87502: ** the first three statements in the compareInfo structure. The
87503: ** asserts() that follow verify that assumption
87504: */
87505: memcpy(aWc, pDef->pUserData, 3);
87506: assert( (char*)&likeInfoAlt == (char*)&likeInfoAlt.matchAll );
87507: assert( &((char*)&likeInfoAlt)[1] == (char*)&likeInfoAlt.matchOne );
87508: assert( &((char*)&likeInfoAlt)[2] == (char*)&likeInfoAlt.matchSet );
87509: *pIsNocase = (pDef->flags & SQLITE_FUNC_CASE)==0;
87510: return 1;
87511: }
87512:
87513: /*
87514: ** All all of the FuncDef structures in the aBuiltinFunc[] array above
87515: ** to the global function hash table. This occurs at start-time (as
87516: ** a consequence of calling sqlite3_initialize()).
87517: **
87518: ** After this routine runs
87519: */
87520: SQLITE_PRIVATE void sqlite3RegisterGlobalFunctions(void){
87521: /*
87522: ** The following array holds FuncDef structures for all of the functions
87523: ** defined in this file.
87524: **
87525: ** The array cannot be constant since changes are made to the
87526: ** FuncDef.pHash elements at start-time. The elements of this array
87527: ** are read-only after initialization is complete.
87528: */
87529: static SQLITE_WSD FuncDef aBuiltinFunc[] = {
87530: FUNCTION(ltrim, 1, 1, 0, trimFunc ),
87531: FUNCTION(ltrim, 2, 1, 0, trimFunc ),
87532: FUNCTION(rtrim, 1, 2, 0, trimFunc ),
87533: FUNCTION(rtrim, 2, 2, 0, trimFunc ),
87534: FUNCTION(trim, 1, 3, 0, trimFunc ),
87535: FUNCTION(trim, 2, 3, 0, trimFunc ),
87536: FUNCTION(min, -1, 0, 1, minmaxFunc ),
87537: FUNCTION(min, 0, 0, 1, 0 ),
87538: AGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize ),
87539: FUNCTION(max, -1, 1, 1, minmaxFunc ),
87540: FUNCTION(max, 0, 1, 1, 0 ),
87541: AGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize ),
87542: FUNCTION(typeof, 1, 0, 0, typeofFunc ),
87543: FUNCTION(length, 1, 0, 0, lengthFunc ),
87544: FUNCTION(substr, 2, 0, 0, substrFunc ),
87545: FUNCTION(substr, 3, 0, 0, substrFunc ),
87546: FUNCTION(abs, 1, 0, 0, absFunc ),
87547: #ifndef SQLITE_OMIT_FLOATING_POINT
87548: FUNCTION(round, 1, 0, 0, roundFunc ),
87549: FUNCTION(round, 2, 0, 0, roundFunc ),
87550: #endif
87551: FUNCTION(upper, 1, 0, 0, upperFunc ),
87552: FUNCTION(lower, 1, 0, 0, lowerFunc ),
87553: FUNCTION(coalesce, 1, 0, 0, 0 ),
87554: FUNCTION(coalesce, 0, 0, 0, 0 ),
87555: /* FUNCTION(coalesce, -1, 0, 0, ifnullFunc ), */
87556: {-1,SQLITE_UTF8,SQLITE_FUNC_COALESCE,0,0,ifnullFunc,0,0,"coalesce",0,0},
87557: FUNCTION(hex, 1, 0, 0, hexFunc ),
87558: /* FUNCTION(ifnull, 2, 0, 0, ifnullFunc ), */
87559: {2,SQLITE_UTF8,SQLITE_FUNC_COALESCE,0,0,ifnullFunc,0,0,"ifnull",0,0},
87560: FUNCTION(random, 0, 0, 0, randomFunc ),
87561: FUNCTION(randomblob, 1, 0, 0, randomBlob ),
87562: FUNCTION(nullif, 2, 0, 1, nullifFunc ),
87563: FUNCTION(sqlite_version, 0, 0, 0, versionFunc ),
87564: FUNCTION(sqlite_source_id, 0, 0, 0, sourceidFunc ),
87565: FUNCTION(sqlite_log, 2, 0, 0, errlogFunc ),
87566: #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
87567: FUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc ),
87568: FUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc ),
87569: #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
87570: FUNCTION(quote, 1, 0, 0, quoteFunc ),
87571: FUNCTION(last_insert_rowid, 0, 0, 0, last_insert_rowid),
87572: FUNCTION(changes, 0, 0, 0, changes ),
87573: FUNCTION(total_changes, 0, 0, 0, total_changes ),
87574: FUNCTION(replace, 3, 0, 0, replaceFunc ),
87575: FUNCTION(zeroblob, 1, 0, 0, zeroblobFunc ),
87576: #ifdef SQLITE_SOUNDEX
87577: FUNCTION(soundex, 1, 0, 0, soundexFunc ),
87578: #endif
87579: #ifndef SQLITE_OMIT_LOAD_EXTENSION
87580: FUNCTION(load_extension, 1, 0, 0, loadExt ),
87581: FUNCTION(load_extension, 2, 0, 0, loadExt ),
87582: #endif
87583: AGGREGATE(sum, 1, 0, 0, sumStep, sumFinalize ),
87584: AGGREGATE(total, 1, 0, 0, sumStep, totalFinalize ),
87585: AGGREGATE(avg, 1, 0, 0, sumStep, avgFinalize ),
87586: /* AGGREGATE(count, 0, 0, 0, countStep, countFinalize ), */
87587: {0,SQLITE_UTF8,SQLITE_FUNC_COUNT,0,0,0,countStep,countFinalize,"count",0,0},
87588: AGGREGATE(count, 1, 0, 0, countStep, countFinalize ),
87589: AGGREGATE(group_concat, 1, 0, 0, groupConcatStep, groupConcatFinalize),
87590: AGGREGATE(group_concat, 2, 0, 0, groupConcatStep, groupConcatFinalize),
87591:
87592: LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
87593: #ifdef SQLITE_CASE_SENSITIVE_LIKE
87594: LIKEFUNC(like, 2, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
87595: LIKEFUNC(like, 3, &likeInfoAlt, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
87596: #else
87597: LIKEFUNC(like, 2, &likeInfoNorm, SQLITE_FUNC_LIKE),
87598: LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE),
87599: #endif
87600: };
87601:
87602: int i;
87603: FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
87604: FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aBuiltinFunc);
87605:
87606: for(i=0; i<ArraySize(aBuiltinFunc); i++){
87607: sqlite3FuncDefInsert(pHash, &aFunc[i]);
87608: }
87609: sqlite3RegisterDateTimeFunctions();
87610: #ifndef SQLITE_OMIT_ALTERTABLE
87611: sqlite3AlterFunctions();
87612: #endif
87613: }
87614:
87615: /************** End of func.c ************************************************/
87616: /************** Begin file fkey.c ********************************************/
87617: /*
87618: **
87619: ** The author disclaims copyright to this source code. In place of
87620: ** a legal notice, here is a blessing:
87621: **
87622: ** May you do good and not evil.
87623: ** May you find forgiveness for yourself and forgive others.
87624: ** May you share freely, never taking more than you give.
87625: **
87626: *************************************************************************
87627: ** This file contains code used by the compiler to add foreign key
87628: ** support to compiled SQL statements.
87629: */
87630:
87631: #ifndef SQLITE_OMIT_FOREIGN_KEY
87632: #ifndef SQLITE_OMIT_TRIGGER
87633:
87634: /*
87635: ** Deferred and Immediate FKs
87636: ** --------------------------
87637: **
87638: ** Foreign keys in SQLite come in two flavours: deferred and immediate.
87639: ** If an immediate foreign key constraint is violated, SQLITE_CONSTRAINT
87640: ** is returned and the current statement transaction rolled back. If a
87641: ** deferred foreign key constraint is violated, no action is taken
87642: ** immediately. However if the application attempts to commit the
87643: ** transaction before fixing the constraint violation, the attempt fails.
87644: **
87645: ** Deferred constraints are implemented using a simple counter associated
87646: ** with the database handle. The counter is set to zero each time a
87647: ** database transaction is opened. Each time a statement is executed
87648: ** that causes a foreign key violation, the counter is incremented. Each
87649: ** time a statement is executed that removes an existing violation from
87650: ** the database, the counter is decremented. When the transaction is
87651: ** committed, the commit fails if the current value of the counter is
87652: ** greater than zero. This scheme has two big drawbacks:
87653: **
87654: ** * When a commit fails due to a deferred foreign key constraint,
87655: ** there is no way to tell which foreign constraint is not satisfied,
87656: ** or which row it is not satisfied for.
87657: **
87658: ** * If the database contains foreign key violations when the
87659: ** transaction is opened, this may cause the mechanism to malfunction.
87660: **
87661: ** Despite these problems, this approach is adopted as it seems simpler
87662: ** than the alternatives.
87663: **
87664: ** INSERT operations:
87665: **
87666: ** I.1) For each FK for which the table is the child table, search
87667: ** the parent table for a match. If none is found increment the
87668: ** constraint counter.
87669: **
87670: ** I.2) For each FK for which the table is the parent table,
87671: ** search the child table for rows that correspond to the new
87672: ** row in the parent table. Decrement the counter for each row
87673: ** found (as the constraint is now satisfied).
87674: **
87675: ** DELETE operations:
87676: **
87677: ** D.1) For each FK for which the table is the child table,
87678: ** search the parent table for a row that corresponds to the
87679: ** deleted row in the child table. If such a row is not found,
87680: ** decrement the counter.
87681: **
87682: ** D.2) For each FK for which the table is the parent table, search
87683: ** the child table for rows that correspond to the deleted row
87684: ** in the parent table. For each found increment the counter.
87685: **
87686: ** UPDATE operations:
87687: **
87688: ** An UPDATE command requires that all 4 steps above are taken, but only
87689: ** for FK constraints for which the affected columns are actually
87690: ** modified (values must be compared at runtime).
87691: **
87692: ** Note that I.1 and D.1 are very similar operations, as are I.2 and D.2.
87693: ** This simplifies the implementation a bit.
87694: **
87695: ** For the purposes of immediate FK constraints, the OR REPLACE conflict
87696: ** resolution is considered to delete rows before the new row is inserted.
87697: ** If a delete caused by OR REPLACE violates an FK constraint, an exception
87698: ** is thrown, even if the FK constraint would be satisfied after the new
87699: ** row is inserted.
87700: **
87701: ** Immediate constraints are usually handled similarly. The only difference
87702: ** is that the counter used is stored as part of each individual statement
87703: ** object (struct Vdbe). If, after the statement has run, its immediate
87704: ** constraint counter is greater than zero, it returns SQLITE_CONSTRAINT
87705: ** and the statement transaction is rolled back. An exception is an INSERT
87706: ** statement that inserts a single row only (no triggers). In this case,
87707: ** instead of using a counter, an exception is thrown immediately if the
87708: ** INSERT violates a foreign key constraint. This is necessary as such
87709: ** an INSERT does not open a statement transaction.
87710: **
87711: ** TODO: How should dropping a table be handled? How should renaming a
87712: ** table be handled?
87713: **
87714: **
87715: ** Query API Notes
87716: ** ---------------
87717: **
87718: ** Before coding an UPDATE or DELETE row operation, the code-generator
87719: ** for those two operations needs to know whether or not the operation
87720: ** requires any FK processing and, if so, which columns of the original
87721: ** row are required by the FK processing VDBE code (i.e. if FKs were
87722: ** implemented using triggers, which of the old.* columns would be
87723: ** accessed). No information is required by the code-generator before
87724: ** coding an INSERT operation. The functions used by the UPDATE/DELETE
87725: ** generation code to query for this information are:
87726: **
87727: ** sqlite3FkRequired() - Test to see if FK processing is required.
87728: ** sqlite3FkOldmask() - Query for the set of required old.* columns.
87729: **
87730: **
87731: ** Externally accessible module functions
87732: ** --------------------------------------
87733: **
87734: ** sqlite3FkCheck() - Check for foreign key violations.
87735: ** sqlite3FkActions() - Code triggers for ON UPDATE/ON DELETE actions.
87736: ** sqlite3FkDelete() - Delete an FKey structure.
87737: */
87738:
87739: /*
87740: ** VDBE Calling Convention
87741: ** -----------------------
87742: **
87743: ** Example:
87744: **
87745: ** For the following INSERT statement:
87746: **
87747: ** CREATE TABLE t1(a, b INTEGER PRIMARY KEY, c);
87748: ** INSERT INTO t1 VALUES(1, 2, 3.1);
87749: **
87750: ** Register (x): 2 (type integer)
87751: ** Register (x+1): 1 (type integer)
87752: ** Register (x+2): NULL (type NULL)
87753: ** Register (x+3): 3.1 (type real)
87754: */
87755:
87756: /*
87757: ** A foreign key constraint requires that the key columns in the parent
87758: ** table are collectively subject to a UNIQUE or PRIMARY KEY constraint.
87759: ** Given that pParent is the parent table for foreign key constraint pFKey,
87760: ** search the schema a unique index on the parent key columns.
87761: **
87762: ** If successful, zero is returned. If the parent key is an INTEGER PRIMARY
87763: ** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx
87764: ** is set to point to the unique index.
87765: **
87766: ** If the parent key consists of a single column (the foreign key constraint
87767: ** is not a composite foreign key), output variable *paiCol is set to NULL.
87768: ** Otherwise, it is set to point to an allocated array of size N, where
87769: ** N is the number of columns in the parent key. The first element of the
87770: ** array is the index of the child table column that is mapped by the FK
87771: ** constraint to the parent table column stored in the left-most column
87772: ** of index *ppIdx. The second element of the array is the index of the
87773: ** child table column that corresponds to the second left-most column of
87774: ** *ppIdx, and so on.
87775: **
87776: ** If the required index cannot be found, either because:
87777: **
87778: ** 1) The named parent key columns do not exist, or
87779: **
87780: ** 2) The named parent key columns do exist, but are not subject to a
87781: ** UNIQUE or PRIMARY KEY constraint, or
87782: **
87783: ** 3) No parent key columns were provided explicitly as part of the
87784: ** foreign key definition, and the parent table does not have a
87785: ** PRIMARY KEY, or
87786: **
87787: ** 4) No parent key columns were provided explicitly as part of the
87788: ** foreign key definition, and the PRIMARY KEY of the parent table
87789: ** consists of a a different number of columns to the child key in
87790: ** the child table.
87791: **
87792: ** then non-zero is returned, and a "foreign key mismatch" error loaded
87793: ** into pParse. If an OOM error occurs, non-zero is returned and the
87794: ** pParse->db->mallocFailed flag is set.
87795: */
87796: static int locateFkeyIndex(
87797: Parse *pParse, /* Parse context to store any error in */
87798: Table *pParent, /* Parent table of FK constraint pFKey */
87799: FKey *pFKey, /* Foreign key to find index for */
87800: Index **ppIdx, /* OUT: Unique index on parent table */
87801: int **paiCol /* OUT: Map of index columns in pFKey */
87802: ){
87803: Index *pIdx = 0; /* Value to return via *ppIdx */
87804: int *aiCol = 0; /* Value to return via *paiCol */
87805: int nCol = pFKey->nCol; /* Number of columns in parent key */
87806: char *zKey = pFKey->aCol[0].zCol; /* Name of left-most parent key column */
87807:
87808: /* The caller is responsible for zeroing output parameters. */
87809: assert( ppIdx && *ppIdx==0 );
87810: assert( !paiCol || *paiCol==0 );
87811: assert( pParse );
87812:
87813: /* If this is a non-composite (single column) foreign key, check if it
87814: ** maps to the INTEGER PRIMARY KEY of table pParent. If so, leave *ppIdx
87815: ** and *paiCol set to zero and return early.
87816: **
87817: ** Otherwise, for a composite foreign key (more than one column), allocate
87818: ** space for the aiCol array (returned via output parameter *paiCol).
87819: ** Non-composite foreign keys do not require the aiCol array.
87820: */
87821: if( nCol==1 ){
87822: /* The FK maps to the IPK if any of the following are true:
87823: **
87824: ** 1) There is an INTEGER PRIMARY KEY column and the FK is implicitly
87825: ** mapped to the primary key of table pParent, or
87826: ** 2) The FK is explicitly mapped to a column declared as INTEGER
87827: ** PRIMARY KEY.
87828: */
87829: if( pParent->iPKey>=0 ){
87830: if( !zKey ) return 0;
87831: if( !sqlite3StrICmp(pParent->aCol[pParent->iPKey].zName, zKey) ) return 0;
87832: }
87833: }else if( paiCol ){
87834: assert( nCol>1 );
87835: aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
87836: if( !aiCol ) return 1;
87837: *paiCol = aiCol;
87838: }
87839:
87840: for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
87841: if( pIdx->nColumn==nCol && pIdx->onError!=OE_None ){
87842: /* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number
87843: ** of columns. If each indexed column corresponds to a foreign key
87844: ** column of pFKey, then this index is a winner. */
87845:
87846: if( zKey==0 ){
87847: /* If zKey is NULL, then this foreign key is implicitly mapped to
87848: ** the PRIMARY KEY of table pParent. The PRIMARY KEY index may be
87849: ** identified by the test (Index.autoIndex==2). */
87850: if( pIdx->autoIndex==2 ){
87851: if( aiCol ){
87852: int i;
87853: for(i=0; i<nCol; i++) aiCol[i] = pFKey->aCol[i].iFrom;
87854: }
87855: break;
87856: }
87857: }else{
87858: /* If zKey is non-NULL, then this foreign key was declared to
87859: ** map to an explicit list of columns in table pParent. Check if this
87860: ** index matches those columns. Also, check that the index uses
87861: ** the default collation sequences for each column. */
87862: int i, j;
87863: for(i=0; i<nCol; i++){
87864: int iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
87865: char *zDfltColl; /* Def. collation for column */
87866: char *zIdxCol; /* Name of indexed column */
87867:
87868: /* If the index uses a collation sequence that is different from
87869: ** the default collation sequence for the column, this index is
87870: ** unusable. Bail out early in this case. */
87871: zDfltColl = pParent->aCol[iCol].zColl;
87872: if( !zDfltColl ){
87873: zDfltColl = "BINARY";
87874: }
87875: if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break;
87876:
87877: zIdxCol = pParent->aCol[iCol].zName;
87878: for(j=0; j<nCol; j++){
87879: if( sqlite3StrICmp(pFKey->aCol[j].zCol, zIdxCol)==0 ){
87880: if( aiCol ) aiCol[i] = pFKey->aCol[j].iFrom;
87881: break;
87882: }
87883: }
87884: if( j==nCol ) break;
87885: }
87886: if( i==nCol ) break; /* pIdx is usable */
87887: }
87888: }
87889: }
87890:
87891: if( !pIdx ){
87892: if( !pParse->disableTriggers ){
87893: sqlite3ErrorMsg(pParse, "foreign key mismatch");
87894: }
87895: sqlite3DbFree(pParse->db, aiCol);
87896: return 1;
87897: }
87898:
87899: *ppIdx = pIdx;
87900: return 0;
87901: }
87902:
87903: /*
87904: ** This function is called when a row is inserted into or deleted from the
87905: ** child table of foreign key constraint pFKey. If an SQL UPDATE is executed
87906: ** on the child table of pFKey, this function is invoked twice for each row
87907: ** affected - once to "delete" the old row, and then again to "insert" the
87908: ** new row.
87909: **
87910: ** Each time it is called, this function generates VDBE code to locate the
87911: ** row in the parent table that corresponds to the row being inserted into
87912: ** or deleted from the child table. If the parent row can be found, no
87913: ** special action is taken. Otherwise, if the parent row can *not* be
87914: ** found in the parent table:
87915: **
87916: ** Operation | FK type | Action taken
87917: ** --------------------------------------------------------------------------
87918: ** INSERT immediate Increment the "immediate constraint counter".
87919: **
87920: ** DELETE immediate Decrement the "immediate constraint counter".
87921: **
87922: ** INSERT deferred Increment the "deferred constraint counter".
87923: **
87924: ** DELETE deferred Decrement the "deferred constraint counter".
87925: **
87926: ** These operations are identified in the comment at the top of this file
87927: ** (fkey.c) as "I.1" and "D.1".
87928: */
87929: static void fkLookupParent(
87930: Parse *pParse, /* Parse context */
87931: int iDb, /* Index of database housing pTab */
87932: Table *pTab, /* Parent table of FK pFKey */
87933: Index *pIdx, /* Unique index on parent key columns in pTab */
87934: FKey *pFKey, /* Foreign key constraint */
87935: int *aiCol, /* Map from parent key columns to child table columns */
87936: int regData, /* Address of array containing child table row */
87937: int nIncr, /* Increment constraint counter by this */
87938: int isIgnore /* If true, pretend pTab contains all NULL values */
87939: ){
87940: int i; /* Iterator variable */
87941: Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */
87942: int iCur = pParse->nTab - 1; /* Cursor number to use */
87943: int iOk = sqlite3VdbeMakeLabel(v); /* jump here if parent key found */
87944:
87945: /* If nIncr is less than zero, then check at runtime if there are any
87946: ** outstanding constraints to resolve. If there are not, there is no need
87947: ** to check if deleting this row resolves any outstanding violations.
87948: **
87949: ** Check if any of the key columns in the child table row are NULL. If
87950: ** any are, then the constraint is considered satisfied. No need to
87951: ** search for a matching row in the parent table. */
87952: if( nIncr<0 ){
87953: sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk);
87954: }
87955: for(i=0; i<pFKey->nCol; i++){
87956: int iReg = aiCol[i] + regData + 1;
87957: sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk);
87958: }
87959:
87960: if( isIgnore==0 ){
87961: if( pIdx==0 ){
87962: /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY
87963: ** column of the parent table (table pTab). */
87964: int iMustBeInt; /* Address of MustBeInt instruction */
87965: int regTemp = sqlite3GetTempReg(pParse);
87966:
87967: /* Invoke MustBeInt to coerce the child key value to an integer (i.e.
87968: ** apply the affinity of the parent key). If this fails, then there
87969: ** is no matching parent key. Before using MustBeInt, make a copy of
87970: ** the value. Otherwise, the value inserted into the child key column
87971: ** will have INTEGER affinity applied to it, which may not be correct. */
87972: sqlite3VdbeAddOp2(v, OP_SCopy, aiCol[0]+1+regData, regTemp);
87973: iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0);
87974:
87975: /* If the parent table is the same as the child table, and we are about
87976: ** to increment the constraint-counter (i.e. this is an INSERT operation),
87977: ** then check if the row being inserted matches itself. If so, do not
87978: ** increment the constraint-counter. */
87979: if( pTab==pFKey->pFrom && nIncr==1 ){
87980: sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp);
87981: }
87982:
87983: sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
87984: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp);
87985: sqlite3VdbeAddOp2(v, OP_Goto, 0, iOk);
87986: sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
87987: sqlite3VdbeJumpHere(v, iMustBeInt);
87988: sqlite3ReleaseTempReg(pParse, regTemp);
87989: }else{
87990: int nCol = pFKey->nCol;
87991: int regTemp = sqlite3GetTempRange(pParse, nCol);
87992: int regRec = sqlite3GetTempReg(pParse);
87993: KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
87994:
87995: sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
87996: sqlite3VdbeChangeP4(v, -1, (char*)pKey, P4_KEYINFO_HANDOFF);
87997: for(i=0; i<nCol; i++){
87998: sqlite3VdbeAddOp2(v, OP_Copy, aiCol[i]+1+regData, regTemp+i);
87999: }
88000:
88001: /* If the parent table is the same as the child table, and we are about
88002: ** to increment the constraint-counter (i.e. this is an INSERT operation),
88003: ** then check if the row being inserted matches itself. If so, do not
88004: ** increment the constraint-counter.
88005: **
88006: ** If any of the parent-key values are NULL, then the row cannot match
88007: ** itself. So set JUMPIFNULL to make sure we do the OP_Found if any
88008: ** of the parent-key values are NULL (at this point it is known that
88009: ** none of the child key values are).
88010: */
88011: if( pTab==pFKey->pFrom && nIncr==1 ){
88012: int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
88013: for(i=0; i<nCol; i++){
88014: int iChild = aiCol[i]+1+regData;
88015: int iParent = pIdx->aiColumn[i]+1+regData;
88016: assert( aiCol[i]!=pTab->iPKey );
88017: if( pIdx->aiColumn[i]==pTab->iPKey ){
88018: /* The parent key is a composite key that includes the IPK column */
88019: iParent = regData;
88020: }
88021: sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent);
88022: sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
88023: }
88024: sqlite3VdbeAddOp2(v, OP_Goto, 0, iOk);
88025: }
88026:
88027: sqlite3VdbeAddOp3(v, OP_MakeRecord, regTemp, nCol, regRec);
88028: sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v,pIdx), P4_TRANSIENT);
88029: sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regRec, 0);
88030:
88031: sqlite3ReleaseTempReg(pParse, regRec);
88032: sqlite3ReleaseTempRange(pParse, regTemp, nCol);
88033: }
88034: }
88035:
88036: if( !pFKey->isDeferred && !pParse->pToplevel && !pParse->isMultiWrite ){
88037: /* Special case: If this is an INSERT statement that will insert exactly
88038: ** one row into the table, raise a constraint immediately instead of
88039: ** incrementing a counter. This is necessary as the VM code is being
88040: ** generated for will not open a statement transaction. */
88041: assert( nIncr==1 );
88042: sqlite3HaltConstraint(
88043: pParse, OE_Abort, "foreign key constraint failed", P4_STATIC
88044: );
88045: }else{
88046: if( nIncr>0 && pFKey->isDeferred==0 ){
88047: sqlite3ParseToplevel(pParse)->mayAbort = 1;
88048: }
88049: sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
88050: }
88051:
88052: sqlite3VdbeResolveLabel(v, iOk);
88053: sqlite3VdbeAddOp1(v, OP_Close, iCur);
88054: }
88055:
88056: /*
88057: ** This function is called to generate code executed when a row is deleted
88058: ** from the parent table of foreign key constraint pFKey and, if pFKey is
88059: ** deferred, when a row is inserted into the same table. When generating
88060: ** code for an SQL UPDATE operation, this function may be called twice -
88061: ** once to "delete" the old row and once to "insert" the new row.
88062: **
88063: ** The code generated by this function scans through the rows in the child
88064: ** table that correspond to the parent table row being deleted or inserted.
88065: ** For each child row found, one of the following actions is taken:
88066: **
88067: ** Operation | FK type | Action taken
88068: ** --------------------------------------------------------------------------
88069: ** DELETE immediate Increment the "immediate constraint counter".
88070: ** Or, if the ON (UPDATE|DELETE) action is RESTRICT,
88071: ** throw a "foreign key constraint failed" exception.
88072: **
88073: ** INSERT immediate Decrement the "immediate constraint counter".
88074: **
88075: ** DELETE deferred Increment the "deferred constraint counter".
88076: ** Or, if the ON (UPDATE|DELETE) action is RESTRICT,
88077: ** throw a "foreign key constraint failed" exception.
88078: **
88079: ** INSERT deferred Decrement the "deferred constraint counter".
88080: **
88081: ** These operations are identified in the comment at the top of this file
88082: ** (fkey.c) as "I.2" and "D.2".
88083: */
88084: static void fkScanChildren(
88085: Parse *pParse, /* Parse context */
88086: SrcList *pSrc, /* SrcList containing the table to scan */
88087: Table *pTab,
88088: Index *pIdx, /* Foreign key index */
88089: FKey *pFKey, /* Foreign key relationship */
88090: int *aiCol, /* Map from pIdx cols to child table cols */
88091: int regData, /* Referenced table data starts here */
88092: int nIncr /* Amount to increment deferred counter by */
88093: ){
88094: sqlite3 *db = pParse->db; /* Database handle */
88095: int i; /* Iterator variable */
88096: Expr *pWhere = 0; /* WHERE clause to scan with */
88097: NameContext sNameContext; /* Context used to resolve WHERE clause */
88098: WhereInfo *pWInfo; /* Context used by sqlite3WhereXXX() */
88099: int iFkIfZero = 0; /* Address of OP_FkIfZero */
88100: Vdbe *v = sqlite3GetVdbe(pParse);
88101:
88102: assert( !pIdx || pIdx->pTable==pTab );
88103:
88104: if( nIncr<0 ){
88105: iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0);
88106: }
88107:
88108: /* Create an Expr object representing an SQL expression like:
88109: **
88110: ** <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ...
88111: **
88112: ** The collation sequence used for the comparison should be that of
88113: ** the parent key columns. The affinity of the parent key column should
88114: ** be applied to each child key value before the comparison takes place.
88115: */
88116: for(i=0; i<pFKey->nCol; i++){
88117: Expr *pLeft; /* Value from parent table row */
88118: Expr *pRight; /* Column ref to child table */
88119: Expr *pEq; /* Expression (pLeft = pRight) */
88120: int iCol; /* Index of column in child table */
88121: const char *zCol; /* Name of column in child table */
88122:
88123: pLeft = sqlite3Expr(db, TK_REGISTER, 0);
88124: if( pLeft ){
88125: /* Set the collation sequence and affinity of the LHS of each TK_EQ
88126: ** expression to the parent key column defaults. */
88127: if( pIdx ){
88128: Column *pCol;
88129: iCol = pIdx->aiColumn[i];
88130: pCol = &pTab->aCol[iCol];
88131: if( pTab->iPKey==iCol ) iCol = -1;
88132: pLeft->iTable = regData+iCol+1;
88133: pLeft->affinity = pCol->affinity;
88134: pLeft->pColl = sqlite3LocateCollSeq(pParse, pCol->zColl);
88135: }else{
88136: pLeft->iTable = regData;
88137: pLeft->affinity = SQLITE_AFF_INTEGER;
88138: }
88139: }
88140: iCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
88141: assert( iCol>=0 );
88142: zCol = pFKey->pFrom->aCol[iCol].zName;
88143: pRight = sqlite3Expr(db, TK_ID, zCol);
88144: pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0);
88145: pWhere = sqlite3ExprAnd(db, pWhere, pEq);
88146: }
88147:
88148: /* If the child table is the same as the parent table, and this scan
88149: ** is taking place as part of a DELETE operation (operation D.2), omit the
88150: ** row being deleted from the scan by adding ($rowid != rowid) to the WHERE
88151: ** clause, where $rowid is the rowid of the row being deleted. */
88152: if( pTab==pFKey->pFrom && nIncr>0 ){
88153: Expr *pEq; /* Expression (pLeft = pRight) */
88154: Expr *pLeft; /* Value from parent table row */
88155: Expr *pRight; /* Column ref to child table */
88156: pLeft = sqlite3Expr(db, TK_REGISTER, 0);
88157: pRight = sqlite3Expr(db, TK_COLUMN, 0);
88158: if( pLeft && pRight ){
88159: pLeft->iTable = regData;
88160: pLeft->affinity = SQLITE_AFF_INTEGER;
88161: pRight->iTable = pSrc->a[0].iCursor;
88162: pRight->iColumn = -1;
88163: }
88164: pEq = sqlite3PExpr(pParse, TK_NE, pLeft, pRight, 0);
88165: pWhere = sqlite3ExprAnd(db, pWhere, pEq);
88166: }
88167:
88168: /* Resolve the references in the WHERE clause. */
88169: memset(&sNameContext, 0, sizeof(NameContext));
88170: sNameContext.pSrcList = pSrc;
88171: sNameContext.pParse = pParse;
88172: sqlite3ResolveExprNames(&sNameContext, pWhere);
88173:
88174: /* Create VDBE to loop through the entries in pSrc that match the WHERE
88175: ** clause. If the constraint is not deferred, throw an exception for
88176: ** each row found. Otherwise, for deferred constraints, increment the
88177: ** deferred constraint counter by nIncr for each row selected. */
88178: pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0);
88179: if( nIncr>0 && pFKey->isDeferred==0 ){
88180: sqlite3ParseToplevel(pParse)->mayAbort = 1;
88181: }
88182: sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
88183: if( pWInfo ){
88184: sqlite3WhereEnd(pWInfo);
88185: }
88186:
88187: /* Clean up the WHERE clause constructed above. */
88188: sqlite3ExprDelete(db, pWhere);
88189: if( iFkIfZero ){
88190: sqlite3VdbeJumpHere(v, iFkIfZero);
88191: }
88192: }
88193:
88194: /*
88195: ** This function returns a pointer to the head of a linked list of FK
88196: ** constraints for which table pTab is the parent table. For example,
88197: ** given the following schema:
88198: **
88199: ** CREATE TABLE t1(a PRIMARY KEY);
88200: ** CREATE TABLE t2(b REFERENCES t1(a);
88201: **
88202: ** Calling this function with table "t1" as an argument returns a pointer
88203: ** to the FKey structure representing the foreign key constraint on table
88204: ** "t2". Calling this function with "t2" as the argument would return a
88205: ** NULL pointer (as there are no FK constraints for which t2 is the parent
88206: ** table).
88207: */
88208: SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *pTab){
88209: int nName = sqlite3Strlen30(pTab->zName);
88210: return (FKey *)sqlite3HashFind(&pTab->pSchema->fkeyHash, pTab->zName, nName);
88211: }
88212:
88213: /*
88214: ** The second argument is a Trigger structure allocated by the
88215: ** fkActionTrigger() routine. This function deletes the Trigger structure
88216: ** and all of its sub-components.
88217: **
88218: ** The Trigger structure or any of its sub-components may be allocated from
88219: ** the lookaside buffer belonging to database handle dbMem.
88220: */
88221: static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){
88222: if( p ){
88223: TriggerStep *pStep = p->step_list;
88224: sqlite3ExprDelete(dbMem, pStep->pWhere);
88225: sqlite3ExprListDelete(dbMem, pStep->pExprList);
88226: sqlite3SelectDelete(dbMem, pStep->pSelect);
88227: sqlite3ExprDelete(dbMem, p->pWhen);
88228: sqlite3DbFree(dbMem, p);
88229: }
88230: }
88231:
88232: /*
88233: ** This function is called to generate code that runs when table pTab is
88234: ** being dropped from the database. The SrcList passed as the second argument
88235: ** to this function contains a single entry guaranteed to resolve to
88236: ** table pTab.
88237: **
88238: ** Normally, no code is required. However, if either
88239: **
88240: ** (a) The table is the parent table of a FK constraint, or
88241: ** (b) The table is the child table of a deferred FK constraint and it is
88242: ** determined at runtime that there are outstanding deferred FK
88243: ** constraint violations in the database,
88244: **
88245: ** then the equivalent of "DELETE FROM <tbl>" is executed before dropping
88246: ** the table from the database. Triggers are disabled while running this
88247: ** DELETE, but foreign key actions are not.
88248: */
88249: SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
88250: sqlite3 *db = pParse->db;
88251: if( (db->flags&SQLITE_ForeignKeys) && !IsVirtual(pTab) && !pTab->pSelect ){
88252: int iSkip = 0;
88253: Vdbe *v = sqlite3GetVdbe(pParse);
88254:
88255: assert( v ); /* VDBE has already been allocated */
88256: if( sqlite3FkReferences(pTab)==0 ){
88257: /* Search for a deferred foreign key constraint for which this table
88258: ** is the child table. If one cannot be found, return without
88259: ** generating any VDBE code. If one can be found, then jump over
88260: ** the entire DELETE if there are no outstanding deferred constraints
88261: ** when this statement is run. */
88262: FKey *p;
88263: for(p=pTab->pFKey; p; p=p->pNextFrom){
88264: if( p->isDeferred ) break;
88265: }
88266: if( !p ) return;
88267: iSkip = sqlite3VdbeMakeLabel(v);
88268: sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip);
88269: }
88270:
88271: pParse->disableTriggers = 1;
88272: sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0);
88273: pParse->disableTriggers = 0;
88274:
88275: /* If the DELETE has generated immediate foreign key constraint
88276: ** violations, halt the VDBE and return an error at this point, before
88277: ** any modifications to the schema are made. This is because statement
88278: ** transactions are not able to rollback schema changes. */
88279: sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2);
88280: sqlite3HaltConstraint(
88281: pParse, OE_Abort, "foreign key constraint failed", P4_STATIC
88282: );
88283:
88284: if( iSkip ){
88285: sqlite3VdbeResolveLabel(v, iSkip);
88286: }
88287: }
88288: }
88289:
88290: /*
88291: ** This function is called when inserting, deleting or updating a row of
88292: ** table pTab to generate VDBE code to perform foreign key constraint
88293: ** processing for the operation.
88294: **
88295: ** For a DELETE operation, parameter regOld is passed the index of the
88296: ** first register in an array of (pTab->nCol+1) registers containing the
88297: ** rowid of the row being deleted, followed by each of the column values
88298: ** of the row being deleted, from left to right. Parameter regNew is passed
88299: ** zero in this case.
88300: **
88301: ** For an INSERT operation, regOld is passed zero and regNew is passed the
88302: ** first register of an array of (pTab->nCol+1) registers containing the new
88303: ** row data.
88304: **
88305: ** For an UPDATE operation, this function is called twice. Once before
88306: ** the original record is deleted from the table using the calling convention
88307: ** described for DELETE. Then again after the original record is deleted
88308: ** but before the new record is inserted using the INSERT convention.
88309: */
88310: SQLITE_PRIVATE void sqlite3FkCheck(
88311: Parse *pParse, /* Parse context */
88312: Table *pTab, /* Row is being deleted from this table */
88313: int regOld, /* Previous row data is stored here */
88314: int regNew /* New row data is stored here */
88315: ){
88316: sqlite3 *db = pParse->db; /* Database handle */
88317: FKey *pFKey; /* Used to iterate through FKs */
88318: int iDb; /* Index of database containing pTab */
88319: const char *zDb; /* Name of database containing pTab */
88320: int isIgnoreErrors = pParse->disableTriggers;
88321:
88322: /* Exactly one of regOld and regNew should be non-zero. */
88323: assert( (regOld==0)!=(regNew==0) );
88324:
88325: /* If foreign-keys are disabled, this function is a no-op. */
88326: if( (db->flags&SQLITE_ForeignKeys)==0 ) return;
88327:
88328: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
88329: zDb = db->aDb[iDb].zName;
88330:
88331: /* Loop through all the foreign key constraints for which pTab is the
88332: ** child table (the table that the foreign key definition is part of). */
88333: for(pFKey=pTab->pFKey; pFKey; pFKey=pFKey->pNextFrom){
88334: Table *pTo; /* Parent table of foreign key pFKey */
88335: Index *pIdx = 0; /* Index on key columns in pTo */
88336: int *aiFree = 0;
88337: int *aiCol;
88338: int iCol;
88339: int i;
88340: int isIgnore = 0;
88341:
88342: /* Find the parent table of this foreign key. Also find a unique index
88343: ** on the parent key columns in the parent table. If either of these
88344: ** schema items cannot be located, set an error in pParse and return
88345: ** early. */
88346: if( pParse->disableTriggers ){
88347: pTo = sqlite3FindTable(db, pFKey->zTo, zDb);
88348: }else{
88349: pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);
88350: }
88351: if( !pTo || locateFkeyIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){
88352: assert( isIgnoreErrors==0 || (regOld!=0 && regNew==0) );
88353: if( !isIgnoreErrors || db->mallocFailed ) return;
88354: if( pTo==0 ){
88355: /* If isIgnoreErrors is true, then a table is being dropped. In this
88356: ** case SQLite runs a "DELETE FROM xxx" on the table being dropped
88357: ** before actually dropping it in order to check FK constraints.
88358: ** If the parent table of an FK constraint on the current table is
88359: ** missing, behave as if it is empty. i.e. decrement the relevant
88360: ** FK counter for each row of the current table with non-NULL keys.
88361: */
88362: Vdbe *v = sqlite3GetVdbe(pParse);
88363: int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
88364: for(i=0; i<pFKey->nCol; i++){
88365: int iReg = pFKey->aCol[i].iFrom + regOld + 1;
88366: sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump);
88367: }
88368: sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1);
88369: }
88370: continue;
88371: }
88372: assert( pFKey->nCol==1 || (aiFree && pIdx) );
88373:
88374: if( aiFree ){
88375: aiCol = aiFree;
88376: }else{
88377: iCol = pFKey->aCol[0].iFrom;
88378: aiCol = &iCol;
88379: }
88380: for(i=0; i<pFKey->nCol; i++){
88381: if( aiCol[i]==pTab->iPKey ){
88382: aiCol[i] = -1;
88383: }
88384: #ifndef SQLITE_OMIT_AUTHORIZATION
88385: /* Request permission to read the parent key columns. If the
88386: ** authorization callback returns SQLITE_IGNORE, behave as if any
88387: ** values read from the parent table are NULL. */
88388: if( db->xAuth ){
88389: int rcauth;
88390: char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
88391: rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
88392: isIgnore = (rcauth==SQLITE_IGNORE);
88393: }
88394: #endif
88395: }
88396:
88397: /* Take a shared-cache advisory read-lock on the parent table. Allocate
88398: ** a cursor to use to search the unique index on the parent key columns
88399: ** in the parent table. */
88400: sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
88401: pParse->nTab++;
88402:
88403: if( regOld!=0 ){
88404: /* A row is being removed from the child table. Search for the parent.
88405: ** If the parent does not exist, removing the child row resolves an
88406: ** outstanding foreign key constraint violation. */
88407: fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1,isIgnore);
88408: }
88409: if( regNew!=0 ){
88410: /* A row is being added to the child table. If a parent row cannot
88411: ** be found, adding the child row has violated the FK constraint. */
88412: fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1,isIgnore);
88413: }
88414:
88415: sqlite3DbFree(db, aiFree);
88416: }
88417:
88418: /* Loop through all the foreign key constraints that refer to this table */
88419: for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
88420: Index *pIdx = 0; /* Foreign key index for pFKey */
88421: SrcList *pSrc;
88422: int *aiCol = 0;
88423:
88424: if( !pFKey->isDeferred && !pParse->pToplevel && !pParse->isMultiWrite ){
88425: assert( regOld==0 && regNew!=0 );
88426: /* Inserting a single row into a parent table cannot cause an immediate
88427: ** foreign key violation. So do nothing in this case. */
88428: continue;
88429: }
88430:
88431: if( locateFkeyIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
88432: if( !isIgnoreErrors || db->mallocFailed ) return;
88433: continue;
88434: }
88435: assert( aiCol || pFKey->nCol==1 );
88436:
88437: /* Create a SrcList structure containing a single table (the table
88438: ** the foreign key that refers to this table is attached to). This
88439: ** is required for the sqlite3WhereXXX() interface. */
88440: pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
88441: if( pSrc ){
88442: struct SrcList_item *pItem = pSrc->a;
88443: pItem->pTab = pFKey->pFrom;
88444: pItem->zName = pFKey->pFrom->zName;
88445: pItem->pTab->nRef++;
88446: pItem->iCursor = pParse->nTab++;
88447:
88448: if( regNew!=0 ){
88449: fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
88450: }
88451: if( regOld!=0 ){
88452: /* If there is a RESTRICT action configured for the current operation
88453: ** on the parent table of this FK, then throw an exception
88454: ** immediately if the FK constraint is violated, even if this is a
88455: ** deferred trigger. That's what RESTRICT means. To defer checking
88456: ** the constraint, the FK should specify NO ACTION (represented
88457: ** using OE_None). NO ACTION is the default. */
88458: fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
88459: }
88460: pItem->zName = 0;
88461: sqlite3SrcListDelete(db, pSrc);
88462: }
88463: sqlite3DbFree(db, aiCol);
88464: }
88465: }
88466:
88467: #define COLUMN_MASK(x) (((x)>31) ? 0xffffffff : ((u32)1<<(x)))
88468:
88469: /*
88470: ** This function is called before generating code to update or delete a
88471: ** row contained in table pTab.
88472: */
88473: SQLITE_PRIVATE u32 sqlite3FkOldmask(
88474: Parse *pParse, /* Parse context */
88475: Table *pTab /* Table being modified */
88476: ){
88477: u32 mask = 0;
88478: if( pParse->db->flags&SQLITE_ForeignKeys ){
88479: FKey *p;
88480: int i;
88481: for(p=pTab->pFKey; p; p=p->pNextFrom){
88482: for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
88483: }
88484: for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
88485: Index *pIdx = 0;
88486: locateFkeyIndex(pParse, pTab, p, &pIdx, 0);
88487: if( pIdx ){
88488: for(i=0; i<pIdx->nColumn; i++) mask |= COLUMN_MASK(pIdx->aiColumn[i]);
88489: }
88490: }
88491: }
88492: return mask;
88493: }
88494:
88495: /*
88496: ** This function is called before generating code to update or delete a
88497: ** row contained in table pTab. If the operation is a DELETE, then
88498: ** parameter aChange is passed a NULL value. For an UPDATE, aChange points
88499: ** to an array of size N, where N is the number of columns in table pTab.
88500: ** If the i'th column is not modified by the UPDATE, then the corresponding
88501: ** entry in the aChange[] array is set to -1. If the column is modified,
88502: ** the value is 0 or greater. Parameter chngRowid is set to true if the
88503: ** UPDATE statement modifies the rowid fields of the table.
88504: **
88505: ** If any foreign key processing will be required, this function returns
88506: ** true. If there is no foreign key related processing, this function
88507: ** returns false.
88508: */
88509: SQLITE_PRIVATE int sqlite3FkRequired(
88510: Parse *pParse, /* Parse context */
88511: Table *pTab, /* Table being modified */
88512: int *aChange, /* Non-NULL for UPDATE operations */
88513: int chngRowid /* True for UPDATE that affects rowid */
88514: ){
88515: if( pParse->db->flags&SQLITE_ForeignKeys ){
88516: if( !aChange ){
88517: /* A DELETE operation. Foreign key processing is required if the
88518: ** table in question is either the child or parent table for any
88519: ** foreign key constraint. */
88520: return (sqlite3FkReferences(pTab) || pTab->pFKey);
88521: }else{
88522: /* This is an UPDATE. Foreign key processing is only required if the
88523: ** operation modifies one or more child or parent key columns. */
88524: int i;
88525: FKey *p;
88526:
88527: /* Check if any child key columns are being modified. */
88528: for(p=pTab->pFKey; p; p=p->pNextFrom){
88529: for(i=0; i<p->nCol; i++){
88530: int iChildKey = p->aCol[i].iFrom;
88531: if( aChange[iChildKey]>=0 ) return 1;
88532: if( iChildKey==pTab->iPKey && chngRowid ) return 1;
88533: }
88534: }
88535:
88536: /* Check if any parent key columns are being modified. */
88537: for(p=sqlite3FkReferences(pTab); p; p=p->pNextTo){
88538: for(i=0; i<p->nCol; i++){
88539: char *zKey = p->aCol[i].zCol;
88540: int iKey;
88541: for(iKey=0; iKey<pTab->nCol; iKey++){
88542: Column *pCol = &pTab->aCol[iKey];
88543: if( (zKey ? !sqlite3StrICmp(pCol->zName, zKey) : pCol->isPrimKey) ){
88544: if( aChange[iKey]>=0 ) return 1;
88545: if( iKey==pTab->iPKey && chngRowid ) return 1;
88546: }
88547: }
88548: }
88549: }
88550: }
88551: }
88552: return 0;
88553: }
88554:
88555: /*
88556: ** This function is called when an UPDATE or DELETE operation is being
88557: ** compiled on table pTab, which is the parent table of foreign-key pFKey.
88558: ** If the current operation is an UPDATE, then the pChanges parameter is
88559: ** passed a pointer to the list of columns being modified. If it is a
88560: ** DELETE, pChanges is passed a NULL pointer.
88561: **
88562: ** It returns a pointer to a Trigger structure containing a trigger
88563: ** equivalent to the ON UPDATE or ON DELETE action specified by pFKey.
88564: ** If the action is "NO ACTION" or "RESTRICT", then a NULL pointer is
88565: ** returned (these actions require no special handling by the triggers
88566: ** sub-system, code for them is created by fkScanChildren()).
88567: **
88568: ** For example, if pFKey is the foreign key and pTab is table "p" in
88569: ** the following schema:
88570: **
88571: ** CREATE TABLE p(pk PRIMARY KEY);
88572: ** CREATE TABLE c(ck REFERENCES p ON DELETE CASCADE);
88573: **
88574: ** then the returned trigger structure is equivalent to:
88575: **
88576: ** CREATE TRIGGER ... DELETE ON p BEGIN
88577: ** DELETE FROM c WHERE ck = old.pk;
88578: ** END;
88579: **
88580: ** The returned pointer is cached as part of the foreign key object. It
88581: ** is eventually freed along with the rest of the foreign key object by
88582: ** sqlite3FkDelete().
88583: */
88584: static Trigger *fkActionTrigger(
88585: Parse *pParse, /* Parse context */
88586: Table *pTab, /* Table being updated or deleted from */
88587: FKey *pFKey, /* Foreign key to get action for */
88588: ExprList *pChanges /* Change-list for UPDATE, NULL for DELETE */
88589: ){
88590: sqlite3 *db = pParse->db; /* Database handle */
88591: int action; /* One of OE_None, OE_Cascade etc. */
88592: Trigger *pTrigger; /* Trigger definition to return */
88593: int iAction = (pChanges!=0); /* 1 for UPDATE, 0 for DELETE */
88594:
88595: action = pFKey->aAction[iAction];
88596: pTrigger = pFKey->apTrigger[iAction];
88597:
88598: if( action!=OE_None && !pTrigger ){
88599: u8 enableLookaside; /* Copy of db->lookaside.bEnabled */
88600: char const *zFrom; /* Name of child table */
88601: int nFrom; /* Length in bytes of zFrom */
88602: Index *pIdx = 0; /* Parent key index for this FK */
88603: int *aiCol = 0; /* child table cols -> parent key cols */
88604: TriggerStep *pStep = 0; /* First (only) step of trigger program */
88605: Expr *pWhere = 0; /* WHERE clause of trigger step */
88606: ExprList *pList = 0; /* Changes list if ON UPDATE CASCADE */
88607: Select *pSelect = 0; /* If RESTRICT, "SELECT RAISE(...)" */
88608: int i; /* Iterator variable */
88609: Expr *pWhen = 0; /* WHEN clause for the trigger */
88610:
88611: if( locateFkeyIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
88612: assert( aiCol || pFKey->nCol==1 );
88613:
88614: for(i=0; i<pFKey->nCol; i++){
88615: Token tOld = { "old", 3 }; /* Literal "old" token */
88616: Token tNew = { "new", 3 }; /* Literal "new" token */
88617: Token tFromCol; /* Name of column in child table */
88618: Token tToCol; /* Name of column in parent table */
88619: int iFromCol; /* Idx of column in child table */
88620: Expr *pEq; /* tFromCol = OLD.tToCol */
88621:
88622: iFromCol = aiCol ? aiCol[i] : pFKey->aCol[0].iFrom;
88623: assert( iFromCol>=0 );
88624: tToCol.z = pIdx ? pTab->aCol[pIdx->aiColumn[i]].zName : "oid";
88625: tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName;
88626:
88627: tToCol.n = sqlite3Strlen30(tToCol.z);
88628: tFromCol.n = sqlite3Strlen30(tFromCol.z);
88629:
88630: /* Create the expression "OLD.zToCol = zFromCol". It is important
88631: ** that the "OLD.zToCol" term is on the LHS of the = operator, so
88632: ** that the affinity and collation sequence associated with the
88633: ** parent table are used for the comparison. */
88634: pEq = sqlite3PExpr(pParse, TK_EQ,
88635: sqlite3PExpr(pParse, TK_DOT,
88636: sqlite3PExpr(pParse, TK_ID, 0, 0, &tOld),
88637: sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol)
88638: , 0),
88639: sqlite3PExpr(pParse, TK_ID, 0, 0, &tFromCol)
88640: , 0);
88641: pWhere = sqlite3ExprAnd(db, pWhere, pEq);
88642:
88643: /* For ON UPDATE, construct the next term of the WHEN clause.
88644: ** The final WHEN clause will be like this:
88645: **
88646: ** WHEN NOT(old.col1 IS new.col1 AND ... AND old.colN IS new.colN)
88647: */
88648: if( pChanges ){
88649: pEq = sqlite3PExpr(pParse, TK_IS,
88650: sqlite3PExpr(pParse, TK_DOT,
88651: sqlite3PExpr(pParse, TK_ID, 0, 0, &tOld),
88652: sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol),
88653: 0),
88654: sqlite3PExpr(pParse, TK_DOT,
88655: sqlite3PExpr(pParse, TK_ID, 0, 0, &tNew),
88656: sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol),
88657: 0),
88658: 0);
88659: pWhen = sqlite3ExprAnd(db, pWhen, pEq);
88660: }
88661:
88662: if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){
88663: Expr *pNew;
88664: if( action==OE_Cascade ){
88665: pNew = sqlite3PExpr(pParse, TK_DOT,
88666: sqlite3PExpr(pParse, TK_ID, 0, 0, &tNew),
88667: sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol)
88668: , 0);
88669: }else if( action==OE_SetDflt ){
88670: Expr *pDflt = pFKey->pFrom->aCol[iFromCol].pDflt;
88671: if( pDflt ){
88672: pNew = sqlite3ExprDup(db, pDflt, 0);
88673: }else{
88674: pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
88675: }
88676: }else{
88677: pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
88678: }
88679: pList = sqlite3ExprListAppend(pParse, pList, pNew);
88680: sqlite3ExprListSetName(pParse, pList, &tFromCol, 0);
88681: }
88682: }
88683: sqlite3DbFree(db, aiCol);
88684:
88685: zFrom = pFKey->pFrom->zName;
88686: nFrom = sqlite3Strlen30(zFrom);
88687:
88688: if( action==OE_Restrict ){
88689: Token tFrom;
88690: Expr *pRaise;
88691:
88692: tFrom.z = zFrom;
88693: tFrom.n = nFrom;
88694: pRaise = sqlite3Expr(db, TK_RAISE, "foreign key constraint failed");
88695: if( pRaise ){
88696: pRaise->affinity = OE_Abort;
88697: }
88698: pSelect = sqlite3SelectNew(pParse,
88699: sqlite3ExprListAppend(pParse, 0, pRaise),
88700: sqlite3SrcListAppend(db, 0, &tFrom, 0),
88701: pWhere,
88702: 0, 0, 0, 0, 0, 0
88703: );
88704: pWhere = 0;
88705: }
88706:
88707: /* Disable lookaside memory allocation */
88708: enableLookaside = db->lookaside.bEnabled;
88709: db->lookaside.bEnabled = 0;
88710:
88711: pTrigger = (Trigger *)sqlite3DbMallocZero(db,
88712: sizeof(Trigger) + /* struct Trigger */
88713: sizeof(TriggerStep) + /* Single step in trigger program */
88714: nFrom + 1 /* Space for pStep->target.z */
88715: );
88716: if( pTrigger ){
88717: pStep = pTrigger->step_list = (TriggerStep *)&pTrigger[1];
88718: pStep->target.z = (char *)&pStep[1];
88719: pStep->target.n = nFrom;
88720: memcpy((char *)pStep->target.z, zFrom, nFrom);
88721:
88722: pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
88723: pStep->pExprList = sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE);
88724: pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
88725: if( pWhen ){
88726: pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0, 0);
88727: pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
88728: }
88729: }
88730:
88731: /* Re-enable the lookaside buffer, if it was disabled earlier. */
88732: db->lookaside.bEnabled = enableLookaside;
88733:
88734: sqlite3ExprDelete(db, pWhere);
88735: sqlite3ExprDelete(db, pWhen);
88736: sqlite3ExprListDelete(db, pList);
88737: sqlite3SelectDelete(db, pSelect);
88738: if( db->mallocFailed==1 ){
88739: fkTriggerDelete(db, pTrigger);
88740: return 0;
88741: }
88742: assert( pStep!=0 );
88743:
88744: switch( action ){
88745: case OE_Restrict:
88746: pStep->op = TK_SELECT;
88747: break;
88748: case OE_Cascade:
88749: if( !pChanges ){
88750: pStep->op = TK_DELETE;
88751: break;
88752: }
88753: default:
88754: pStep->op = TK_UPDATE;
88755: }
88756: pStep->pTrig = pTrigger;
88757: pTrigger->pSchema = pTab->pSchema;
88758: pTrigger->pTabSchema = pTab->pSchema;
88759: pFKey->apTrigger[iAction] = pTrigger;
88760: pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE);
88761: }
88762:
88763: return pTrigger;
88764: }
88765:
88766: /*
88767: ** This function is called when deleting or updating a row to implement
88768: ** any required CASCADE, SET NULL or SET DEFAULT actions.
88769: */
88770: SQLITE_PRIVATE void sqlite3FkActions(
88771: Parse *pParse, /* Parse context */
88772: Table *pTab, /* Table being updated or deleted from */
88773: ExprList *pChanges, /* Change-list for UPDATE, NULL for DELETE */
88774: int regOld /* Address of array containing old row */
88775: ){
88776: /* If foreign-key support is enabled, iterate through all FKs that
88777: ** refer to table pTab. If there is an action associated with the FK
88778: ** for this operation (either update or delete), invoke the associated
88779: ** trigger sub-program. */
88780: if( pParse->db->flags&SQLITE_ForeignKeys ){
88781: FKey *pFKey; /* Iterator variable */
88782: for(pFKey = sqlite3FkReferences(pTab); pFKey; pFKey=pFKey->pNextTo){
88783: Trigger *pAction = fkActionTrigger(pParse, pTab, pFKey, pChanges);
88784: if( pAction ){
88785: sqlite3CodeRowTriggerDirect(pParse, pAction, pTab, regOld, OE_Abort, 0);
88786: }
88787: }
88788: }
88789: }
88790:
88791: #endif /* ifndef SQLITE_OMIT_TRIGGER */
88792:
88793: /*
88794: ** Free all memory associated with foreign key definitions attached to
88795: ** table pTab. Remove the deleted foreign keys from the Schema.fkeyHash
88796: ** hash table.
88797: */
88798: SQLITE_PRIVATE void sqlite3FkDelete(sqlite3 *db, Table *pTab){
88799: FKey *pFKey; /* Iterator variable */
88800: FKey *pNext; /* Copy of pFKey->pNextFrom */
88801:
88802: assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pTab->pSchema) );
88803: for(pFKey=pTab->pFKey; pFKey; pFKey=pNext){
88804:
88805: /* Remove the FK from the fkeyHash hash table. */
88806: if( !db || db->pnBytesFreed==0 ){
88807: if( pFKey->pPrevTo ){
88808: pFKey->pPrevTo->pNextTo = pFKey->pNextTo;
88809: }else{
88810: void *p = (void *)pFKey->pNextTo;
88811: const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo);
88812: sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, sqlite3Strlen30(z), p);
88813: }
88814: if( pFKey->pNextTo ){
88815: pFKey->pNextTo->pPrevTo = pFKey->pPrevTo;
88816: }
88817: }
88818:
88819: /* EV: R-30323-21917 Each foreign key constraint in SQLite is
88820: ** classified as either immediate or deferred.
88821: */
88822: assert( pFKey->isDeferred==0 || pFKey->isDeferred==1 );
88823:
88824: /* Delete any triggers created to implement actions for this FK. */
88825: #ifndef SQLITE_OMIT_TRIGGER
88826: fkTriggerDelete(db, pFKey->apTrigger[0]);
88827: fkTriggerDelete(db, pFKey->apTrigger[1]);
88828: #endif
88829:
88830: pNext = pFKey->pNextFrom;
88831: sqlite3DbFree(db, pFKey);
88832: }
88833: }
88834: #endif /* ifndef SQLITE_OMIT_FOREIGN_KEY */
88835:
88836: /************** End of fkey.c ************************************************/
88837: /************** Begin file insert.c ******************************************/
88838: /*
88839: ** 2001 September 15
88840: **
88841: ** The author disclaims copyright to this source code. In place of
88842: ** a legal notice, here is a blessing:
88843: **
88844: ** May you do good and not evil.
88845: ** May you find forgiveness for yourself and forgive others.
88846: ** May you share freely, never taking more than you give.
88847: **
88848: *************************************************************************
88849: ** This file contains C code routines that are called by the parser
88850: ** to handle INSERT statements in SQLite.
88851: */
88852:
88853: /*
88854: ** Generate code that will open a table for reading.
88855: */
88856: SQLITE_PRIVATE void sqlite3OpenTable(
88857: Parse *p, /* Generate code into this VDBE */
88858: int iCur, /* The cursor number of the table */
88859: int iDb, /* The database index in sqlite3.aDb[] */
88860: Table *pTab, /* The table to be opened */
88861: int opcode /* OP_OpenRead or OP_OpenWrite */
88862: ){
88863: Vdbe *v;
88864: if( IsVirtual(pTab) ) return;
88865: v = sqlite3GetVdbe(p);
88866: assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
88867: sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);
88868: sqlite3VdbeAddOp3(v, opcode, iCur, pTab->tnum, iDb);
88869: sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(pTab->nCol), P4_INT32);
88870: VdbeComment((v, "%s", pTab->zName));
88871: }
88872:
88873: /*
88874: ** Return a pointer to the column affinity string associated with index
88875: ** pIdx. A column affinity string has one character for each column in
88876: ** the table, according to the affinity of the column:
88877: **
88878: ** Character Column affinity
88879: ** ------------------------------
88880: ** 'a' TEXT
88881: ** 'b' NONE
88882: ** 'c' NUMERIC
88883: ** 'd' INTEGER
88884: ** 'e' REAL
88885: **
88886: ** An extra 'd' is appended to the end of the string to cover the
88887: ** rowid that appears as the last column in every index.
88888: **
88889: ** Memory for the buffer containing the column index affinity string
88890: ** is managed along with the rest of the Index structure. It will be
88891: ** released when sqlite3DeleteIndex() is called.
88892: */
88893: SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){
88894: if( !pIdx->zColAff ){
88895: /* The first time a column affinity string for a particular index is
88896: ** required, it is allocated and populated here. It is then stored as
88897: ** a member of the Index structure for subsequent use.
88898: **
88899: ** The column affinity string will eventually be deleted by
88900: ** sqliteDeleteIndex() when the Index structure itself is cleaned
88901: ** up.
88902: */
88903: int n;
88904: Table *pTab = pIdx->pTable;
88905: sqlite3 *db = sqlite3VdbeDb(v);
88906: pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+2);
88907: if( !pIdx->zColAff ){
88908: db->mallocFailed = 1;
88909: return 0;
88910: }
88911: for(n=0; n<pIdx->nColumn; n++){
88912: pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
88913: }
88914: pIdx->zColAff[n++] = SQLITE_AFF_INTEGER;
88915: pIdx->zColAff[n] = 0;
88916: }
88917:
88918: return pIdx->zColAff;
88919: }
88920:
88921: /*
88922: ** Set P4 of the most recently inserted opcode to a column affinity
88923: ** string for table pTab. A column affinity string has one character
88924: ** for each column indexed by the index, according to the affinity of the
88925: ** column:
88926: **
88927: ** Character Column affinity
88928: ** ------------------------------
88929: ** 'a' TEXT
88930: ** 'b' NONE
88931: ** 'c' NUMERIC
88932: ** 'd' INTEGER
88933: ** 'e' REAL
88934: */
88935: SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
88936: /* The first time a column affinity string for a particular table
88937: ** is required, it is allocated and populated here. It is then
88938: ** stored as a member of the Table structure for subsequent use.
88939: **
88940: ** The column affinity string will eventually be deleted by
88941: ** sqlite3DeleteTable() when the Table structure itself is cleaned up.
88942: */
88943: if( !pTab->zColAff ){
88944: char *zColAff;
88945: int i;
88946: sqlite3 *db = sqlite3VdbeDb(v);
88947:
88948: zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
88949: if( !zColAff ){
88950: db->mallocFailed = 1;
88951: return;
88952: }
88953:
88954: for(i=0; i<pTab->nCol; i++){
88955: zColAff[i] = pTab->aCol[i].affinity;
88956: }
88957: zColAff[pTab->nCol] = '\0';
88958:
88959: pTab->zColAff = zColAff;
88960: }
88961:
88962: sqlite3VdbeChangeP4(v, -1, pTab->zColAff, P4_TRANSIENT);
88963: }
88964:
88965: /*
88966: ** Return non-zero if the table pTab in database iDb or any of its indices
88967: ** have been opened at any point in the VDBE program beginning at location
88968: ** iStartAddr throught the end of the program. This is used to see if
88969: ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
88970: ** run without using temporary table for the results of the SELECT.
88971: */
88972: static int readsTable(Parse *p, int iStartAddr, int iDb, Table *pTab){
88973: Vdbe *v = sqlite3GetVdbe(p);
88974: int i;
88975: int iEnd = sqlite3VdbeCurrentAddr(v);
88976: #ifndef SQLITE_OMIT_VIRTUALTABLE
88977: VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
88978: #endif
88979:
88980: for(i=iStartAddr; i<iEnd; i++){
88981: VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
88982: assert( pOp!=0 );
88983: if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
88984: Index *pIndex;
88985: int tnum = pOp->p2;
88986: if( tnum==pTab->tnum ){
88987: return 1;
88988: }
88989: for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
88990: if( tnum==pIndex->tnum ){
88991: return 1;
88992: }
88993: }
88994: }
88995: #ifndef SQLITE_OMIT_VIRTUALTABLE
88996: if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){
88997: assert( pOp->p4.pVtab!=0 );
88998: assert( pOp->p4type==P4_VTAB );
88999: return 1;
89000: }
89001: #endif
89002: }
89003: return 0;
89004: }
89005:
89006: #ifndef SQLITE_OMIT_AUTOINCREMENT
89007: /*
89008: ** Locate or create an AutoincInfo structure associated with table pTab
89009: ** which is in database iDb. Return the register number for the register
89010: ** that holds the maximum rowid.
89011: **
89012: ** There is at most one AutoincInfo structure per table even if the
89013: ** same table is autoincremented multiple times due to inserts within
89014: ** triggers. A new AutoincInfo structure is created if this is the
89015: ** first use of table pTab. On 2nd and subsequent uses, the original
89016: ** AutoincInfo structure is used.
89017: **
89018: ** Three memory locations are allocated:
89019: **
89020: ** (1) Register to hold the name of the pTab table.
89021: ** (2) Register to hold the maximum ROWID of pTab.
89022: ** (3) Register to hold the rowid in sqlite_sequence of pTab
89023: **
89024: ** The 2nd register is the one that is returned. That is all the
89025: ** insert routine needs to know about.
89026: */
89027: static int autoIncBegin(
89028: Parse *pParse, /* Parsing context */
89029: int iDb, /* Index of the database holding pTab */
89030: Table *pTab /* The table we are writing to */
89031: ){
89032: int memId = 0; /* Register holding maximum rowid */
89033: if( pTab->tabFlags & TF_Autoincrement ){
89034: Parse *pToplevel = sqlite3ParseToplevel(pParse);
89035: AutoincInfo *pInfo;
89036:
89037: pInfo = pToplevel->pAinc;
89038: while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
89039: if( pInfo==0 ){
89040: pInfo = sqlite3DbMallocRaw(pParse->db, sizeof(*pInfo));
89041: if( pInfo==0 ) return 0;
89042: pInfo->pNext = pToplevel->pAinc;
89043: pToplevel->pAinc = pInfo;
89044: pInfo->pTab = pTab;
89045: pInfo->iDb = iDb;
89046: pToplevel->nMem++; /* Register to hold name of table */
89047: pInfo->regCtr = ++pToplevel->nMem; /* Max rowid register */
89048: pToplevel->nMem++; /* Rowid in sqlite_sequence */
89049: }
89050: memId = pInfo->regCtr;
89051: }
89052: return memId;
89053: }
89054:
89055: /*
89056: ** This routine generates code that will initialize all of the
89057: ** register used by the autoincrement tracker.
89058: */
89059: SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
89060: AutoincInfo *p; /* Information about an AUTOINCREMENT */
89061: sqlite3 *db = pParse->db; /* The database connection */
89062: Db *pDb; /* Database only autoinc table */
89063: int memId; /* Register holding max rowid */
89064: int addr; /* A VDBE address */
89065: Vdbe *v = pParse->pVdbe; /* VDBE under construction */
89066:
89067: /* This routine is never called during trigger-generation. It is
89068: ** only called from the top-level */
89069: assert( pParse->pTriggerTab==0 );
89070: assert( pParse==sqlite3ParseToplevel(pParse) );
89071:
89072: assert( v ); /* We failed long ago if this is not so */
89073: for(p = pParse->pAinc; p; p = p->pNext){
89074: pDb = &db->aDb[p->iDb];
89075: memId = p->regCtr;
89076: assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
89077: sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
89078: sqlite3VdbeAddOp3(v, OP_Null, 0, memId, memId+1);
89079: addr = sqlite3VdbeCurrentAddr(v);
89080: sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
89081: sqlite3VdbeAddOp2(v, OP_Rewind, 0, addr+9);
89082: sqlite3VdbeAddOp3(v, OP_Column, 0, 0, memId);
89083: sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId);
89084: sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
89085: sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
89086: sqlite3VdbeAddOp3(v, OP_Column, 0, 1, memId);
89087: sqlite3VdbeAddOp2(v, OP_Goto, 0, addr+9);
89088: sqlite3VdbeAddOp2(v, OP_Next, 0, addr+2);
89089: sqlite3VdbeAddOp2(v, OP_Integer, 0, memId);
89090: sqlite3VdbeAddOp0(v, OP_Close);
89091: }
89092: }
89093:
89094: /*
89095: ** Update the maximum rowid for an autoincrement calculation.
89096: **
89097: ** This routine should be called when the top of the stack holds a
89098: ** new rowid that is about to be inserted. If that new rowid is
89099: ** larger than the maximum rowid in the memId memory cell, then the
89100: ** memory cell is updated. The stack is unchanged.
89101: */
89102: static void autoIncStep(Parse *pParse, int memId, int regRowid){
89103: if( memId>0 ){
89104: sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
89105: }
89106: }
89107:
89108: /*
89109: ** This routine generates the code needed to write autoincrement
89110: ** maximum rowid values back into the sqlite_sequence register.
89111: ** Every statement that might do an INSERT into an autoincrement
89112: ** table (either directly or through triggers) needs to call this
89113: ** routine just before the "exit" code.
89114: */
89115: SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
89116: AutoincInfo *p;
89117: Vdbe *v = pParse->pVdbe;
89118: sqlite3 *db = pParse->db;
89119:
89120: assert( v );
89121: for(p = pParse->pAinc; p; p = p->pNext){
89122: Db *pDb = &db->aDb[p->iDb];
89123: int j1, j2, j3, j4, j5;
89124: int iRec;
89125: int memId = p->regCtr;
89126:
89127: iRec = sqlite3GetTempReg(pParse);
89128: assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
89129: sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
89130: j1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1);
89131: j2 = sqlite3VdbeAddOp0(v, OP_Rewind);
89132: j3 = sqlite3VdbeAddOp3(v, OP_Column, 0, 0, iRec);
89133: j4 = sqlite3VdbeAddOp3(v, OP_Eq, memId-1, 0, iRec);
89134: sqlite3VdbeAddOp2(v, OP_Next, 0, j3);
89135: sqlite3VdbeJumpHere(v, j2);
89136: sqlite3VdbeAddOp2(v, OP_NewRowid, 0, memId+1);
89137: j5 = sqlite3VdbeAddOp0(v, OP_Goto);
89138: sqlite3VdbeJumpHere(v, j4);
89139: sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
89140: sqlite3VdbeJumpHere(v, j1);
89141: sqlite3VdbeJumpHere(v, j5);
89142: sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);
89143: sqlite3VdbeAddOp3(v, OP_Insert, 0, iRec, memId+1);
89144: sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
89145: sqlite3VdbeAddOp0(v, OP_Close);
89146: sqlite3ReleaseTempReg(pParse, iRec);
89147: }
89148: }
89149: #else
89150: /*
89151: ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
89152: ** above are all no-ops
89153: */
89154: # define autoIncBegin(A,B,C) (0)
89155: # define autoIncStep(A,B,C)
89156: #endif /* SQLITE_OMIT_AUTOINCREMENT */
89157:
89158:
89159: /* Forward declaration */
89160: static int xferOptimization(
89161: Parse *pParse, /* Parser context */
89162: Table *pDest, /* The table we are inserting into */
89163: Select *pSelect, /* A SELECT statement to use as the data source */
89164: int onError, /* How to handle constraint errors */
89165: int iDbDest /* The database of pDest */
89166: );
89167:
89168: /*
89169: ** This routine is call to handle SQL of the following forms:
89170: **
89171: ** insert into TABLE (IDLIST) values(EXPRLIST)
89172: ** insert into TABLE (IDLIST) select
89173: **
89174: ** The IDLIST following the table name is always optional. If omitted,
89175: ** then a list of all columns for the table is substituted. The IDLIST
89176: ** appears in the pColumn parameter. pColumn is NULL if IDLIST is omitted.
89177: **
89178: ** The pList parameter holds EXPRLIST in the first form of the INSERT
89179: ** statement above, and pSelect is NULL. For the second form, pList is
89180: ** NULL and pSelect is a pointer to the select statement used to generate
89181: ** data for the insert.
89182: **
89183: ** The code generated follows one of four templates. For a simple
89184: ** select with data coming from a VALUES clause, the code executes
89185: ** once straight down through. Pseudo-code follows (we call this
89186: ** the "1st template"):
89187: **
89188: ** open write cursor to <table> and its indices
89189: ** puts VALUES clause expressions onto the stack
89190: ** write the resulting record into <table>
89191: ** cleanup
89192: **
89193: ** The three remaining templates assume the statement is of the form
89194: **
89195: ** INSERT INTO <table> SELECT ...
89196: **
89197: ** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
89198: ** in other words if the SELECT pulls all columns from a single table
89199: ** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
89200: ** if <table2> and <table1> are distinct tables but have identical
89201: ** schemas, including all the same indices, then a special optimization
89202: ** is invoked that copies raw records from <table2> over to <table1>.
89203: ** See the xferOptimization() function for the implementation of this
89204: ** template. This is the 2nd template.
89205: **
89206: ** open a write cursor to <table>
89207: ** open read cursor on <table2>
89208: ** transfer all records in <table2> over to <table>
89209: ** close cursors
89210: ** foreach index on <table>
89211: ** open a write cursor on the <table> index
89212: ** open a read cursor on the corresponding <table2> index
89213: ** transfer all records from the read to the write cursors
89214: ** close cursors
89215: ** end foreach
89216: **
89217: ** The 3rd template is for when the second template does not apply
89218: ** and the SELECT clause does not read from <table> at any time.
89219: ** The generated code follows this template:
89220: **
89221: ** EOF <- 0
89222: ** X <- A
89223: ** goto B
89224: ** A: setup for the SELECT
89225: ** loop over the rows in the SELECT
89226: ** load values into registers R..R+n
89227: ** yield X
89228: ** end loop
89229: ** cleanup after the SELECT
89230: ** EOF <- 1
89231: ** yield X
89232: ** goto A
89233: ** B: open write cursor to <table> and its indices
89234: ** C: yield X
89235: ** if EOF goto D
89236: ** insert the select result into <table> from R..R+n
89237: ** goto C
89238: ** D: cleanup
89239: **
89240: ** The 4th template is used if the insert statement takes its
89241: ** values from a SELECT but the data is being inserted into a table
89242: ** that is also read as part of the SELECT. In the third form,
89243: ** we have to use a intermediate table to store the results of
89244: ** the select. The template is like this:
89245: **
89246: ** EOF <- 0
89247: ** X <- A
89248: ** goto B
89249: ** A: setup for the SELECT
89250: ** loop over the tables in the SELECT
89251: ** load value into register R..R+n
89252: ** yield X
89253: ** end loop
89254: ** cleanup after the SELECT
89255: ** EOF <- 1
89256: ** yield X
89257: ** halt-error
89258: ** B: open temp table
89259: ** L: yield X
89260: ** if EOF goto M
89261: ** insert row from R..R+n into temp table
89262: ** goto L
89263: ** M: open write cursor to <table> and its indices
89264: ** rewind temp table
89265: ** C: loop over rows of intermediate table
89266: ** transfer values form intermediate table into <table>
89267: ** end loop
89268: ** D: cleanup
89269: */
89270: SQLITE_PRIVATE void sqlite3Insert(
89271: Parse *pParse, /* Parser context */
89272: SrcList *pTabList, /* Name of table into which we are inserting */
89273: ExprList *pList, /* List of values to be inserted */
89274: Select *pSelect, /* A SELECT statement to use as the data source */
89275: IdList *pColumn, /* Column names corresponding to IDLIST. */
89276: int onError /* How to handle constraint errors */
89277: ){
89278: sqlite3 *db; /* The main database structure */
89279: Table *pTab; /* The table to insert into. aka TABLE */
89280: char *zTab; /* Name of the table into which we are inserting */
89281: const char *zDb; /* Name of the database holding this table */
89282: int i, j, idx; /* Loop counters */
89283: Vdbe *v; /* Generate code into this virtual machine */
89284: Index *pIdx; /* For looping over indices of the table */
89285: int nColumn; /* Number of columns in the data */
89286: int nHidden = 0; /* Number of hidden columns if TABLE is virtual */
89287: int baseCur = 0; /* VDBE Cursor number for pTab */
89288: int keyColumn = -1; /* Column that is the INTEGER PRIMARY KEY */
89289: int endOfLoop; /* Label for the end of the insertion loop */
89290: int useTempTable = 0; /* Store SELECT results in intermediate table */
89291: int srcTab = 0; /* Data comes from this temporary cursor if >=0 */
89292: int addrInsTop = 0; /* Jump to label "D" */
89293: int addrCont = 0; /* Top of insert loop. Label "C" in templates 3 and 4 */
89294: int addrSelect = 0; /* Address of coroutine that implements the SELECT */
89295: SelectDest dest; /* Destination for SELECT on rhs of INSERT */
89296: int iDb; /* Index of database holding TABLE */
89297: Db *pDb; /* The database containing table being inserted into */
89298: int appendFlag = 0; /* True if the insert is likely to be an append */
89299:
89300: /* Register allocations */
89301: int regFromSelect = 0;/* Base register for data coming from SELECT */
89302: int regAutoinc = 0; /* Register holding the AUTOINCREMENT counter */
89303: int regRowCount = 0; /* Memory cell used for the row counter */
89304: int regIns; /* Block of regs holding rowid+data being inserted */
89305: int regRowid; /* registers holding insert rowid */
89306: int regData; /* register holding first column to insert */
89307: int regEof = 0; /* Register recording end of SELECT data */
89308: int *aRegIdx = 0; /* One register allocated to each index */
89309:
89310: #ifndef SQLITE_OMIT_TRIGGER
89311: int isView; /* True if attempting to insert into a view */
89312: Trigger *pTrigger; /* List of triggers on pTab, if required */
89313: int tmask; /* Mask of trigger times */
89314: #endif
89315:
89316: db = pParse->db;
89317: memset(&dest, 0, sizeof(dest));
89318: if( pParse->nErr || db->mallocFailed ){
89319: goto insert_cleanup;
89320: }
89321:
89322: /* Locate the table into which we will be inserting new information.
89323: */
89324: assert( pTabList->nSrc==1 );
89325: zTab = pTabList->a[0].zName;
89326: if( NEVER(zTab==0) ) goto insert_cleanup;
89327: pTab = sqlite3SrcListLookup(pParse, pTabList);
89328: if( pTab==0 ){
89329: goto insert_cleanup;
89330: }
89331: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
89332: assert( iDb<db->nDb );
89333: pDb = &db->aDb[iDb];
89334: zDb = pDb->zName;
89335: if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
89336: goto insert_cleanup;
89337: }
89338:
89339: /* Figure out if we have any triggers and if the table being
89340: ** inserted into is a view
89341: */
89342: #ifndef SQLITE_OMIT_TRIGGER
89343: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
89344: isView = pTab->pSelect!=0;
89345: #else
89346: # define pTrigger 0
89347: # define tmask 0
89348: # define isView 0
89349: #endif
89350: #ifdef SQLITE_OMIT_VIEW
89351: # undef isView
89352: # define isView 0
89353: #endif
89354: assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
89355:
89356: /* If pTab is really a view, make sure it has been initialized.
89357: ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual
89358: ** module table).
89359: */
89360: if( sqlite3ViewGetColumnNames(pParse, pTab) ){
89361: goto insert_cleanup;
89362: }
89363:
89364: /* Ensure that:
89365: * (a) the table is not read-only,
89366: * (b) that if it is a view then ON INSERT triggers exist
89367: */
89368: if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
89369: goto insert_cleanup;
89370: }
89371:
89372: /* Allocate a VDBE
89373: */
89374: v = sqlite3GetVdbe(pParse);
89375: if( v==0 ) goto insert_cleanup;
89376: if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
89377: sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
89378:
89379: #ifndef SQLITE_OMIT_XFER_OPT
89380: /* If the statement is of the form
89381: **
89382: ** INSERT INTO <table1> SELECT * FROM <table2>;
89383: **
89384: ** Then special optimizations can be applied that make the transfer
89385: ** very fast and which reduce fragmentation of indices.
89386: **
89387: ** This is the 2nd template.
89388: */
89389: if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
89390: assert( !pTrigger );
89391: assert( pList==0 );
89392: goto insert_end;
89393: }
89394: #endif /* SQLITE_OMIT_XFER_OPT */
89395:
89396: /* If this is an AUTOINCREMENT table, look up the sequence number in the
89397: ** sqlite_sequence table and store it in memory cell regAutoinc.
89398: */
89399: regAutoinc = autoIncBegin(pParse, iDb, pTab);
89400:
89401: /* Figure out how many columns of data are supplied. If the data
89402: ** is coming from a SELECT statement, then generate a co-routine that
89403: ** produces a single row of the SELECT on each invocation. The
89404: ** co-routine is the common header to the 3rd and 4th templates.
89405: */
89406: if( pSelect ){
89407: /* Data is coming from a SELECT. Generate code to implement that SELECT
89408: ** as a co-routine. The code is common to both the 3rd and 4th
89409: ** templates:
89410: **
89411: ** EOF <- 0
89412: ** X <- A
89413: ** goto B
89414: ** A: setup for the SELECT
89415: ** loop over the tables in the SELECT
89416: ** load value into register R..R+n
89417: ** yield X
89418: ** end loop
89419: ** cleanup after the SELECT
89420: ** EOF <- 1
89421: ** yield X
89422: ** halt-error
89423: **
89424: ** On each invocation of the co-routine, it puts a single row of the
89425: ** SELECT result into registers dest.iMem...dest.iMem+dest.nMem-1.
89426: ** (These output registers are allocated by sqlite3Select().) When
89427: ** the SELECT completes, it sets the EOF flag stored in regEof.
89428: */
89429: int rc, j1;
89430:
89431: regEof = ++pParse->nMem;
89432: sqlite3VdbeAddOp2(v, OP_Integer, 0, regEof); /* EOF <- 0 */
89433: VdbeComment((v, "SELECT eof flag"));
89434: sqlite3SelectDestInit(&dest, SRT_Coroutine, ++pParse->nMem);
89435: addrSelect = sqlite3VdbeCurrentAddr(v)+2;
89436: sqlite3VdbeAddOp2(v, OP_Integer, addrSelect-1, dest.iParm);
89437: j1 = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
89438: VdbeComment((v, "Jump over SELECT coroutine"));
89439:
89440: /* Resolve the expressions in the SELECT statement and execute it. */
89441: rc = sqlite3Select(pParse, pSelect, &dest);
89442: assert( pParse->nErr==0 || rc );
89443: if( rc || NEVER(pParse->nErr) || db->mallocFailed ){
89444: goto insert_cleanup;
89445: }
89446: sqlite3VdbeAddOp2(v, OP_Integer, 1, regEof); /* EOF <- 1 */
89447: sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm); /* yield X */
89448: sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_INTERNAL, OE_Abort);
89449: VdbeComment((v, "End of SELECT coroutine"));
89450: sqlite3VdbeJumpHere(v, j1); /* label B: */
89451:
89452: regFromSelect = dest.iMem;
89453: assert( pSelect->pEList );
89454: nColumn = pSelect->pEList->nExpr;
89455: assert( dest.nMem==nColumn );
89456:
89457: /* Set useTempTable to TRUE if the result of the SELECT statement
89458: ** should be written into a temporary table (template 4). Set to
89459: ** FALSE if each* row of the SELECT can be written directly into
89460: ** the destination table (template 3).
89461: **
89462: ** A temp table must be used if the table being updated is also one
89463: ** of the tables being read by the SELECT statement. Also use a
89464: ** temp table in the case of row triggers.
89465: */
89466: if( pTrigger || readsTable(pParse, addrSelect, iDb, pTab) ){
89467: useTempTable = 1;
89468: }
89469:
89470: if( useTempTable ){
89471: /* Invoke the coroutine to extract information from the SELECT
89472: ** and add it to a transient table srcTab. The code generated
89473: ** here is from the 4th template:
89474: **
89475: ** B: open temp table
89476: ** L: yield X
89477: ** if EOF goto M
89478: ** insert row from R..R+n into temp table
89479: ** goto L
89480: ** M: ...
89481: */
89482: int regRec; /* Register to hold packed record */
89483: int regTempRowid; /* Register to hold temp table ROWID */
89484: int addrTop; /* Label "L" */
89485: int addrIf; /* Address of jump to M */
89486:
89487: srcTab = pParse->nTab++;
89488: regRec = sqlite3GetTempReg(pParse);
89489: regTempRowid = sqlite3GetTempReg(pParse);
89490: sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
89491: addrTop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm);
89492: addrIf = sqlite3VdbeAddOp1(v, OP_If, regEof);
89493: sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
89494: sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);
89495: sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);
89496: sqlite3VdbeAddOp2(v, OP_Goto, 0, addrTop);
89497: sqlite3VdbeJumpHere(v, addrIf);
89498: sqlite3ReleaseTempReg(pParse, regRec);
89499: sqlite3ReleaseTempReg(pParse, regTempRowid);
89500: }
89501: }else{
89502: /* This is the case if the data for the INSERT is coming from a VALUES
89503: ** clause
89504: */
89505: NameContext sNC;
89506: memset(&sNC, 0, sizeof(sNC));
89507: sNC.pParse = pParse;
89508: srcTab = -1;
89509: assert( useTempTable==0 );
89510: nColumn = pList ? pList->nExpr : 0;
89511: for(i=0; i<nColumn; i++){
89512: if( sqlite3ResolveExprNames(&sNC, pList->a[i].pExpr) ){
89513: goto insert_cleanup;
89514: }
89515: }
89516: }
89517:
89518: /* Make sure the number of columns in the source data matches the number
89519: ** of columns to be inserted into the table.
89520: */
89521: if( IsVirtual(pTab) ){
89522: for(i=0; i<pTab->nCol; i++){
89523: nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0);
89524: }
89525: }
89526: if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
89527: sqlite3ErrorMsg(pParse,
89528: "table %S has %d columns but %d values were supplied",
89529: pTabList, 0, pTab->nCol-nHidden, nColumn);
89530: goto insert_cleanup;
89531: }
89532: if( pColumn!=0 && nColumn!=pColumn->nId ){
89533: sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
89534: goto insert_cleanup;
89535: }
89536:
89537: /* If the INSERT statement included an IDLIST term, then make sure
89538: ** all elements of the IDLIST really are columns of the table and
89539: ** remember the column indices.
89540: **
89541: ** If the table has an INTEGER PRIMARY KEY column and that column
89542: ** is named in the IDLIST, then record in the keyColumn variable
89543: ** the index into IDLIST of the primary key column. keyColumn is
89544: ** the index of the primary key as it appears in IDLIST, not as
89545: ** is appears in the original table. (The index of the primary
89546: ** key in the original table is pTab->iPKey.)
89547: */
89548: if( pColumn ){
89549: for(i=0; i<pColumn->nId; i++){
89550: pColumn->a[i].idx = -1;
89551: }
89552: for(i=0; i<pColumn->nId; i++){
89553: for(j=0; j<pTab->nCol; j++){
89554: if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
89555: pColumn->a[i].idx = j;
89556: if( j==pTab->iPKey ){
89557: keyColumn = i;
89558: }
89559: break;
89560: }
89561: }
89562: if( j>=pTab->nCol ){
89563: if( sqlite3IsRowid(pColumn->a[i].zName) ){
89564: keyColumn = i;
89565: }else{
89566: sqlite3ErrorMsg(pParse, "table %S has no column named %s",
89567: pTabList, 0, pColumn->a[i].zName);
89568: pParse->checkSchema = 1;
89569: goto insert_cleanup;
89570: }
89571: }
89572: }
89573: }
89574:
89575: /* If there is no IDLIST term but the table has an integer primary
89576: ** key, the set the keyColumn variable to the primary key column index
89577: ** in the original table definition.
89578: */
89579: if( pColumn==0 && nColumn>0 ){
89580: keyColumn = pTab->iPKey;
89581: }
89582:
89583: /* Initialize the count of rows to be inserted
89584: */
89585: if( db->flags & SQLITE_CountRows ){
89586: regRowCount = ++pParse->nMem;
89587: sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
89588: }
89589:
89590: /* If this is not a view, open the table and and all indices */
89591: if( !isView ){
89592: int nIdx;
89593:
89594: baseCur = pParse->nTab;
89595: nIdx = sqlite3OpenTableAndIndices(pParse, pTab, baseCur, OP_OpenWrite);
89596: aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1));
89597: if( aRegIdx==0 ){
89598: goto insert_cleanup;
89599: }
89600: for(i=0; i<nIdx; i++){
89601: aRegIdx[i] = ++pParse->nMem;
89602: }
89603: }
89604:
89605: /* This is the top of the main insertion loop */
89606: if( useTempTable ){
89607: /* This block codes the top of loop only. The complete loop is the
89608: ** following pseudocode (template 4):
89609: **
89610: ** rewind temp table
89611: ** C: loop over rows of intermediate table
89612: ** transfer values form intermediate table into <table>
89613: ** end loop
89614: ** D: ...
89615: */
89616: addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab);
89617: addrCont = sqlite3VdbeCurrentAddr(v);
89618: }else if( pSelect ){
89619: /* This block codes the top of loop only. The complete loop is the
89620: ** following pseudocode (template 3):
89621: **
89622: ** C: yield X
89623: ** if EOF goto D
89624: ** insert the select result into <table> from R..R+n
89625: ** goto C
89626: ** D: ...
89627: */
89628: addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm);
89629: addrInsTop = sqlite3VdbeAddOp1(v, OP_If, regEof);
89630: }
89631:
89632: /* Allocate registers for holding the rowid of the new row,
89633: ** the content of the new row, and the assemblied row record.
89634: */
89635: regRowid = regIns = pParse->nMem+1;
89636: pParse->nMem += pTab->nCol + 1;
89637: if( IsVirtual(pTab) ){
89638: regRowid++;
89639: pParse->nMem++;
89640: }
89641: regData = regRowid+1;
89642:
89643: /* Run the BEFORE and INSTEAD OF triggers, if there are any
89644: */
89645: endOfLoop = sqlite3VdbeMakeLabel(v);
89646: if( tmask & TRIGGER_BEFORE ){
89647: int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
89648:
89649: /* build the NEW.* reference row. Note that if there is an INTEGER
89650: ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
89651: ** translated into a unique ID for the row. But on a BEFORE trigger,
89652: ** we do not know what the unique ID will be (because the insert has
89653: ** not happened yet) so we substitute a rowid of -1
89654: */
89655: if( keyColumn<0 ){
89656: sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
89657: }else{
89658: int j1;
89659: if( useTempTable ){
89660: sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regCols);
89661: }else{
89662: assert( pSelect==0 ); /* Otherwise useTempTable is true */
89663: sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regCols);
89664: }
89665: j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols);
89666: sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
89667: sqlite3VdbeJumpHere(v, j1);
89668: sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols);
89669: }
89670:
89671: /* Cannot have triggers on a virtual table. If it were possible,
89672: ** this block would have to account for hidden column.
89673: */
89674: assert( !IsVirtual(pTab) );
89675:
89676: /* Create the new column data
89677: */
89678: for(i=0; i<pTab->nCol; i++){
89679: if( pColumn==0 ){
89680: j = i;
89681: }else{
89682: for(j=0; j<pColumn->nId; j++){
89683: if( pColumn->a[j].idx==i ) break;
89684: }
89685: }
89686: if( (!useTempTable && !pList) || (pColumn && j>=pColumn->nId) ){
89687: sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i+1);
89688: }else if( useTempTable ){
89689: sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, regCols+i+1);
89690: }else{
89691: assert( pSelect==0 ); /* Otherwise useTempTable is true */
89692: sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i+1);
89693: }
89694: }
89695:
89696: /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
89697: ** do not attempt any conversions before assembling the record.
89698: ** If this is a real table, attempt conversions as required by the
89699: ** table column affinities.
89700: */
89701: if( !isView ){
89702: sqlite3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);
89703: sqlite3TableAffinityStr(v, pTab);
89704: }
89705:
89706: /* Fire BEFORE or INSTEAD OF triggers */
89707: sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE,
89708: pTab, regCols-pTab->nCol-1, onError, endOfLoop);
89709:
89710: sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
89711: }
89712:
89713: /* Push the record number for the new entry onto the stack. The
89714: ** record number is a randomly generate integer created by NewRowid
89715: ** except when the table has an INTEGER PRIMARY KEY column, in which
89716: ** case the record number is the same as that column.
89717: */
89718: if( !isView ){
89719: if( IsVirtual(pTab) ){
89720: /* The row that the VUpdate opcode will delete: none */
89721: sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
89722: }
89723: if( keyColumn>=0 ){
89724: if( useTempTable ){
89725: sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regRowid);
89726: }else if( pSelect ){
89727: sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+keyColumn, regRowid);
89728: }else{
89729: VdbeOp *pOp;
89730: sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
89731: pOp = sqlite3VdbeGetOp(v, -1);
89732: if( ALWAYS(pOp) && pOp->opcode==OP_Null && !IsVirtual(pTab) ){
89733: appendFlag = 1;
89734: pOp->opcode = OP_NewRowid;
89735: pOp->p1 = baseCur;
89736: pOp->p2 = regRowid;
89737: pOp->p3 = regAutoinc;
89738: }
89739: }
89740: /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
89741: ** to generate a unique primary key value.
89742: */
89743: if( !appendFlag ){
89744: int j1;
89745: if( !IsVirtual(pTab) ){
89746: j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid);
89747: sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
89748: sqlite3VdbeJumpHere(v, j1);
89749: }else{
89750: j1 = sqlite3VdbeCurrentAddr(v);
89751: sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, j1+2);
89752: }
89753: sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid);
89754: }
89755: }else if( IsVirtual(pTab) ){
89756: sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
89757: }else{
89758: sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
89759: appendFlag = 1;
89760: }
89761: autoIncStep(pParse, regAutoinc, regRowid);
89762:
89763: /* Push onto the stack, data for all columns of the new entry, beginning
89764: ** with the first column.
89765: */
89766: nHidden = 0;
89767: for(i=0; i<pTab->nCol; i++){
89768: int iRegStore = regRowid+1+i;
89769: if( i==pTab->iPKey ){
89770: /* The value of the INTEGER PRIMARY KEY column is always a NULL.
89771: ** Whenever this column is read, the record number will be substituted
89772: ** in its place. So will fill this column with a NULL to avoid
89773: ** taking up data space with information that will never be used. */
89774: sqlite3VdbeAddOp2(v, OP_Null, 0, iRegStore);
89775: continue;
89776: }
89777: if( pColumn==0 ){
89778: if( IsHiddenColumn(&pTab->aCol[i]) ){
89779: assert( IsVirtual(pTab) );
89780: j = -1;
89781: nHidden++;
89782: }else{
89783: j = i - nHidden;
89784: }
89785: }else{
89786: for(j=0; j<pColumn->nId; j++){
89787: if( pColumn->a[j].idx==i ) break;
89788: }
89789: }
89790: if( j<0 || nColumn==0 || (pColumn && j>=pColumn->nId) ){
89791: sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, iRegStore);
89792: }else if( useTempTable ){
89793: sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, iRegStore);
89794: }else if( pSelect ){
89795: sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+j, iRegStore);
89796: }else{
89797: sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
89798: }
89799: }
89800:
89801: /* Generate code to check constraints and generate index keys and
89802: ** do the insertion.
89803: */
89804: #ifndef SQLITE_OMIT_VIRTUALTABLE
89805: if( IsVirtual(pTab) ){
89806: const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
89807: sqlite3VtabMakeWritable(pParse, pTab);
89808: sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
89809: sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
89810: sqlite3MayAbort(pParse);
89811: }else
89812: #endif
89813: {
89814: int isReplace; /* Set to true if constraints may cause a replace */
89815: sqlite3GenerateConstraintChecks(pParse, pTab, baseCur, regIns, aRegIdx,
89816: keyColumn>=0, 0, onError, endOfLoop, &isReplace
89817: );
89818: sqlite3FkCheck(pParse, pTab, 0, regIns);
89819: sqlite3CompleteInsertion(
89820: pParse, pTab, baseCur, regIns, aRegIdx, 0, appendFlag, isReplace==0
89821: );
89822: }
89823: }
89824:
89825: /* Update the count of rows that are inserted
89826: */
89827: if( (db->flags & SQLITE_CountRows)!=0 ){
89828: sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
89829: }
89830:
89831: if( pTrigger ){
89832: /* Code AFTER triggers */
89833: sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER,
89834: pTab, regData-2-pTab->nCol, onError, endOfLoop);
89835: }
89836:
89837: /* The bottom of the main insertion loop, if the data source
89838: ** is a SELECT statement.
89839: */
89840: sqlite3VdbeResolveLabel(v, endOfLoop);
89841: if( useTempTable ){
89842: sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont);
89843: sqlite3VdbeJumpHere(v, addrInsTop);
89844: sqlite3VdbeAddOp1(v, OP_Close, srcTab);
89845: }else if( pSelect ){
89846: sqlite3VdbeAddOp2(v, OP_Goto, 0, addrCont);
89847: sqlite3VdbeJumpHere(v, addrInsTop);
89848: }
89849:
89850: if( !IsVirtual(pTab) && !isView ){
89851: /* Close all tables opened */
89852: sqlite3VdbeAddOp1(v, OP_Close, baseCur);
89853: for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
89854: sqlite3VdbeAddOp1(v, OP_Close, idx+baseCur);
89855: }
89856: }
89857:
89858: insert_end:
89859: /* Update the sqlite_sequence table by storing the content of the
89860: ** maximum rowid counter values recorded while inserting into
89861: ** autoincrement tables.
89862: */
89863: if( pParse->nested==0 && pParse->pTriggerTab==0 ){
89864: sqlite3AutoincrementEnd(pParse);
89865: }
89866:
89867: /*
89868: ** Return the number of rows inserted. If this routine is
89869: ** generating code because of a call to sqlite3NestedParse(), do not
89870: ** invoke the callback function.
89871: */
89872: if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
89873: sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
89874: sqlite3VdbeSetNumCols(v, 1);
89875: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC);
89876: }
89877:
89878: insert_cleanup:
89879: sqlite3SrcListDelete(db, pTabList);
89880: sqlite3ExprListDelete(db, pList);
89881: sqlite3SelectDelete(db, pSelect);
89882: sqlite3IdListDelete(db, pColumn);
89883: sqlite3DbFree(db, aRegIdx);
89884: }
89885:
89886: /* Make sure "isView" and other macros defined above are undefined. Otherwise
89887: ** thely may interfere with compilation of other functions in this file
89888: ** (or in another file, if this file becomes part of the amalgamation). */
89889: #ifdef isView
89890: #undef isView
89891: #endif
89892: #ifdef pTrigger
89893: #undef pTrigger
89894: #endif
89895: #ifdef tmask
89896: #undef tmask
89897: #endif
89898:
89899:
89900: /*
89901: ** Generate code to do constraint checks prior to an INSERT or an UPDATE.
89902: **
89903: ** The input is a range of consecutive registers as follows:
89904: **
89905: ** 1. The rowid of the row after the update.
89906: **
89907: ** 2. The data in the first column of the entry after the update.
89908: **
89909: ** i. Data from middle columns...
89910: **
89911: ** N. The data in the last column of the entry after the update.
89912: **
89913: ** The regRowid parameter is the index of the register containing (1).
89914: **
89915: ** If isUpdate is true and rowidChng is non-zero, then rowidChng contains
89916: ** the address of a register containing the rowid before the update takes
89917: ** place. isUpdate is true for UPDATEs and false for INSERTs. If isUpdate
89918: ** is false, indicating an INSERT statement, then a non-zero rowidChng
89919: ** indicates that the rowid was explicitly specified as part of the
89920: ** INSERT statement. If rowidChng is false, it means that the rowid is
89921: ** computed automatically in an insert or that the rowid value is not
89922: ** modified by an update.
89923: **
89924: ** The code generated by this routine store new index entries into
89925: ** registers identified by aRegIdx[]. No index entry is created for
89926: ** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is
89927: ** the same as the order of indices on the linked list of indices
89928: ** attached to the table.
89929: **
89930: ** This routine also generates code to check constraints. NOT NULL,
89931: ** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
89932: ** then the appropriate action is performed. There are five possible
89933: ** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
89934: **
89935: ** Constraint type Action What Happens
89936: ** --------------- ---------- ----------------------------------------
89937: ** any ROLLBACK The current transaction is rolled back and
89938: ** sqlite3_exec() returns immediately with a
89939: ** return code of SQLITE_CONSTRAINT.
89940: **
89941: ** any ABORT Back out changes from the current command
89942: ** only (do not do a complete rollback) then
89943: ** cause sqlite3_exec() to return immediately
89944: ** with SQLITE_CONSTRAINT.
89945: **
89946: ** any FAIL Sqlite3_exec() returns immediately with a
89947: ** return code of SQLITE_CONSTRAINT. The
89948: ** transaction is not rolled back and any
89949: ** prior changes are retained.
89950: **
89951: ** any IGNORE The record number and data is popped from
89952: ** the stack and there is an immediate jump
89953: ** to label ignoreDest.
89954: **
89955: ** NOT NULL REPLACE The NULL value is replace by the default
89956: ** value for that column. If the default value
89957: ** is NULL, the action is the same as ABORT.
89958: **
89959: ** UNIQUE REPLACE The other row that conflicts with the row
89960: ** being inserted is removed.
89961: **
89962: ** CHECK REPLACE Illegal. The results in an exception.
89963: **
89964: ** Which action to take is determined by the overrideError parameter.
89965: ** Or if overrideError==OE_Default, then the pParse->onError parameter
89966: ** is used. Or if pParse->onError==OE_Default then the onError value
89967: ** for the constraint is used.
89968: **
89969: ** The calling routine must open a read/write cursor for pTab with
89970: ** cursor number "baseCur". All indices of pTab must also have open
89971: ** read/write cursors with cursor number baseCur+i for the i-th cursor.
89972: ** Except, if there is no possibility of a REPLACE action then
89973: ** cursors do not need to be open for indices where aRegIdx[i]==0.
89974: */
89975: SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
89976: Parse *pParse, /* The parser context */
89977: Table *pTab, /* the table into which we are inserting */
89978: int baseCur, /* Index of a read/write cursor pointing at pTab */
89979: int regRowid, /* Index of the range of input registers */
89980: int *aRegIdx, /* Register used by each index. 0 for unused indices */
89981: int rowidChng, /* True if the rowid might collide with existing entry */
89982: int isUpdate, /* True for UPDATE, False for INSERT */
89983: int overrideError, /* Override onError to this if not OE_Default */
89984: int ignoreDest, /* Jump to this label on an OE_Ignore resolution */
89985: int *pbMayReplace /* OUT: Set to true if constraint may cause a replace */
89986: ){
89987: int i; /* loop counter */
89988: Vdbe *v; /* VDBE under constrution */
89989: int nCol; /* Number of columns */
89990: int onError; /* Conflict resolution strategy */
89991: int j1; /* Addresss of jump instruction */
89992: int j2 = 0, j3; /* Addresses of jump instructions */
89993: int regData; /* Register containing first data column */
89994: int iCur; /* Table cursor number */
89995: Index *pIdx; /* Pointer to one of the indices */
89996: int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
89997: int regOldRowid = (rowidChng && isUpdate) ? rowidChng : regRowid;
89998:
89999: v = sqlite3GetVdbe(pParse);
90000: assert( v!=0 );
90001: assert( pTab->pSelect==0 ); /* This table is not a VIEW */
90002: nCol = pTab->nCol;
90003: regData = regRowid + 1;
90004:
90005: /* Test all NOT NULL constraints.
90006: */
90007: for(i=0; i<nCol; i++){
90008: if( i==pTab->iPKey ){
90009: continue;
90010: }
90011: onError = pTab->aCol[i].notNull;
90012: if( onError==OE_None ) continue;
90013: if( overrideError!=OE_Default ){
90014: onError = overrideError;
90015: }else if( onError==OE_Default ){
90016: onError = OE_Abort;
90017: }
90018: if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){
90019: onError = OE_Abort;
90020: }
90021: assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
90022: || onError==OE_Ignore || onError==OE_Replace );
90023: switch( onError ){
90024: case OE_Abort:
90025: sqlite3MayAbort(pParse);
90026: case OE_Rollback:
90027: case OE_Fail: {
90028: char *zMsg;
90029: sqlite3VdbeAddOp3(v, OP_HaltIfNull,
90030: SQLITE_CONSTRAINT, onError, regData+i);
90031: zMsg = sqlite3MPrintf(pParse->db, "%s.%s may not be NULL",
90032: pTab->zName, pTab->aCol[i].zName);
90033: sqlite3VdbeChangeP4(v, -1, zMsg, P4_DYNAMIC);
90034: break;
90035: }
90036: case OE_Ignore: {
90037: sqlite3VdbeAddOp2(v, OP_IsNull, regData+i, ignoreDest);
90038: break;
90039: }
90040: default: {
90041: assert( onError==OE_Replace );
90042: j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regData+i);
90043: sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regData+i);
90044: sqlite3VdbeJumpHere(v, j1);
90045: break;
90046: }
90047: }
90048: }
90049:
90050: /* Test all CHECK constraints
90051: */
90052: #ifndef SQLITE_OMIT_CHECK
90053: if( pTab->pCheck && (pParse->db->flags & SQLITE_IgnoreChecks)==0 ){
90054: int allOk = sqlite3VdbeMakeLabel(v);
90055: pParse->ckBase = regData;
90056: sqlite3ExprIfTrue(pParse, pTab->pCheck, allOk, SQLITE_JUMPIFNULL);
90057: onError = overrideError!=OE_Default ? overrideError : OE_Abort;
90058: if( onError==OE_Ignore ){
90059: sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
90060: }else{
90061: if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-15569-63625 */
90062: sqlite3HaltConstraint(pParse, onError, 0, 0);
90063: }
90064: sqlite3VdbeResolveLabel(v, allOk);
90065: }
90066: #endif /* !defined(SQLITE_OMIT_CHECK) */
90067:
90068: /* If we have an INTEGER PRIMARY KEY, make sure the primary key
90069: ** of the new record does not previously exist. Except, if this
90070: ** is an UPDATE and the primary key is not changing, that is OK.
90071: */
90072: if( rowidChng ){
90073: onError = pTab->keyConf;
90074: if( overrideError!=OE_Default ){
90075: onError = overrideError;
90076: }else if( onError==OE_Default ){
90077: onError = OE_Abort;
90078: }
90079:
90080: if( isUpdate ){
90081: j2 = sqlite3VdbeAddOp3(v, OP_Eq, regRowid, 0, rowidChng);
90082: }
90083: j3 = sqlite3VdbeAddOp3(v, OP_NotExists, baseCur, 0, regRowid);
90084: switch( onError ){
90085: default: {
90086: onError = OE_Abort;
90087: /* Fall thru into the next case */
90088: }
90089: case OE_Rollback:
90090: case OE_Abort:
90091: case OE_Fail: {
90092: sqlite3HaltConstraint(
90093: pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
90094: break;
90095: }
90096: case OE_Replace: {
90097: /* If there are DELETE triggers on this table and the
90098: ** recursive-triggers flag is set, call GenerateRowDelete() to
90099: ** remove the conflicting row from the the table. This will fire
90100: ** the triggers and remove both the table and index b-tree entries.
90101: **
90102: ** Otherwise, if there are no triggers or the recursive-triggers
90103: ** flag is not set, but the table has one or more indexes, call
90104: ** GenerateRowIndexDelete(). This removes the index b-tree entries
90105: ** only. The table b-tree entry will be replaced by the new entry
90106: ** when it is inserted.
90107: **
90108: ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
90109: ** also invoke MultiWrite() to indicate that this VDBE may require
90110: ** statement rollback (if the statement is aborted after the delete
90111: ** takes place). Earlier versions called sqlite3MultiWrite() regardless,
90112: ** but being more selective here allows statements like:
90113: **
90114: ** REPLACE INTO t(rowid) VALUES($newrowid)
90115: **
90116: ** to run without a statement journal if there are no indexes on the
90117: ** table.
90118: */
90119: Trigger *pTrigger = 0;
90120: if( pParse->db->flags&SQLITE_RecTriggers ){
90121: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
90122: }
90123: if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){
90124: sqlite3MultiWrite(pParse);
90125: sqlite3GenerateRowDelete(
90126: pParse, pTab, baseCur, regRowid, 0, pTrigger, OE_Replace
90127: );
90128: }else if( pTab->pIndex ){
90129: sqlite3MultiWrite(pParse);
90130: sqlite3GenerateRowIndexDelete(pParse, pTab, baseCur, 0);
90131: }
90132: seenReplace = 1;
90133: break;
90134: }
90135: case OE_Ignore: {
90136: assert( seenReplace==0 );
90137: sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
90138: break;
90139: }
90140: }
90141: sqlite3VdbeJumpHere(v, j3);
90142: if( isUpdate ){
90143: sqlite3VdbeJumpHere(v, j2);
90144: }
90145: }
90146:
90147: /* Test all UNIQUE constraints by creating entries for each UNIQUE
90148: ** index and making sure that duplicate entries do not already exist.
90149: ** Add the new records to the indices as we go.
90150: */
90151: for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
90152: int regIdx;
90153: int regR;
90154:
90155: if( aRegIdx[iCur]==0 ) continue; /* Skip unused indices */
90156:
90157: /* Create a key for accessing the index entry */
90158: regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn+1);
90159: for(i=0; i<pIdx->nColumn; i++){
90160: int idx = pIdx->aiColumn[i];
90161: if( idx==pTab->iPKey ){
90162: sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
90163: }else{
90164: sqlite3VdbeAddOp2(v, OP_SCopy, regData+idx, regIdx+i);
90165: }
90166: }
90167: sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
90168: sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn+1, aRegIdx[iCur]);
90169: sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v, pIdx), P4_TRANSIENT);
90170: sqlite3ExprCacheAffinityChange(pParse, regIdx, pIdx->nColumn+1);
90171:
90172: /* Find out what action to take in case there is an indexing conflict */
90173: onError = pIdx->onError;
90174: if( onError==OE_None ){
90175: sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
90176: continue; /* pIdx is not a UNIQUE index */
90177: }
90178: if( overrideError!=OE_Default ){
90179: onError = overrideError;
90180: }else if( onError==OE_Default ){
90181: onError = OE_Abort;
90182: }
90183: if( seenReplace ){
90184: if( onError==OE_Ignore ) onError = OE_Replace;
90185: else if( onError==OE_Fail ) onError = OE_Abort;
90186: }
90187:
90188: /* Check to see if the new index entry will be unique */
90189: regR = sqlite3GetTempReg(pParse);
90190: sqlite3VdbeAddOp2(v, OP_SCopy, regOldRowid, regR);
90191: j3 = sqlite3VdbeAddOp4(v, OP_IsUnique, baseCur+iCur+1, 0,
90192: regR, SQLITE_INT_TO_PTR(regIdx),
90193: P4_INT32);
90194: sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
90195:
90196: /* Generate code that executes if the new index entry is not unique */
90197: assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
90198: || onError==OE_Ignore || onError==OE_Replace );
90199: switch( onError ){
90200: case OE_Rollback:
90201: case OE_Abort:
90202: case OE_Fail: {
90203: int j;
90204: StrAccum errMsg;
90205: const char *zSep;
90206: char *zErr;
90207:
90208: sqlite3StrAccumInit(&errMsg, 0, 0, 200);
90209: errMsg.db = pParse->db;
90210: zSep = pIdx->nColumn>1 ? "columns " : "column ";
90211: for(j=0; j<pIdx->nColumn; j++){
90212: char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
90213: sqlite3StrAccumAppend(&errMsg, zSep, -1);
90214: zSep = ", ";
90215: sqlite3StrAccumAppend(&errMsg, zCol, -1);
90216: }
90217: sqlite3StrAccumAppend(&errMsg,
90218: pIdx->nColumn>1 ? " are not unique" : " is not unique", -1);
90219: zErr = sqlite3StrAccumFinish(&errMsg);
90220: sqlite3HaltConstraint(pParse, onError, zErr, 0);
90221: sqlite3DbFree(errMsg.db, zErr);
90222: break;
90223: }
90224: case OE_Ignore: {
90225: assert( seenReplace==0 );
90226: sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
90227: break;
90228: }
90229: default: {
90230: Trigger *pTrigger = 0;
90231: assert( onError==OE_Replace );
90232: sqlite3MultiWrite(pParse);
90233: if( pParse->db->flags&SQLITE_RecTriggers ){
90234: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
90235: }
90236: sqlite3GenerateRowDelete(
90237: pParse, pTab, baseCur, regR, 0, pTrigger, OE_Replace
90238: );
90239: seenReplace = 1;
90240: break;
90241: }
90242: }
90243: sqlite3VdbeJumpHere(v, j3);
90244: sqlite3ReleaseTempReg(pParse, regR);
90245: }
90246:
90247: if( pbMayReplace ){
90248: *pbMayReplace = seenReplace;
90249: }
90250: }
90251:
90252: /*
90253: ** This routine generates code to finish the INSERT or UPDATE operation
90254: ** that was started by a prior call to sqlite3GenerateConstraintChecks.
90255: ** A consecutive range of registers starting at regRowid contains the
90256: ** rowid and the content to be inserted.
90257: **
90258: ** The arguments to this routine should be the same as the first six
90259: ** arguments to sqlite3GenerateConstraintChecks.
90260: */
90261: SQLITE_PRIVATE void sqlite3CompleteInsertion(
90262: Parse *pParse, /* The parser context */
90263: Table *pTab, /* the table into which we are inserting */
90264: int baseCur, /* Index of a read/write cursor pointing at pTab */
90265: int regRowid, /* Range of content */
90266: int *aRegIdx, /* Register used by each index. 0 for unused indices */
90267: int isUpdate, /* True for UPDATE, False for INSERT */
90268: int appendBias, /* True if this is likely to be an append */
90269: int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
90270: ){
90271: int i;
90272: Vdbe *v;
90273: int nIdx;
90274: Index *pIdx;
90275: u8 pik_flags;
90276: int regData;
90277: int regRec;
90278:
90279: v = sqlite3GetVdbe(pParse);
90280: assert( v!=0 );
90281: assert( pTab->pSelect==0 ); /* This table is not a VIEW */
90282: for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
90283: for(i=nIdx-1; i>=0; i--){
90284: if( aRegIdx[i]==0 ) continue;
90285: sqlite3VdbeAddOp2(v, OP_IdxInsert, baseCur+i+1, aRegIdx[i]);
90286: if( useSeekResult ){
90287: sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
90288: }
90289: }
90290: regData = regRowid + 1;
90291: regRec = sqlite3GetTempReg(pParse);
90292: sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
90293: sqlite3TableAffinityStr(v, pTab);
90294: sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
90295: if( pParse->nested ){
90296: pik_flags = 0;
90297: }else{
90298: pik_flags = OPFLAG_NCHANGE;
90299: pik_flags |= (isUpdate?OPFLAG_ISUPDATE:OPFLAG_LASTROWID);
90300: }
90301: if( appendBias ){
90302: pik_flags |= OPFLAG_APPEND;
90303: }
90304: if( useSeekResult ){
90305: pik_flags |= OPFLAG_USESEEKRESULT;
90306: }
90307: sqlite3VdbeAddOp3(v, OP_Insert, baseCur, regRec, regRowid);
90308: if( !pParse->nested ){
90309: sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
90310: }
90311: sqlite3VdbeChangeP5(v, pik_flags);
90312: }
90313:
90314: /*
90315: ** Generate code that will open cursors for a table and for all
90316: ** indices of that table. The "baseCur" parameter is the cursor number used
90317: ** for the table. Indices are opened on subsequent cursors.
90318: **
90319: ** Return the number of indices on the table.
90320: */
90321: SQLITE_PRIVATE int sqlite3OpenTableAndIndices(
90322: Parse *pParse, /* Parsing context */
90323: Table *pTab, /* Table to be opened */
90324: int baseCur, /* Cursor number assigned to the table */
90325: int op /* OP_OpenRead or OP_OpenWrite */
90326: ){
90327: int i;
90328: int iDb;
90329: Index *pIdx;
90330: Vdbe *v;
90331:
90332: if( IsVirtual(pTab) ) return 0;
90333: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
90334: v = sqlite3GetVdbe(pParse);
90335: assert( v!=0 );
90336: sqlite3OpenTable(pParse, baseCur, iDb, pTab, op);
90337: for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
90338: KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
90339: assert( pIdx->pSchema==pTab->pSchema );
90340: sqlite3VdbeAddOp4(v, op, i+baseCur, pIdx->tnum, iDb,
90341: (char*)pKey, P4_KEYINFO_HANDOFF);
90342: VdbeComment((v, "%s", pIdx->zName));
90343: }
90344: if( pParse->nTab<baseCur+i ){
90345: pParse->nTab = baseCur+i;
90346: }
90347: return i-1;
90348: }
90349:
90350:
90351: #ifdef SQLITE_TEST
90352: /*
90353: ** The following global variable is incremented whenever the
90354: ** transfer optimization is used. This is used for testing
90355: ** purposes only - to make sure the transfer optimization really
90356: ** is happening when it is suppose to.
90357: */
90358: SQLITE_API int sqlite3_xferopt_count;
90359: #endif /* SQLITE_TEST */
90360:
90361:
90362: #ifndef SQLITE_OMIT_XFER_OPT
90363: /*
90364: ** Check to collation names to see if they are compatible.
90365: */
90366: static int xferCompatibleCollation(const char *z1, const char *z2){
90367: if( z1==0 ){
90368: return z2==0;
90369: }
90370: if( z2==0 ){
90371: return 0;
90372: }
90373: return sqlite3StrICmp(z1, z2)==0;
90374: }
90375:
90376:
90377: /*
90378: ** Check to see if index pSrc is compatible as a source of data
90379: ** for index pDest in an insert transfer optimization. The rules
90380: ** for a compatible index:
90381: **
90382: ** * The index is over the same set of columns
90383: ** * The same DESC and ASC markings occurs on all columns
90384: ** * The same onError processing (OE_Abort, OE_Ignore, etc)
90385: ** * The same collating sequence on each column
90386: */
90387: static int xferCompatibleIndex(Index *pDest, Index *pSrc){
90388: int i;
90389: assert( pDest && pSrc );
90390: assert( pDest->pTable!=pSrc->pTable );
90391: if( pDest->nColumn!=pSrc->nColumn ){
90392: return 0; /* Different number of columns */
90393: }
90394: if( pDest->onError!=pSrc->onError ){
90395: return 0; /* Different conflict resolution strategies */
90396: }
90397: for(i=0; i<pSrc->nColumn; i++){
90398: if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
90399: return 0; /* Different columns indexed */
90400: }
90401: if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
90402: return 0; /* Different sort orders */
90403: }
90404: if( !xferCompatibleCollation(pSrc->azColl[i],pDest->azColl[i]) ){
90405: return 0; /* Different collating sequences */
90406: }
90407: }
90408:
90409: /* If no test above fails then the indices must be compatible */
90410: return 1;
90411: }
90412:
90413: /*
90414: ** Attempt the transfer optimization on INSERTs of the form
90415: **
90416: ** INSERT INTO tab1 SELECT * FROM tab2;
90417: **
90418: ** The xfer optimization transfers raw records from tab2 over to tab1.
90419: ** Columns are not decoded and reassemblied, which greatly improves
90420: ** performance. Raw index records are transferred in the same way.
90421: **
90422: ** The xfer optimization is only attempted if tab1 and tab2 are compatible.
90423: ** There are lots of rules for determining compatibility - see comments
90424: ** embedded in the code for details.
90425: **
90426: ** This routine returns TRUE if the optimization is guaranteed to be used.
90427: ** Sometimes the xfer optimization will only work if the destination table
90428: ** is empty - a factor that can only be determined at run-time. In that
90429: ** case, this routine generates code for the xfer optimization but also
90430: ** does a test to see if the destination table is empty and jumps over the
90431: ** xfer optimization code if the test fails. In that case, this routine
90432: ** returns FALSE so that the caller will know to go ahead and generate
90433: ** an unoptimized transfer. This routine also returns FALSE if there
90434: ** is no chance that the xfer optimization can be applied.
90435: **
90436: ** This optimization is particularly useful at making VACUUM run faster.
90437: */
90438: static int xferOptimization(
90439: Parse *pParse, /* Parser context */
90440: Table *pDest, /* The table we are inserting into */
90441: Select *pSelect, /* A SELECT statement to use as the data source */
90442: int onError, /* How to handle constraint errors */
90443: int iDbDest /* The database of pDest */
90444: ){
90445: ExprList *pEList; /* The result set of the SELECT */
90446: Table *pSrc; /* The table in the FROM clause of SELECT */
90447: Index *pSrcIdx, *pDestIdx; /* Source and destination indices */
90448: struct SrcList_item *pItem; /* An element of pSelect->pSrc */
90449: int i; /* Loop counter */
90450: int iDbSrc; /* The database of pSrc */
90451: int iSrc, iDest; /* Cursors from source and destination */
90452: int addr1, addr2; /* Loop addresses */
90453: int emptyDestTest; /* Address of test for empty pDest */
90454: int emptySrcTest; /* Address of test for empty pSrc */
90455: Vdbe *v; /* The VDBE we are building */
90456: KeyInfo *pKey; /* Key information for an index */
90457: int regAutoinc; /* Memory register used by AUTOINC */
90458: int destHasUniqueIdx = 0; /* True if pDest has a UNIQUE index */
90459: int regData, regRowid; /* Registers holding data and rowid */
90460:
90461: if( pSelect==0 ){
90462: return 0; /* Must be of the form INSERT INTO ... SELECT ... */
90463: }
90464: if( sqlite3TriggerList(pParse, pDest) ){
90465: return 0; /* tab1 must not have triggers */
90466: }
90467: #ifndef SQLITE_OMIT_VIRTUALTABLE
90468: if( pDest->tabFlags & TF_Virtual ){
90469: return 0; /* tab1 must not be a virtual table */
90470: }
90471: #endif
90472: if( onError==OE_Default ){
90473: if( pDest->iPKey>=0 ) onError = pDest->keyConf;
90474: if( onError==OE_Default ) onError = OE_Abort;
90475: }
90476: assert(pSelect->pSrc); /* allocated even if there is no FROM clause */
90477: if( pSelect->pSrc->nSrc!=1 ){
90478: return 0; /* FROM clause must have exactly one term */
90479: }
90480: if( pSelect->pSrc->a[0].pSelect ){
90481: return 0; /* FROM clause cannot contain a subquery */
90482: }
90483: if( pSelect->pWhere ){
90484: return 0; /* SELECT may not have a WHERE clause */
90485: }
90486: if( pSelect->pOrderBy ){
90487: return 0; /* SELECT may not have an ORDER BY clause */
90488: }
90489: /* Do not need to test for a HAVING clause. If HAVING is present but
90490: ** there is no ORDER BY, we will get an error. */
90491: if( pSelect->pGroupBy ){
90492: return 0; /* SELECT may not have a GROUP BY clause */
90493: }
90494: if( pSelect->pLimit ){
90495: return 0; /* SELECT may not have a LIMIT clause */
90496: }
90497: assert( pSelect->pOffset==0 ); /* Must be so if pLimit==0 */
90498: if( pSelect->pPrior ){
90499: return 0; /* SELECT may not be a compound query */
90500: }
90501: if( pSelect->selFlags & SF_Distinct ){
90502: return 0; /* SELECT may not be DISTINCT */
90503: }
90504: pEList = pSelect->pEList;
90505: assert( pEList!=0 );
90506: if( pEList->nExpr!=1 ){
90507: return 0; /* The result set must have exactly one column */
90508: }
90509: assert( pEList->a[0].pExpr );
90510: if( pEList->a[0].pExpr->op!=TK_ALL ){
90511: return 0; /* The result set must be the special operator "*" */
90512: }
90513:
90514: /* At this point we have established that the statement is of the
90515: ** correct syntactic form to participate in this optimization. Now
90516: ** we have to check the semantics.
90517: */
90518: pItem = pSelect->pSrc->a;
90519: pSrc = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
90520: if( pSrc==0 ){
90521: return 0; /* FROM clause does not contain a real table */
90522: }
90523: if( pSrc==pDest ){
90524: return 0; /* tab1 and tab2 may not be the same table */
90525: }
90526: #ifndef SQLITE_OMIT_VIRTUALTABLE
90527: if( pSrc->tabFlags & TF_Virtual ){
90528: return 0; /* tab2 must not be a virtual table */
90529: }
90530: #endif
90531: if( pSrc->pSelect ){
90532: return 0; /* tab2 may not be a view */
90533: }
90534: if( pDest->nCol!=pSrc->nCol ){
90535: return 0; /* Number of columns must be the same in tab1 and tab2 */
90536: }
90537: if( pDest->iPKey!=pSrc->iPKey ){
90538: return 0; /* Both tables must have the same INTEGER PRIMARY KEY */
90539: }
90540: for(i=0; i<pDest->nCol; i++){
90541: if( pDest->aCol[i].affinity!=pSrc->aCol[i].affinity ){
90542: return 0; /* Affinity must be the same on all columns */
90543: }
90544: if( !xferCompatibleCollation(pDest->aCol[i].zColl, pSrc->aCol[i].zColl) ){
90545: return 0; /* Collating sequence must be the same on all columns */
90546: }
90547: if( pDest->aCol[i].notNull && !pSrc->aCol[i].notNull ){
90548: return 0; /* tab2 must be NOT NULL if tab1 is */
90549: }
90550: }
90551: for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
90552: if( pDestIdx->onError!=OE_None ){
90553: destHasUniqueIdx = 1;
90554: }
90555: for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
90556: if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
90557: }
90558: if( pSrcIdx==0 ){
90559: return 0; /* pDestIdx has no corresponding index in pSrc */
90560: }
90561: }
90562: #ifndef SQLITE_OMIT_CHECK
90563: if( pDest->pCheck && sqlite3ExprCompare(pSrc->pCheck, pDest->pCheck) ){
90564: return 0; /* Tables have different CHECK constraints. Ticket #2252 */
90565: }
90566: #endif
90567: #ifndef SQLITE_OMIT_FOREIGN_KEY
90568: /* Disallow the transfer optimization if the destination table constains
90569: ** any foreign key constraints. This is more restrictive than necessary.
90570: ** But the main beneficiary of the transfer optimization is the VACUUM
90571: ** command, and the VACUUM command disables foreign key constraints. So
90572: ** the extra complication to make this rule less restrictive is probably
90573: ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
90574: */
90575: if( (pParse->db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
90576: return 0;
90577: }
90578: #endif
90579: if( (pParse->db->flags & SQLITE_CountRows)!=0 ){
90580: return 0; /* xfer opt does not play well with PRAGMA count_changes */
90581: }
90582:
90583: /* If we get this far, it means that the xfer optimization is at
90584: ** least a possibility, though it might only work if the destination
90585: ** table (tab1) is initially empty.
90586: */
90587: #ifdef SQLITE_TEST
90588: sqlite3_xferopt_count++;
90589: #endif
90590: iDbSrc = sqlite3SchemaToIndex(pParse->db, pSrc->pSchema);
90591: v = sqlite3GetVdbe(pParse);
90592: sqlite3CodeVerifySchema(pParse, iDbSrc);
90593: iSrc = pParse->nTab++;
90594: iDest = pParse->nTab++;
90595: regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
90596: sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
90597: if( (pDest->iPKey<0 && pDest->pIndex!=0) /* (1) */
90598: || destHasUniqueIdx /* (2) */
90599: || (onError!=OE_Abort && onError!=OE_Rollback) /* (3) */
90600: ){
90601: /* In some circumstances, we are able to run the xfer optimization
90602: ** only if the destination table is initially empty. This code makes
90603: ** that determination. Conditions under which the destination must
90604: ** be empty:
90605: **
90606: ** (1) There is no INTEGER PRIMARY KEY but there are indices.
90607: ** (If the destination is not initially empty, the rowid fields
90608: ** of index entries might need to change.)
90609: **
90610: ** (2) The destination has a unique index. (The xfer optimization
90611: ** is unable to test uniqueness.)
90612: **
90613: ** (3) onError is something other than OE_Abort and OE_Rollback.
90614: */
90615: addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0);
90616: emptyDestTest = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
90617: sqlite3VdbeJumpHere(v, addr1);
90618: }else{
90619: emptyDestTest = 0;
90620: }
90621: sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
90622: emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
90623: regData = sqlite3GetTempReg(pParse);
90624: regRowid = sqlite3GetTempReg(pParse);
90625: if( pDest->iPKey>=0 ){
90626: addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
90627: addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
90628: sqlite3HaltConstraint(
90629: pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
90630: sqlite3VdbeJumpHere(v, addr2);
90631: autoIncStep(pParse, regAutoinc, regRowid);
90632: }else if( pDest->pIndex==0 ){
90633: addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
90634: }else{
90635: addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
90636: assert( (pDest->tabFlags & TF_Autoincrement)==0 );
90637: }
90638: sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
90639: sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
90640: sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND);
90641: sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
90642: sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1);
90643: for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
90644: for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
90645: if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
90646: }
90647: assert( pSrcIdx );
90648: sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
90649: sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
90650: pKey = sqlite3IndexKeyinfo(pParse, pSrcIdx);
90651: sqlite3VdbeAddOp4(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc,
90652: (char*)pKey, P4_KEYINFO_HANDOFF);
90653: VdbeComment((v, "%s", pSrcIdx->zName));
90654: pKey = sqlite3IndexKeyinfo(pParse, pDestIdx);
90655: sqlite3VdbeAddOp4(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest,
90656: (char*)pKey, P4_KEYINFO_HANDOFF);
90657: VdbeComment((v, "%s", pDestIdx->zName));
90658: addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
90659: sqlite3VdbeAddOp2(v, OP_RowKey, iSrc, regData);
90660: sqlite3VdbeAddOp3(v, OP_IdxInsert, iDest, regData, 1);
90661: sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1);
90662: sqlite3VdbeJumpHere(v, addr1);
90663: }
90664: sqlite3VdbeJumpHere(v, emptySrcTest);
90665: sqlite3ReleaseTempReg(pParse, regRowid);
90666: sqlite3ReleaseTempReg(pParse, regData);
90667: sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
90668: sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
90669: if( emptyDestTest ){
90670: sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
90671: sqlite3VdbeJumpHere(v, emptyDestTest);
90672: sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
90673: return 0;
90674: }else{
90675: return 1;
90676: }
90677: }
90678: #endif /* SQLITE_OMIT_XFER_OPT */
90679:
90680: /************** End of insert.c **********************************************/
90681: /************** Begin file legacy.c ******************************************/
90682: /*
90683: ** 2001 September 15
90684: **
90685: ** The author disclaims copyright to this source code. In place of
90686: ** a legal notice, here is a blessing:
90687: **
90688: ** May you do good and not evil.
90689: ** May you find forgiveness for yourself and forgive others.
90690: ** May you share freely, never taking more than you give.
90691: **
90692: *************************************************************************
90693: ** Main file for the SQLite library. The routines in this file
90694: ** implement the programmer interface to the library. Routines in
90695: ** other files are for internal use by SQLite and should not be
90696: ** accessed by users of the library.
90697: */
90698:
90699:
90700: /*
90701: ** Execute SQL code. Return one of the SQLITE_ success/failure
90702: ** codes. Also write an error message into memory obtained from
90703: ** malloc() and make *pzErrMsg point to that message.
90704: **
90705: ** If the SQL is a query, then for each row in the query result
90706: ** the xCallback() function is called. pArg becomes the first
90707: ** argument to xCallback(). If xCallback=NULL then no callback
90708: ** is invoked, even for queries.
90709: */
90710: SQLITE_API int sqlite3_exec(
90711: sqlite3 *db, /* The database on which the SQL executes */
90712: const char *zSql, /* The SQL to be executed */
90713: sqlite3_callback xCallback, /* Invoke this callback routine */
90714: void *pArg, /* First argument to xCallback() */
90715: char **pzErrMsg /* Write error messages here */
90716: ){
90717: int rc = SQLITE_OK; /* Return code */
90718: const char *zLeftover; /* Tail of unprocessed SQL */
90719: sqlite3_stmt *pStmt = 0; /* The current SQL statement */
90720: char **azCols = 0; /* Names of result columns */
90721: int nRetry = 0; /* Number of retry attempts */
90722: int callbackIsInit; /* True if callback data is initialized */
90723:
90724: if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
90725: if( zSql==0 ) zSql = "";
90726:
90727: sqlite3_mutex_enter(db->mutex);
90728: sqlite3Error(db, SQLITE_OK, 0);
90729: while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){
90730: int nCol;
90731: char **azVals = 0;
90732:
90733: pStmt = 0;
90734: rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover);
90735: assert( rc==SQLITE_OK || pStmt==0 );
90736: if( rc!=SQLITE_OK ){
90737: continue;
90738: }
90739: if( !pStmt ){
90740: /* this happens for a comment or white-space */
90741: zSql = zLeftover;
90742: continue;
90743: }
90744:
90745: callbackIsInit = 0;
90746: nCol = sqlite3_column_count(pStmt);
90747:
90748: while( 1 ){
90749: int i;
90750: rc = sqlite3_step(pStmt);
90751:
90752: /* Invoke the callback function if required */
90753: if( xCallback && (SQLITE_ROW==rc ||
90754: (SQLITE_DONE==rc && !callbackIsInit
90755: && db->flags&SQLITE_NullCallback)) ){
90756: if( !callbackIsInit ){
90757: azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
90758: if( azCols==0 ){
90759: goto exec_out;
90760: }
90761: for(i=0; i<nCol; i++){
90762: azCols[i] = (char *)sqlite3_column_name(pStmt, i);
90763: /* sqlite3VdbeSetColName() installs column names as UTF8
90764: ** strings so there is no way for sqlite3_column_name() to fail. */
90765: assert( azCols[i]!=0 );
90766: }
90767: callbackIsInit = 1;
90768: }
90769: if( rc==SQLITE_ROW ){
90770: azVals = &azCols[nCol];
90771: for(i=0; i<nCol; i++){
90772: azVals[i] = (char *)sqlite3_column_text(pStmt, i);
90773: if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
90774: db->mallocFailed = 1;
90775: goto exec_out;
90776: }
90777: }
90778: }
90779: if( xCallback(pArg, nCol, azVals, azCols) ){
90780: rc = SQLITE_ABORT;
90781: sqlite3VdbeFinalize((Vdbe *)pStmt);
90782: pStmt = 0;
90783: sqlite3Error(db, SQLITE_ABORT, 0);
90784: goto exec_out;
90785: }
90786: }
90787:
90788: if( rc!=SQLITE_ROW ){
90789: rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
90790: pStmt = 0;
90791: if( rc!=SQLITE_SCHEMA ){
90792: nRetry = 0;
90793: zSql = zLeftover;
90794: while( sqlite3Isspace(zSql[0]) ) zSql++;
90795: }
90796: break;
90797: }
90798: }
90799:
90800: sqlite3DbFree(db, azCols);
90801: azCols = 0;
90802: }
90803:
90804: exec_out:
90805: if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
90806: sqlite3DbFree(db, azCols);
90807:
90808: rc = sqlite3ApiExit(db, rc);
90809: if( rc!=SQLITE_OK && ALWAYS(rc==sqlite3_errcode(db)) && pzErrMsg ){
90810: int nErrMsg = 1 + sqlite3Strlen30(sqlite3_errmsg(db));
90811: *pzErrMsg = sqlite3Malloc(nErrMsg);
90812: if( *pzErrMsg ){
90813: memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg);
90814: }else{
90815: rc = SQLITE_NOMEM;
90816: sqlite3Error(db, SQLITE_NOMEM, 0);
90817: }
90818: }else if( pzErrMsg ){
90819: *pzErrMsg = 0;
90820: }
90821:
90822: assert( (rc&db->errMask)==rc );
90823: sqlite3_mutex_leave(db->mutex);
90824: return rc;
90825: }
90826:
90827: /************** End of legacy.c **********************************************/
90828: /************** Begin file loadext.c *****************************************/
90829: /*
90830: ** 2006 June 7
90831: **
90832: ** The author disclaims copyright to this source code. In place of
90833: ** a legal notice, here is a blessing:
90834: **
90835: ** May you do good and not evil.
90836: ** May you find forgiveness for yourself and forgive others.
90837: ** May you share freely, never taking more than you give.
90838: **
90839: *************************************************************************
90840: ** This file contains code used to dynamically load extensions into
90841: ** the SQLite library.
90842: */
90843:
90844: #ifndef SQLITE_CORE
90845: #define SQLITE_CORE 1 /* Disable the API redefinition in sqlite3ext.h */
90846: #endif
90847: /************** Include sqlite3ext.h in the middle of loadext.c **************/
90848: /************** Begin file sqlite3ext.h **************************************/
90849: /*
90850: ** 2006 June 7
90851: **
90852: ** The author disclaims copyright to this source code. In place of
90853: ** a legal notice, here is a blessing:
90854: **
90855: ** May you do good and not evil.
90856: ** May you find forgiveness for yourself and forgive others.
90857: ** May you share freely, never taking more than you give.
90858: **
90859: *************************************************************************
90860: ** This header file defines the SQLite interface for use by
90861: ** shared libraries that want to be imported as extensions into
90862: ** an SQLite instance. Shared libraries that intend to be loaded
90863: ** as extensions by SQLite should #include this file instead of
90864: ** sqlite3.h.
90865: */
90866: #ifndef _SQLITE3EXT_H_
90867: #define _SQLITE3EXT_H_
90868:
90869: typedef struct sqlite3_api_routines sqlite3_api_routines;
90870:
90871: /*
90872: ** The following structure holds pointers to all of the SQLite API
90873: ** routines.
90874: **
90875: ** WARNING: In order to maintain backwards compatibility, add new
90876: ** interfaces to the end of this structure only. If you insert new
90877: ** interfaces in the middle of this structure, then older different
90878: ** versions of SQLite will not be able to load each others' shared
90879: ** libraries!
90880: */
90881: struct sqlite3_api_routines {
90882: void * (*aggregate_context)(sqlite3_context*,int nBytes);
90883: int (*aggregate_count)(sqlite3_context*);
90884: int (*bind_blob)(sqlite3_stmt*,int,const void*,int n,void(*)(void*));
90885: int (*bind_double)(sqlite3_stmt*,int,double);
90886: int (*bind_int)(sqlite3_stmt*,int,int);
90887: int (*bind_int64)(sqlite3_stmt*,int,sqlite_int64);
90888: int (*bind_null)(sqlite3_stmt*,int);
90889: int (*bind_parameter_count)(sqlite3_stmt*);
90890: int (*bind_parameter_index)(sqlite3_stmt*,const char*zName);
90891: const char * (*bind_parameter_name)(sqlite3_stmt*,int);
90892: int (*bind_text)(sqlite3_stmt*,int,const char*,int n,void(*)(void*));
90893: int (*bind_text16)(sqlite3_stmt*,int,const void*,int,void(*)(void*));
90894: int (*bind_value)(sqlite3_stmt*,int,const sqlite3_value*);
90895: int (*busy_handler)(sqlite3*,int(*)(void*,int),void*);
90896: int (*busy_timeout)(sqlite3*,int ms);
90897: int (*changes)(sqlite3*);
90898: int (*close)(sqlite3*);
90899: int (*collation_needed)(sqlite3*,void*,void(*)(void*,sqlite3*,
90900: int eTextRep,const char*));
90901: int (*collation_needed16)(sqlite3*,void*,void(*)(void*,sqlite3*,
90902: int eTextRep,const void*));
90903: const void * (*column_blob)(sqlite3_stmt*,int iCol);
90904: int (*column_bytes)(sqlite3_stmt*,int iCol);
90905: int (*column_bytes16)(sqlite3_stmt*,int iCol);
90906: int (*column_count)(sqlite3_stmt*pStmt);
90907: const char * (*column_database_name)(sqlite3_stmt*,int);
90908: const void * (*column_database_name16)(sqlite3_stmt*,int);
90909: const char * (*column_decltype)(sqlite3_stmt*,int i);
90910: const void * (*column_decltype16)(sqlite3_stmt*,int);
90911: double (*column_double)(sqlite3_stmt*,int iCol);
90912: int (*column_int)(sqlite3_stmt*,int iCol);
90913: sqlite_int64 (*column_int64)(sqlite3_stmt*,int iCol);
90914: const char * (*column_name)(sqlite3_stmt*,int);
90915: const void * (*column_name16)(sqlite3_stmt*,int);
90916: const char * (*column_origin_name)(sqlite3_stmt*,int);
90917: const void * (*column_origin_name16)(sqlite3_stmt*,int);
90918: const char * (*column_table_name)(sqlite3_stmt*,int);
90919: const void * (*column_table_name16)(sqlite3_stmt*,int);
90920: const unsigned char * (*column_text)(sqlite3_stmt*,int iCol);
90921: const void * (*column_text16)(sqlite3_stmt*,int iCol);
90922: int (*column_type)(sqlite3_stmt*,int iCol);
90923: sqlite3_value* (*column_value)(sqlite3_stmt*,int iCol);
90924: void * (*commit_hook)(sqlite3*,int(*)(void*),void*);
90925: int (*complete)(const char*sql);
90926: int (*complete16)(const void*sql);
90927: int (*create_collation)(sqlite3*,const char*,int,void*,
90928: int(*)(void*,int,const void*,int,const void*));
90929: int (*create_collation16)(sqlite3*,const void*,int,void*,
90930: int(*)(void*,int,const void*,int,const void*));
90931: int (*create_function)(sqlite3*,const char*,int,int,void*,
90932: void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
90933: void (*xStep)(sqlite3_context*,int,sqlite3_value**),
90934: void (*xFinal)(sqlite3_context*));
90935: int (*create_function16)(sqlite3*,const void*,int,int,void*,
90936: void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
90937: void (*xStep)(sqlite3_context*,int,sqlite3_value**),
90938: void (*xFinal)(sqlite3_context*));
90939: int (*create_module)(sqlite3*,const char*,const sqlite3_module*,void*);
90940: int (*data_count)(sqlite3_stmt*pStmt);
90941: sqlite3 * (*db_handle)(sqlite3_stmt*);
90942: int (*declare_vtab)(sqlite3*,const char*);
90943: int (*enable_shared_cache)(int);
90944: int (*errcode)(sqlite3*db);
90945: const char * (*errmsg)(sqlite3*);
90946: const void * (*errmsg16)(sqlite3*);
90947: int (*exec)(sqlite3*,const char*,sqlite3_callback,void*,char**);
90948: int (*expired)(sqlite3_stmt*);
90949: int (*finalize)(sqlite3_stmt*pStmt);
90950: void (*free)(void*);
90951: void (*free_table)(char**result);
90952: int (*get_autocommit)(sqlite3*);
90953: void * (*get_auxdata)(sqlite3_context*,int);
90954: int (*get_table)(sqlite3*,const char*,char***,int*,int*,char**);
90955: int (*global_recover)(void);
90956: void (*interruptx)(sqlite3*);
90957: sqlite_int64 (*last_insert_rowid)(sqlite3*);
90958: const char * (*libversion)(void);
90959: int (*libversion_number)(void);
90960: void *(*malloc)(int);
90961: char * (*mprintf)(const char*,...);
90962: int (*open)(const char*,sqlite3**);
90963: int (*open16)(const void*,sqlite3**);
90964: int (*prepare)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
90965: int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
90966: void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
90967: void (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
90968: void *(*realloc)(void*,int);
90969: int (*reset)(sqlite3_stmt*pStmt);
90970: void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
90971: void (*result_double)(sqlite3_context*,double);
90972: void (*result_error)(sqlite3_context*,const char*,int);
90973: void (*result_error16)(sqlite3_context*,const void*,int);
90974: void (*result_int)(sqlite3_context*,int);
90975: void (*result_int64)(sqlite3_context*,sqlite_int64);
90976: void (*result_null)(sqlite3_context*);
90977: void (*result_text)(sqlite3_context*,const char*,int,void(*)(void*));
90978: void (*result_text16)(sqlite3_context*,const void*,int,void(*)(void*));
90979: void (*result_text16be)(sqlite3_context*,const void*,int,void(*)(void*));
90980: void (*result_text16le)(sqlite3_context*,const void*,int,void(*)(void*));
90981: void (*result_value)(sqlite3_context*,sqlite3_value*);
90982: void * (*rollback_hook)(sqlite3*,void(*)(void*),void*);
90983: int (*set_authorizer)(sqlite3*,int(*)(void*,int,const char*,const char*,
90984: const char*,const char*),void*);
90985: void (*set_auxdata)(sqlite3_context*,int,void*,void (*)(void*));
90986: char * (*snprintf)(int,char*,const char*,...);
90987: int (*step)(sqlite3_stmt*);
90988: int (*table_column_metadata)(sqlite3*,const char*,const char*,const char*,
90989: char const**,char const**,int*,int*,int*);
90990: void (*thread_cleanup)(void);
90991: int (*total_changes)(sqlite3*);
90992: void * (*trace)(sqlite3*,void(*xTrace)(void*,const char*),void*);
90993: int (*transfer_bindings)(sqlite3_stmt*,sqlite3_stmt*);
90994: void * (*update_hook)(sqlite3*,void(*)(void*,int ,char const*,char const*,
90995: sqlite_int64),void*);
90996: void * (*user_data)(sqlite3_context*);
90997: const void * (*value_blob)(sqlite3_value*);
90998: int (*value_bytes)(sqlite3_value*);
90999: int (*value_bytes16)(sqlite3_value*);
91000: double (*value_double)(sqlite3_value*);
91001: int (*value_int)(sqlite3_value*);
91002: sqlite_int64 (*value_int64)(sqlite3_value*);
91003: int (*value_numeric_type)(sqlite3_value*);
91004: const unsigned char * (*value_text)(sqlite3_value*);
91005: const void * (*value_text16)(sqlite3_value*);
91006: const void * (*value_text16be)(sqlite3_value*);
91007: const void * (*value_text16le)(sqlite3_value*);
91008: int (*value_type)(sqlite3_value*);
91009: char *(*vmprintf)(const char*,va_list);
91010: /* Added ??? */
91011: int (*overload_function)(sqlite3*, const char *zFuncName, int nArg);
91012: /* Added by 3.3.13 */
91013: int (*prepare_v2)(sqlite3*,const char*,int,sqlite3_stmt**,const char**);
91014: int (*prepare16_v2)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
91015: int (*clear_bindings)(sqlite3_stmt*);
91016: /* Added by 3.4.1 */
91017: int (*create_module_v2)(sqlite3*,const char*,const sqlite3_module*,void*,
91018: void (*xDestroy)(void *));
91019: /* Added by 3.5.0 */
91020: int (*bind_zeroblob)(sqlite3_stmt*,int,int);
91021: int (*blob_bytes)(sqlite3_blob*);
91022: int (*blob_close)(sqlite3_blob*);
91023: int (*blob_open)(sqlite3*,const char*,const char*,const char*,sqlite3_int64,
91024: int,sqlite3_blob**);
91025: int (*blob_read)(sqlite3_blob*,void*,int,int);
91026: int (*blob_write)(sqlite3_blob*,const void*,int,int);
91027: int (*create_collation_v2)(sqlite3*,const char*,int,void*,
91028: int(*)(void*,int,const void*,int,const void*),
91029: void(*)(void*));
91030: int (*file_control)(sqlite3*,const char*,int,void*);
91031: sqlite3_int64 (*memory_highwater)(int);
91032: sqlite3_int64 (*memory_used)(void);
91033: sqlite3_mutex *(*mutex_alloc)(int);
91034: void (*mutex_enter)(sqlite3_mutex*);
91035: void (*mutex_free)(sqlite3_mutex*);
91036: void (*mutex_leave)(sqlite3_mutex*);
91037: int (*mutex_try)(sqlite3_mutex*);
91038: int (*open_v2)(const char*,sqlite3**,int,const char*);
91039: int (*release_memory)(int);
91040: void (*result_error_nomem)(sqlite3_context*);
91041: void (*result_error_toobig)(sqlite3_context*);
91042: int (*sleep)(int);
91043: void (*soft_heap_limit)(int);
91044: sqlite3_vfs *(*vfs_find)(const char*);
91045: int (*vfs_register)(sqlite3_vfs*,int);
91046: int (*vfs_unregister)(sqlite3_vfs*);
91047: int (*xthreadsafe)(void);
91048: void (*result_zeroblob)(sqlite3_context*,int);
91049: void (*result_error_code)(sqlite3_context*,int);
91050: int (*test_control)(int, ...);
91051: void (*randomness)(int,void*);
91052: sqlite3 *(*context_db_handle)(sqlite3_context*);
91053: int (*extended_result_codes)(sqlite3*,int);
91054: int (*limit)(sqlite3*,int,int);
91055: sqlite3_stmt *(*next_stmt)(sqlite3*,sqlite3_stmt*);
91056: const char *(*sql)(sqlite3_stmt*);
91057: int (*status)(int,int*,int*,int);
91058: int (*backup_finish)(sqlite3_backup*);
91059: sqlite3_backup *(*backup_init)(sqlite3*,const char*,sqlite3*,const char*);
91060: int (*backup_pagecount)(sqlite3_backup*);
91061: int (*backup_remaining)(sqlite3_backup*);
91062: int (*backup_step)(sqlite3_backup*,int);
91063: const char *(*compileoption_get)(int);
91064: int (*compileoption_used)(const char*);
91065: int (*create_function_v2)(sqlite3*,const char*,int,int,void*,
91066: void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
91067: void (*xStep)(sqlite3_context*,int,sqlite3_value**),
91068: void (*xFinal)(sqlite3_context*),
91069: void(*xDestroy)(void*));
91070: int (*db_config)(sqlite3*,int,...);
91071: sqlite3_mutex *(*db_mutex)(sqlite3*);
91072: int (*db_status)(sqlite3*,int,int*,int*,int);
91073: int (*extended_errcode)(sqlite3*);
91074: void (*log)(int,const char*,...);
91075: sqlite3_int64 (*soft_heap_limit64)(sqlite3_int64);
91076: const char *(*sourceid)(void);
91077: int (*stmt_status)(sqlite3_stmt*,int,int);
91078: int (*strnicmp)(const char*,const char*,int);
91079: int (*unlock_notify)(sqlite3*,void(*)(void**,int),void*);
91080: int (*wal_autocheckpoint)(sqlite3*,int);
91081: int (*wal_checkpoint)(sqlite3*,const char*);
91082: void *(*wal_hook)(sqlite3*,int(*)(void*,sqlite3*,const char*,int),void*);
91083: int (*blob_reopen)(sqlite3_blob*,sqlite3_int64);
91084: int (*vtab_config)(sqlite3*,int op,...);
91085: int (*vtab_on_conflict)(sqlite3*);
91086: };
91087:
91088: /*
91089: ** The following macros redefine the API routines so that they are
91090: ** redirected throught the global sqlite3_api structure.
91091: **
91092: ** This header file is also used by the loadext.c source file
91093: ** (part of the main SQLite library - not an extension) so that
91094: ** it can get access to the sqlite3_api_routines structure
91095: ** definition. But the main library does not want to redefine
91096: ** the API. So the redefinition macros are only valid if the
91097: ** SQLITE_CORE macros is undefined.
91098: */
91099: #ifndef SQLITE_CORE
91100: #define sqlite3_aggregate_context sqlite3_api->aggregate_context
91101: #ifndef SQLITE_OMIT_DEPRECATED
91102: #define sqlite3_aggregate_count sqlite3_api->aggregate_count
91103: #endif
91104: #define sqlite3_bind_blob sqlite3_api->bind_blob
91105: #define sqlite3_bind_double sqlite3_api->bind_double
91106: #define sqlite3_bind_int sqlite3_api->bind_int
91107: #define sqlite3_bind_int64 sqlite3_api->bind_int64
91108: #define sqlite3_bind_null sqlite3_api->bind_null
91109: #define sqlite3_bind_parameter_count sqlite3_api->bind_parameter_count
91110: #define sqlite3_bind_parameter_index sqlite3_api->bind_parameter_index
91111: #define sqlite3_bind_parameter_name sqlite3_api->bind_parameter_name
91112: #define sqlite3_bind_text sqlite3_api->bind_text
91113: #define sqlite3_bind_text16 sqlite3_api->bind_text16
91114: #define sqlite3_bind_value sqlite3_api->bind_value
91115: #define sqlite3_busy_handler sqlite3_api->busy_handler
91116: #define sqlite3_busy_timeout sqlite3_api->busy_timeout
91117: #define sqlite3_changes sqlite3_api->changes
91118: #define sqlite3_close sqlite3_api->close
91119: #define sqlite3_collation_needed sqlite3_api->collation_needed
91120: #define sqlite3_collation_needed16 sqlite3_api->collation_needed16
91121: #define sqlite3_column_blob sqlite3_api->column_blob
91122: #define sqlite3_column_bytes sqlite3_api->column_bytes
91123: #define sqlite3_column_bytes16 sqlite3_api->column_bytes16
91124: #define sqlite3_column_count sqlite3_api->column_count
91125: #define sqlite3_column_database_name sqlite3_api->column_database_name
91126: #define sqlite3_column_database_name16 sqlite3_api->column_database_name16
91127: #define sqlite3_column_decltype sqlite3_api->column_decltype
91128: #define sqlite3_column_decltype16 sqlite3_api->column_decltype16
91129: #define sqlite3_column_double sqlite3_api->column_double
91130: #define sqlite3_column_int sqlite3_api->column_int
91131: #define sqlite3_column_int64 sqlite3_api->column_int64
91132: #define sqlite3_column_name sqlite3_api->column_name
91133: #define sqlite3_column_name16 sqlite3_api->column_name16
91134: #define sqlite3_column_origin_name sqlite3_api->column_origin_name
91135: #define sqlite3_column_origin_name16 sqlite3_api->column_origin_name16
91136: #define sqlite3_column_table_name sqlite3_api->column_table_name
91137: #define sqlite3_column_table_name16 sqlite3_api->column_table_name16
91138: #define sqlite3_column_text sqlite3_api->column_text
91139: #define sqlite3_column_text16 sqlite3_api->column_text16
91140: #define sqlite3_column_type sqlite3_api->column_type
91141: #define sqlite3_column_value sqlite3_api->column_value
91142: #define sqlite3_commit_hook sqlite3_api->commit_hook
91143: #define sqlite3_complete sqlite3_api->complete
91144: #define sqlite3_complete16 sqlite3_api->complete16
91145: #define sqlite3_create_collation sqlite3_api->create_collation
91146: #define sqlite3_create_collation16 sqlite3_api->create_collation16
91147: #define sqlite3_create_function sqlite3_api->create_function
91148: #define sqlite3_create_function16 sqlite3_api->create_function16
91149: #define sqlite3_create_module sqlite3_api->create_module
91150: #define sqlite3_create_module_v2 sqlite3_api->create_module_v2
91151: #define sqlite3_data_count sqlite3_api->data_count
91152: #define sqlite3_db_handle sqlite3_api->db_handle
91153: #define sqlite3_declare_vtab sqlite3_api->declare_vtab
91154: #define sqlite3_enable_shared_cache sqlite3_api->enable_shared_cache
91155: #define sqlite3_errcode sqlite3_api->errcode
91156: #define sqlite3_errmsg sqlite3_api->errmsg
91157: #define sqlite3_errmsg16 sqlite3_api->errmsg16
91158: #define sqlite3_exec sqlite3_api->exec
91159: #ifndef SQLITE_OMIT_DEPRECATED
91160: #define sqlite3_expired sqlite3_api->expired
91161: #endif
91162: #define sqlite3_finalize sqlite3_api->finalize
91163: #define sqlite3_free sqlite3_api->free
91164: #define sqlite3_free_table sqlite3_api->free_table
91165: #define sqlite3_get_autocommit sqlite3_api->get_autocommit
91166: #define sqlite3_get_auxdata sqlite3_api->get_auxdata
91167: #define sqlite3_get_table sqlite3_api->get_table
91168: #ifndef SQLITE_OMIT_DEPRECATED
91169: #define sqlite3_global_recover sqlite3_api->global_recover
91170: #endif
91171: #define sqlite3_interrupt sqlite3_api->interruptx
91172: #define sqlite3_last_insert_rowid sqlite3_api->last_insert_rowid
91173: #define sqlite3_libversion sqlite3_api->libversion
91174: #define sqlite3_libversion_number sqlite3_api->libversion_number
91175: #define sqlite3_malloc sqlite3_api->malloc
91176: #define sqlite3_mprintf sqlite3_api->mprintf
91177: #define sqlite3_open sqlite3_api->open
91178: #define sqlite3_open16 sqlite3_api->open16
91179: #define sqlite3_prepare sqlite3_api->prepare
91180: #define sqlite3_prepare16 sqlite3_api->prepare16
91181: #define sqlite3_prepare_v2 sqlite3_api->prepare_v2
91182: #define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
91183: #define sqlite3_profile sqlite3_api->profile
91184: #define sqlite3_progress_handler sqlite3_api->progress_handler
91185: #define sqlite3_realloc sqlite3_api->realloc
91186: #define sqlite3_reset sqlite3_api->reset
91187: #define sqlite3_result_blob sqlite3_api->result_blob
91188: #define sqlite3_result_double sqlite3_api->result_double
91189: #define sqlite3_result_error sqlite3_api->result_error
91190: #define sqlite3_result_error16 sqlite3_api->result_error16
91191: #define sqlite3_result_int sqlite3_api->result_int
91192: #define sqlite3_result_int64 sqlite3_api->result_int64
91193: #define sqlite3_result_null sqlite3_api->result_null
91194: #define sqlite3_result_text sqlite3_api->result_text
91195: #define sqlite3_result_text16 sqlite3_api->result_text16
91196: #define sqlite3_result_text16be sqlite3_api->result_text16be
91197: #define sqlite3_result_text16le sqlite3_api->result_text16le
91198: #define sqlite3_result_value sqlite3_api->result_value
91199: #define sqlite3_rollback_hook sqlite3_api->rollback_hook
91200: #define sqlite3_set_authorizer sqlite3_api->set_authorizer
91201: #define sqlite3_set_auxdata sqlite3_api->set_auxdata
91202: #define sqlite3_snprintf sqlite3_api->snprintf
91203: #define sqlite3_step sqlite3_api->step
91204: #define sqlite3_table_column_metadata sqlite3_api->table_column_metadata
91205: #define sqlite3_thread_cleanup sqlite3_api->thread_cleanup
91206: #define sqlite3_total_changes sqlite3_api->total_changes
91207: #define sqlite3_trace sqlite3_api->trace
91208: #ifndef SQLITE_OMIT_DEPRECATED
91209: #define sqlite3_transfer_bindings sqlite3_api->transfer_bindings
91210: #endif
91211: #define sqlite3_update_hook sqlite3_api->update_hook
91212: #define sqlite3_user_data sqlite3_api->user_data
91213: #define sqlite3_value_blob sqlite3_api->value_blob
91214: #define sqlite3_value_bytes sqlite3_api->value_bytes
91215: #define sqlite3_value_bytes16 sqlite3_api->value_bytes16
91216: #define sqlite3_value_double sqlite3_api->value_double
91217: #define sqlite3_value_int sqlite3_api->value_int
91218: #define sqlite3_value_int64 sqlite3_api->value_int64
91219: #define sqlite3_value_numeric_type sqlite3_api->value_numeric_type
91220: #define sqlite3_value_text sqlite3_api->value_text
91221: #define sqlite3_value_text16 sqlite3_api->value_text16
91222: #define sqlite3_value_text16be sqlite3_api->value_text16be
91223: #define sqlite3_value_text16le sqlite3_api->value_text16le
91224: #define sqlite3_value_type sqlite3_api->value_type
91225: #define sqlite3_vmprintf sqlite3_api->vmprintf
91226: #define sqlite3_overload_function sqlite3_api->overload_function
91227: #define sqlite3_prepare_v2 sqlite3_api->prepare_v2
91228: #define sqlite3_prepare16_v2 sqlite3_api->prepare16_v2
91229: #define sqlite3_clear_bindings sqlite3_api->clear_bindings
91230: #define sqlite3_bind_zeroblob sqlite3_api->bind_zeroblob
91231: #define sqlite3_blob_bytes sqlite3_api->blob_bytes
91232: #define sqlite3_blob_close sqlite3_api->blob_close
91233: #define sqlite3_blob_open sqlite3_api->blob_open
91234: #define sqlite3_blob_read sqlite3_api->blob_read
91235: #define sqlite3_blob_write sqlite3_api->blob_write
91236: #define sqlite3_create_collation_v2 sqlite3_api->create_collation_v2
91237: #define sqlite3_file_control sqlite3_api->file_control
91238: #define sqlite3_memory_highwater sqlite3_api->memory_highwater
91239: #define sqlite3_memory_used sqlite3_api->memory_used
91240: #define sqlite3_mutex_alloc sqlite3_api->mutex_alloc
91241: #define sqlite3_mutex_enter sqlite3_api->mutex_enter
91242: #define sqlite3_mutex_free sqlite3_api->mutex_free
91243: #define sqlite3_mutex_leave sqlite3_api->mutex_leave
91244: #define sqlite3_mutex_try sqlite3_api->mutex_try
91245: #define sqlite3_open_v2 sqlite3_api->open_v2
91246: #define sqlite3_release_memory sqlite3_api->release_memory
91247: #define sqlite3_result_error_nomem sqlite3_api->result_error_nomem
91248: #define sqlite3_result_error_toobig sqlite3_api->result_error_toobig
91249: #define sqlite3_sleep sqlite3_api->sleep
91250: #define sqlite3_soft_heap_limit sqlite3_api->soft_heap_limit
91251: #define sqlite3_vfs_find sqlite3_api->vfs_find
91252: #define sqlite3_vfs_register sqlite3_api->vfs_register
91253: #define sqlite3_vfs_unregister sqlite3_api->vfs_unregister
91254: #define sqlite3_threadsafe sqlite3_api->xthreadsafe
91255: #define sqlite3_result_zeroblob sqlite3_api->result_zeroblob
91256: #define sqlite3_result_error_code sqlite3_api->result_error_code
91257: #define sqlite3_test_control sqlite3_api->test_control
91258: #define sqlite3_randomness sqlite3_api->randomness
91259: #define sqlite3_context_db_handle sqlite3_api->context_db_handle
91260: #define sqlite3_extended_result_codes sqlite3_api->extended_result_codes
91261: #define sqlite3_limit sqlite3_api->limit
91262: #define sqlite3_next_stmt sqlite3_api->next_stmt
91263: #define sqlite3_sql sqlite3_api->sql
91264: #define sqlite3_status sqlite3_api->status
91265: #define sqlite3_backup_finish sqlite3_api->backup_finish
91266: #define sqlite3_backup_init sqlite3_api->backup_init
91267: #define sqlite3_backup_pagecount sqlite3_api->backup_pagecount
91268: #define sqlite3_backup_remaining sqlite3_api->backup_remaining
91269: #define sqlite3_backup_step sqlite3_api->backup_step
91270: #define sqlite3_compileoption_get sqlite3_api->compileoption_get
91271: #define sqlite3_compileoption_used sqlite3_api->compileoption_used
91272: #define sqlite3_create_function_v2 sqlite3_api->create_function_v2
91273: #define sqlite3_db_config sqlite3_api->db_config
91274: #define sqlite3_db_mutex sqlite3_api->db_mutex
91275: #define sqlite3_db_status sqlite3_api->db_status
91276: #define sqlite3_extended_errcode sqlite3_api->extended_errcode
91277: #define sqlite3_log sqlite3_api->log
91278: #define sqlite3_soft_heap_limit64 sqlite3_api->soft_heap_limit64
91279: #define sqlite3_sourceid sqlite3_api->sourceid
91280: #define sqlite3_stmt_status sqlite3_api->stmt_status
91281: #define sqlite3_strnicmp sqlite3_api->strnicmp
91282: #define sqlite3_unlock_notify sqlite3_api->unlock_notify
91283: #define sqlite3_wal_autocheckpoint sqlite3_api->wal_autocheckpoint
91284: #define sqlite3_wal_checkpoint sqlite3_api->wal_checkpoint
91285: #define sqlite3_wal_hook sqlite3_api->wal_hook
91286: #define sqlite3_blob_reopen sqlite3_api->blob_reopen
91287: #define sqlite3_vtab_config sqlite3_api->vtab_config
91288: #define sqlite3_vtab_on_conflict sqlite3_api->vtab_on_conflict
91289: #endif /* SQLITE_CORE */
91290:
91291: #define SQLITE_EXTENSION_INIT1 const sqlite3_api_routines *sqlite3_api = 0;
91292: #define SQLITE_EXTENSION_INIT2(v) sqlite3_api = v;
91293:
91294: #endif /* _SQLITE3EXT_H_ */
91295:
91296: /************** End of sqlite3ext.h ******************************************/
91297: /************** Continuing where we left off in loadext.c ********************/
91298: /* #include <string.h> */
91299:
91300: #ifndef SQLITE_OMIT_LOAD_EXTENSION
91301:
91302: /*
91303: ** Some API routines are omitted when various features are
91304: ** excluded from a build of SQLite. Substitute a NULL pointer
91305: ** for any missing APIs.
91306: */
91307: #ifndef SQLITE_ENABLE_COLUMN_METADATA
91308: # define sqlite3_column_database_name 0
91309: # define sqlite3_column_database_name16 0
91310: # define sqlite3_column_table_name 0
91311: # define sqlite3_column_table_name16 0
91312: # define sqlite3_column_origin_name 0
91313: # define sqlite3_column_origin_name16 0
91314: # define sqlite3_table_column_metadata 0
91315: #endif
91316:
91317: #ifdef SQLITE_OMIT_AUTHORIZATION
91318: # define sqlite3_set_authorizer 0
91319: #endif
91320:
91321: #ifdef SQLITE_OMIT_UTF16
91322: # define sqlite3_bind_text16 0
91323: # define sqlite3_collation_needed16 0
91324: # define sqlite3_column_decltype16 0
91325: # define sqlite3_column_name16 0
91326: # define sqlite3_column_text16 0
91327: # define sqlite3_complete16 0
91328: # define sqlite3_create_collation16 0
91329: # define sqlite3_create_function16 0
91330: # define sqlite3_errmsg16 0
91331: # define sqlite3_open16 0
91332: # define sqlite3_prepare16 0
91333: # define sqlite3_prepare16_v2 0
91334: # define sqlite3_result_error16 0
91335: # define sqlite3_result_text16 0
91336: # define sqlite3_result_text16be 0
91337: # define sqlite3_result_text16le 0
91338: # define sqlite3_value_text16 0
91339: # define sqlite3_value_text16be 0
91340: # define sqlite3_value_text16le 0
91341: # define sqlite3_column_database_name16 0
91342: # define sqlite3_column_table_name16 0
91343: # define sqlite3_column_origin_name16 0
91344: #endif
91345:
91346: #ifdef SQLITE_OMIT_COMPLETE
91347: # define sqlite3_complete 0
91348: # define sqlite3_complete16 0
91349: #endif
91350:
91351: #ifdef SQLITE_OMIT_DECLTYPE
91352: # define sqlite3_column_decltype16 0
91353: # define sqlite3_column_decltype 0
91354: #endif
91355:
91356: #ifdef SQLITE_OMIT_PROGRESS_CALLBACK
91357: # define sqlite3_progress_handler 0
91358: #endif
91359:
91360: #ifdef SQLITE_OMIT_VIRTUALTABLE
91361: # define sqlite3_create_module 0
91362: # define sqlite3_create_module_v2 0
91363: # define sqlite3_declare_vtab 0
91364: # define sqlite3_vtab_config 0
91365: # define sqlite3_vtab_on_conflict 0
91366: #endif
91367:
91368: #ifdef SQLITE_OMIT_SHARED_CACHE
91369: # define sqlite3_enable_shared_cache 0
91370: #endif
91371:
91372: #ifdef SQLITE_OMIT_TRACE
91373: # define sqlite3_profile 0
91374: # define sqlite3_trace 0
91375: #endif
91376:
91377: #ifdef SQLITE_OMIT_GET_TABLE
91378: # define sqlite3_free_table 0
91379: # define sqlite3_get_table 0
91380: #endif
91381:
91382: #ifdef SQLITE_OMIT_INCRBLOB
91383: #define sqlite3_bind_zeroblob 0
91384: #define sqlite3_blob_bytes 0
91385: #define sqlite3_blob_close 0
91386: #define sqlite3_blob_open 0
91387: #define sqlite3_blob_read 0
91388: #define sqlite3_blob_write 0
91389: #define sqlite3_blob_reopen 0
91390: #endif
91391:
91392: /*
91393: ** The following structure contains pointers to all SQLite API routines.
91394: ** A pointer to this structure is passed into extensions when they are
91395: ** loaded so that the extension can make calls back into the SQLite
91396: ** library.
91397: **
91398: ** When adding new APIs, add them to the bottom of this structure
91399: ** in order to preserve backwards compatibility.
91400: **
91401: ** Extensions that use newer APIs should first call the
91402: ** sqlite3_libversion_number() to make sure that the API they
91403: ** intend to use is supported by the library. Extensions should
91404: ** also check to make sure that the pointer to the function is
91405: ** not NULL before calling it.
91406: */
91407: static const sqlite3_api_routines sqlite3Apis = {
91408: sqlite3_aggregate_context,
91409: #ifndef SQLITE_OMIT_DEPRECATED
91410: sqlite3_aggregate_count,
91411: #else
91412: 0,
91413: #endif
91414: sqlite3_bind_blob,
91415: sqlite3_bind_double,
91416: sqlite3_bind_int,
91417: sqlite3_bind_int64,
91418: sqlite3_bind_null,
91419: sqlite3_bind_parameter_count,
91420: sqlite3_bind_parameter_index,
91421: sqlite3_bind_parameter_name,
91422: sqlite3_bind_text,
91423: sqlite3_bind_text16,
91424: sqlite3_bind_value,
91425: sqlite3_busy_handler,
91426: sqlite3_busy_timeout,
91427: sqlite3_changes,
91428: sqlite3_close,
91429: sqlite3_collation_needed,
91430: sqlite3_collation_needed16,
91431: sqlite3_column_blob,
91432: sqlite3_column_bytes,
91433: sqlite3_column_bytes16,
91434: sqlite3_column_count,
91435: sqlite3_column_database_name,
91436: sqlite3_column_database_name16,
91437: sqlite3_column_decltype,
91438: sqlite3_column_decltype16,
91439: sqlite3_column_double,
91440: sqlite3_column_int,
91441: sqlite3_column_int64,
91442: sqlite3_column_name,
91443: sqlite3_column_name16,
91444: sqlite3_column_origin_name,
91445: sqlite3_column_origin_name16,
91446: sqlite3_column_table_name,
91447: sqlite3_column_table_name16,
91448: sqlite3_column_text,
91449: sqlite3_column_text16,
91450: sqlite3_column_type,
91451: sqlite3_column_value,
91452: sqlite3_commit_hook,
91453: sqlite3_complete,
91454: sqlite3_complete16,
91455: sqlite3_create_collation,
91456: sqlite3_create_collation16,
91457: sqlite3_create_function,
91458: sqlite3_create_function16,
91459: sqlite3_create_module,
91460: sqlite3_data_count,
91461: sqlite3_db_handle,
91462: sqlite3_declare_vtab,
91463: sqlite3_enable_shared_cache,
91464: sqlite3_errcode,
91465: sqlite3_errmsg,
91466: sqlite3_errmsg16,
91467: sqlite3_exec,
91468: #ifndef SQLITE_OMIT_DEPRECATED
91469: sqlite3_expired,
91470: #else
91471: 0,
91472: #endif
91473: sqlite3_finalize,
91474: sqlite3_free,
91475: sqlite3_free_table,
91476: sqlite3_get_autocommit,
91477: sqlite3_get_auxdata,
91478: sqlite3_get_table,
91479: 0, /* Was sqlite3_global_recover(), but that function is deprecated */
91480: sqlite3_interrupt,
91481: sqlite3_last_insert_rowid,
91482: sqlite3_libversion,
91483: sqlite3_libversion_number,
91484: sqlite3_malloc,
91485: sqlite3_mprintf,
91486: sqlite3_open,
91487: sqlite3_open16,
91488: sqlite3_prepare,
91489: sqlite3_prepare16,
91490: sqlite3_profile,
91491: sqlite3_progress_handler,
91492: sqlite3_realloc,
91493: sqlite3_reset,
91494: sqlite3_result_blob,
91495: sqlite3_result_double,
91496: sqlite3_result_error,
91497: sqlite3_result_error16,
91498: sqlite3_result_int,
91499: sqlite3_result_int64,
91500: sqlite3_result_null,
91501: sqlite3_result_text,
91502: sqlite3_result_text16,
91503: sqlite3_result_text16be,
91504: sqlite3_result_text16le,
91505: sqlite3_result_value,
91506: sqlite3_rollback_hook,
91507: sqlite3_set_authorizer,
91508: sqlite3_set_auxdata,
91509: sqlite3_snprintf,
91510: sqlite3_step,
91511: sqlite3_table_column_metadata,
91512: #ifndef SQLITE_OMIT_DEPRECATED
91513: sqlite3_thread_cleanup,
91514: #else
91515: 0,
91516: #endif
91517: sqlite3_total_changes,
91518: sqlite3_trace,
91519: #ifndef SQLITE_OMIT_DEPRECATED
91520: sqlite3_transfer_bindings,
91521: #else
91522: 0,
91523: #endif
91524: sqlite3_update_hook,
91525: sqlite3_user_data,
91526: sqlite3_value_blob,
91527: sqlite3_value_bytes,
91528: sqlite3_value_bytes16,
91529: sqlite3_value_double,
91530: sqlite3_value_int,
91531: sqlite3_value_int64,
91532: sqlite3_value_numeric_type,
91533: sqlite3_value_text,
91534: sqlite3_value_text16,
91535: sqlite3_value_text16be,
91536: sqlite3_value_text16le,
91537: sqlite3_value_type,
91538: sqlite3_vmprintf,
91539: /*
91540: ** The original API set ends here. All extensions can call any
91541: ** of the APIs above provided that the pointer is not NULL. But
91542: ** before calling APIs that follow, extension should check the
91543: ** sqlite3_libversion_number() to make sure they are dealing with
91544: ** a library that is new enough to support that API.
91545: *************************************************************************
91546: */
91547: sqlite3_overload_function,
91548:
91549: /*
91550: ** Added after 3.3.13
91551: */
91552: sqlite3_prepare_v2,
91553: sqlite3_prepare16_v2,
91554: sqlite3_clear_bindings,
91555:
91556: /*
91557: ** Added for 3.4.1
91558: */
91559: sqlite3_create_module_v2,
91560:
91561: /*
91562: ** Added for 3.5.0
91563: */
91564: sqlite3_bind_zeroblob,
91565: sqlite3_blob_bytes,
91566: sqlite3_blob_close,
91567: sqlite3_blob_open,
91568: sqlite3_blob_read,
91569: sqlite3_blob_write,
91570: sqlite3_create_collation_v2,
91571: sqlite3_file_control,
91572: sqlite3_memory_highwater,
91573: sqlite3_memory_used,
91574: #ifdef SQLITE_MUTEX_OMIT
91575: 0,
91576: 0,
91577: 0,
91578: 0,
91579: 0,
91580: #else
91581: sqlite3_mutex_alloc,
91582: sqlite3_mutex_enter,
91583: sqlite3_mutex_free,
91584: sqlite3_mutex_leave,
91585: sqlite3_mutex_try,
91586: #endif
91587: sqlite3_open_v2,
91588: sqlite3_release_memory,
91589: sqlite3_result_error_nomem,
91590: sqlite3_result_error_toobig,
91591: sqlite3_sleep,
91592: sqlite3_soft_heap_limit,
91593: sqlite3_vfs_find,
91594: sqlite3_vfs_register,
91595: sqlite3_vfs_unregister,
91596:
91597: /*
91598: ** Added for 3.5.8
91599: */
91600: sqlite3_threadsafe,
91601: sqlite3_result_zeroblob,
91602: sqlite3_result_error_code,
91603: sqlite3_test_control,
91604: sqlite3_randomness,
91605: sqlite3_context_db_handle,
91606:
91607: /*
91608: ** Added for 3.6.0
91609: */
91610: sqlite3_extended_result_codes,
91611: sqlite3_limit,
91612: sqlite3_next_stmt,
91613: sqlite3_sql,
91614: sqlite3_status,
91615:
91616: /*
91617: ** Added for 3.7.4
91618: */
91619: sqlite3_backup_finish,
91620: sqlite3_backup_init,
91621: sqlite3_backup_pagecount,
91622: sqlite3_backup_remaining,
91623: sqlite3_backup_step,
91624: #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
91625: sqlite3_compileoption_get,
91626: sqlite3_compileoption_used,
91627: #else
91628: 0,
91629: 0,
91630: #endif
91631: sqlite3_create_function_v2,
91632: sqlite3_db_config,
91633: sqlite3_db_mutex,
91634: sqlite3_db_status,
91635: sqlite3_extended_errcode,
91636: sqlite3_log,
91637: sqlite3_soft_heap_limit64,
91638: sqlite3_sourceid,
91639: sqlite3_stmt_status,
91640: sqlite3_strnicmp,
91641: #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
91642: sqlite3_unlock_notify,
91643: #else
91644: 0,
91645: #endif
91646: #ifndef SQLITE_OMIT_WAL
91647: sqlite3_wal_autocheckpoint,
91648: sqlite3_wal_checkpoint,
91649: sqlite3_wal_hook,
91650: #else
91651: 0,
91652: 0,
91653: 0,
91654: #endif
91655: sqlite3_blob_reopen,
91656: sqlite3_vtab_config,
91657: sqlite3_vtab_on_conflict,
91658: };
91659:
91660: /*
91661: ** Attempt to load an SQLite extension library contained in the file
91662: ** zFile. The entry point is zProc. zProc may be 0 in which case a
91663: ** default entry point name (sqlite3_extension_init) is used. Use
91664: ** of the default name is recommended.
91665: **
91666: ** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong.
91667: **
91668: ** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with
91669: ** error message text. The calling function should free this memory
91670: ** by calling sqlite3DbFree(db, ).
91671: */
91672: static int sqlite3LoadExtension(
91673: sqlite3 *db, /* Load the extension into this database connection */
91674: const char *zFile, /* Name of the shared library containing extension */
91675: const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */
91676: char **pzErrMsg /* Put error message here if not 0 */
91677: ){
91678: sqlite3_vfs *pVfs = db->pVfs;
91679: void *handle;
91680: int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
91681: char *zErrmsg = 0;
91682: void **aHandle;
91683: int nMsg = 300 + sqlite3Strlen30(zFile);
91684:
91685: if( pzErrMsg ) *pzErrMsg = 0;
91686:
91687: /* Ticket #1863. To avoid a creating security problems for older
91688: ** applications that relink against newer versions of SQLite, the
91689: ** ability to run load_extension is turned off by default. One
91690: ** must call sqlite3_enable_load_extension() to turn on extension
91691: ** loading. Otherwise you get the following error.
91692: */
91693: if( (db->flags & SQLITE_LoadExtension)==0 ){
91694: if( pzErrMsg ){
91695: *pzErrMsg = sqlite3_mprintf("not authorized");
91696: }
91697: return SQLITE_ERROR;
91698: }
91699:
91700: if( zProc==0 ){
91701: zProc = "sqlite3_extension_init";
91702: }
91703:
91704: handle = sqlite3OsDlOpen(pVfs, zFile);
91705: if( handle==0 ){
91706: if( pzErrMsg ){
91707: *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
91708: if( zErrmsg ){
91709: sqlite3_snprintf(nMsg, zErrmsg,
91710: "unable to open shared library [%s]", zFile);
91711: sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
91712: }
91713: }
91714: return SQLITE_ERROR;
91715: }
91716: xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
91717: sqlite3OsDlSym(pVfs, handle, zProc);
91718: if( xInit==0 ){
91719: if( pzErrMsg ){
91720: nMsg += sqlite3Strlen30(zProc);
91721: *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
91722: if( zErrmsg ){
91723: sqlite3_snprintf(nMsg, zErrmsg,
91724: "no entry point [%s] in shared library [%s]", zProc,zFile);
91725: sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
91726: }
91727: sqlite3OsDlClose(pVfs, handle);
91728: }
91729: return SQLITE_ERROR;
91730: }else if( xInit(db, &zErrmsg, &sqlite3Apis) ){
91731: if( pzErrMsg ){
91732: *pzErrMsg = sqlite3_mprintf("error during initialization: %s", zErrmsg);
91733: }
91734: sqlite3_free(zErrmsg);
91735: sqlite3OsDlClose(pVfs, handle);
91736: return SQLITE_ERROR;
91737: }
91738:
91739: /* Append the new shared library handle to the db->aExtension array. */
91740: aHandle = sqlite3DbMallocZero(db, sizeof(handle)*(db->nExtension+1));
91741: if( aHandle==0 ){
91742: return SQLITE_NOMEM;
91743: }
91744: if( db->nExtension>0 ){
91745: memcpy(aHandle, db->aExtension, sizeof(handle)*db->nExtension);
91746: }
91747: sqlite3DbFree(db, db->aExtension);
91748: db->aExtension = aHandle;
91749:
91750: db->aExtension[db->nExtension++] = handle;
91751: return SQLITE_OK;
91752: }
91753: SQLITE_API int sqlite3_load_extension(
91754: sqlite3 *db, /* Load the extension into this database connection */
91755: const char *zFile, /* Name of the shared library containing extension */
91756: const char *zProc, /* Entry point. Use "sqlite3_extension_init" if 0 */
91757: char **pzErrMsg /* Put error message here if not 0 */
91758: ){
91759: int rc;
91760: sqlite3_mutex_enter(db->mutex);
91761: rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg);
91762: rc = sqlite3ApiExit(db, rc);
91763: sqlite3_mutex_leave(db->mutex);
91764: return rc;
91765: }
91766:
91767: /*
91768: ** Call this routine when the database connection is closing in order
91769: ** to clean up loaded extensions
91770: */
91771: SQLITE_PRIVATE void sqlite3CloseExtensions(sqlite3 *db){
91772: int i;
91773: assert( sqlite3_mutex_held(db->mutex) );
91774: for(i=0; i<db->nExtension; i++){
91775: sqlite3OsDlClose(db->pVfs, db->aExtension[i]);
91776: }
91777: sqlite3DbFree(db, db->aExtension);
91778: }
91779:
91780: /*
91781: ** Enable or disable extension loading. Extension loading is disabled by
91782: ** default so as not to open security holes in older applications.
91783: */
91784: SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff){
91785: sqlite3_mutex_enter(db->mutex);
91786: if( onoff ){
91787: db->flags |= SQLITE_LoadExtension;
91788: }else{
91789: db->flags &= ~SQLITE_LoadExtension;
91790: }
91791: sqlite3_mutex_leave(db->mutex);
91792: return SQLITE_OK;
91793: }
91794:
91795: #endif /* SQLITE_OMIT_LOAD_EXTENSION */
91796:
91797: /*
91798: ** The auto-extension code added regardless of whether or not extension
91799: ** loading is supported. We need a dummy sqlite3Apis pointer for that
91800: ** code if regular extension loading is not available. This is that
91801: ** dummy pointer.
91802: */
91803: #ifdef SQLITE_OMIT_LOAD_EXTENSION
91804: static const sqlite3_api_routines sqlite3Apis = { 0 };
91805: #endif
91806:
91807:
91808: /*
91809: ** The following object holds the list of automatically loaded
91810: ** extensions.
91811: **
91812: ** This list is shared across threads. The SQLITE_MUTEX_STATIC_MASTER
91813: ** mutex must be held while accessing this list.
91814: */
91815: typedef struct sqlite3AutoExtList sqlite3AutoExtList;
91816: static SQLITE_WSD struct sqlite3AutoExtList {
91817: int nExt; /* Number of entries in aExt[] */
91818: void (**aExt)(void); /* Pointers to the extension init functions */
91819: } sqlite3Autoext = { 0, 0 };
91820:
91821: /* The "wsdAutoext" macro will resolve to the autoextension
91822: ** state vector. If writable static data is unsupported on the target,
91823: ** we have to locate the state vector at run-time. In the more common
91824: ** case where writable static data is supported, wsdStat can refer directly
91825: ** to the "sqlite3Autoext" state vector declared above.
91826: */
91827: #ifdef SQLITE_OMIT_WSD
91828: # define wsdAutoextInit \
91829: sqlite3AutoExtList *x = &GLOBAL(sqlite3AutoExtList,sqlite3Autoext)
91830: # define wsdAutoext x[0]
91831: #else
91832: # define wsdAutoextInit
91833: # define wsdAutoext sqlite3Autoext
91834: #endif
91835:
91836:
91837: /*
91838: ** Register a statically linked extension that is automatically
91839: ** loaded by every new database connection.
91840: */
91841: SQLITE_API int sqlite3_auto_extension(void (*xInit)(void)){
91842: int rc = SQLITE_OK;
91843: #ifndef SQLITE_OMIT_AUTOINIT
91844: rc = sqlite3_initialize();
91845: if( rc ){
91846: return rc;
91847: }else
91848: #endif
91849: {
91850: int i;
91851: #if SQLITE_THREADSAFE
91852: sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
91853: #endif
91854: wsdAutoextInit;
91855: sqlite3_mutex_enter(mutex);
91856: for(i=0; i<wsdAutoext.nExt; i++){
91857: if( wsdAutoext.aExt[i]==xInit ) break;
91858: }
91859: if( i==wsdAutoext.nExt ){
91860: int nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
91861: void (**aNew)(void);
91862: aNew = sqlite3_realloc(wsdAutoext.aExt, nByte);
91863: if( aNew==0 ){
91864: rc = SQLITE_NOMEM;
91865: }else{
91866: wsdAutoext.aExt = aNew;
91867: wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
91868: wsdAutoext.nExt++;
91869: }
91870: }
91871: sqlite3_mutex_leave(mutex);
91872: assert( (rc&0xff)==rc );
91873: return rc;
91874: }
91875: }
91876:
91877: /*
91878: ** Reset the automatic extension loading mechanism.
91879: */
91880: SQLITE_API void sqlite3_reset_auto_extension(void){
91881: #ifndef SQLITE_OMIT_AUTOINIT
91882: if( sqlite3_initialize()==SQLITE_OK )
91883: #endif
91884: {
91885: #if SQLITE_THREADSAFE
91886: sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
91887: #endif
91888: wsdAutoextInit;
91889: sqlite3_mutex_enter(mutex);
91890: sqlite3_free(wsdAutoext.aExt);
91891: wsdAutoext.aExt = 0;
91892: wsdAutoext.nExt = 0;
91893: sqlite3_mutex_leave(mutex);
91894: }
91895: }
91896:
91897: /*
91898: ** Load all automatic extensions.
91899: **
91900: ** If anything goes wrong, set an error in the database connection.
91901: */
91902: SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){
91903: int i;
91904: int go = 1;
91905: int rc;
91906: int (*xInit)(sqlite3*,char**,const sqlite3_api_routines*);
91907:
91908: wsdAutoextInit;
91909: if( wsdAutoext.nExt==0 ){
91910: /* Common case: early out without every having to acquire a mutex */
91911: return;
91912: }
91913: for(i=0; go; i++){
91914: char *zErrmsg;
91915: #if SQLITE_THREADSAFE
91916: sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
91917: #endif
91918: sqlite3_mutex_enter(mutex);
91919: if( i>=wsdAutoext.nExt ){
91920: xInit = 0;
91921: go = 0;
91922: }else{
91923: xInit = (int(*)(sqlite3*,char**,const sqlite3_api_routines*))
91924: wsdAutoext.aExt[i];
91925: }
91926: sqlite3_mutex_leave(mutex);
91927: zErrmsg = 0;
91928: if( xInit && (rc = xInit(db, &zErrmsg, &sqlite3Apis))!=0 ){
91929: sqlite3Error(db, rc,
91930: "automatic extension loading failed: %s", zErrmsg);
91931: go = 0;
91932: }
91933: sqlite3_free(zErrmsg);
91934: }
91935: }
91936:
91937: /************** End of loadext.c *********************************************/
91938: /************** Begin file pragma.c ******************************************/
91939: /*
91940: ** 2003 April 6
91941: **
91942: ** The author disclaims copyright to this source code. In place of
91943: ** a legal notice, here is a blessing:
91944: **
91945: ** May you do good and not evil.
91946: ** May you find forgiveness for yourself and forgive others.
91947: ** May you share freely, never taking more than you give.
91948: **
91949: *************************************************************************
91950: ** This file contains code used to implement the PRAGMA command.
91951: */
91952:
91953: /*
91954: ** Interpret the given string as a safety level. Return 0 for OFF,
91955: ** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or
91956: ** unrecognized string argument.
91957: **
91958: ** Note that the values returned are one less that the values that
91959: ** should be passed into sqlite3BtreeSetSafetyLevel(). The is done
91960: ** to support legacy SQL code. The safety level used to be boolean
91961: ** and older scripts may have used numbers 0 for OFF and 1 for ON.
91962: */
91963: static u8 getSafetyLevel(const char *z){
91964: /* 123456789 123456789 */
91965: static const char zText[] = "onoffalseyestruefull";
91966: static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
91967: static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
91968: static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2};
91969: int i, n;
91970: if( sqlite3Isdigit(*z) ){
91971: return (u8)sqlite3Atoi(z);
91972: }
91973: n = sqlite3Strlen30(z);
91974: for(i=0; i<ArraySize(iLength); i++){
91975: if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
91976: return iValue[i];
91977: }
91978: }
91979: return 1;
91980: }
91981:
91982: /*
91983: ** Interpret the given string as a boolean value.
91984: */
91985: SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z){
91986: return getSafetyLevel(z)&1;
91987: }
91988:
91989: /* The sqlite3GetBoolean() function is used by other modules but the
91990: ** remainder of this file is specific to PRAGMA processing. So omit
91991: ** the rest of the file if PRAGMAs are omitted from the build.
91992: */
91993: #if !defined(SQLITE_OMIT_PRAGMA)
91994:
91995: /*
91996: ** Interpret the given string as a locking mode value.
91997: */
91998: static int getLockingMode(const char *z){
91999: if( z ){
92000: if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
92001: if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
92002: }
92003: return PAGER_LOCKINGMODE_QUERY;
92004: }
92005:
92006: #ifndef SQLITE_OMIT_AUTOVACUUM
92007: /*
92008: ** Interpret the given string as an auto-vacuum mode value.
92009: **
92010: ** The following strings, "none", "full" and "incremental" are
92011: ** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
92012: */
92013: static int getAutoVacuum(const char *z){
92014: int i;
92015: if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
92016: if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
92017: if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
92018: i = sqlite3Atoi(z);
92019: return (u8)((i>=0&&i<=2)?i:0);
92020: }
92021: #endif /* ifndef SQLITE_OMIT_AUTOVACUUM */
92022:
92023: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
92024: /*
92025: ** Interpret the given string as a temp db location. Return 1 for file
92026: ** backed temporary databases, 2 for the Red-Black tree in memory database
92027: ** and 0 to use the compile-time default.
92028: */
92029: static int getTempStore(const char *z){
92030: if( z[0]>='0' && z[0]<='2' ){
92031: return z[0] - '0';
92032: }else if( sqlite3StrICmp(z, "file")==0 ){
92033: return 1;
92034: }else if( sqlite3StrICmp(z, "memory")==0 ){
92035: return 2;
92036: }else{
92037: return 0;
92038: }
92039: }
92040: #endif /* SQLITE_PAGER_PRAGMAS */
92041:
92042: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
92043: /*
92044: ** Invalidate temp storage, either when the temp storage is changed
92045: ** from default, or when 'file' and the temp_store_directory has changed
92046: */
92047: static int invalidateTempStorage(Parse *pParse){
92048: sqlite3 *db = pParse->db;
92049: if( db->aDb[1].pBt!=0 ){
92050: if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
92051: sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
92052: "from within a transaction");
92053: return SQLITE_ERROR;
92054: }
92055: sqlite3BtreeClose(db->aDb[1].pBt);
92056: db->aDb[1].pBt = 0;
92057: sqlite3ResetInternalSchema(db, -1);
92058: }
92059: return SQLITE_OK;
92060: }
92061: #endif /* SQLITE_PAGER_PRAGMAS */
92062:
92063: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
92064: /*
92065: ** If the TEMP database is open, close it and mark the database schema
92066: ** as needing reloading. This must be done when using the SQLITE_TEMP_STORE
92067: ** or DEFAULT_TEMP_STORE pragmas.
92068: */
92069: static int changeTempStorage(Parse *pParse, const char *zStorageType){
92070: int ts = getTempStore(zStorageType);
92071: sqlite3 *db = pParse->db;
92072: if( db->temp_store==ts ) return SQLITE_OK;
92073: if( invalidateTempStorage( pParse ) != SQLITE_OK ){
92074: return SQLITE_ERROR;
92075: }
92076: db->temp_store = (u8)ts;
92077: return SQLITE_OK;
92078: }
92079: #endif /* SQLITE_PAGER_PRAGMAS */
92080:
92081: /*
92082: ** Generate code to return a single integer value.
92083: */
92084: static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
92085: Vdbe *v = sqlite3GetVdbe(pParse);
92086: int mem = ++pParse->nMem;
92087: i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));
92088: if( pI64 ){
92089: memcpy(pI64, &value, sizeof(value));
92090: }
92091: sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);
92092: sqlite3VdbeSetNumCols(v, 1);
92093: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, SQLITE_STATIC);
92094: sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
92095: }
92096:
92097: #ifndef SQLITE_OMIT_FLAG_PRAGMAS
92098: /*
92099: ** Check to see if zRight and zLeft refer to a pragma that queries
92100: ** or changes one of the flags in db->flags. Return 1 if so and 0 if not.
92101: ** Also, implement the pragma.
92102: */
92103: static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
92104: static const struct sPragmaType {
92105: const char *zName; /* Name of the pragma */
92106: int mask; /* Mask for the db->flags value */
92107: } aPragma[] = {
92108: { "full_column_names", SQLITE_FullColNames },
92109: { "short_column_names", SQLITE_ShortColNames },
92110: { "count_changes", SQLITE_CountRows },
92111: { "empty_result_callbacks", SQLITE_NullCallback },
92112: { "legacy_file_format", SQLITE_LegacyFileFmt },
92113: { "fullfsync", SQLITE_FullFSync },
92114: { "checkpoint_fullfsync", SQLITE_CkptFullFSync },
92115: { "reverse_unordered_selects", SQLITE_ReverseOrder },
92116: #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
92117: { "automatic_index", SQLITE_AutoIndex },
92118: #endif
92119: #ifdef SQLITE_DEBUG
92120: { "sql_trace", SQLITE_SqlTrace },
92121: { "vdbe_listing", SQLITE_VdbeListing },
92122: { "vdbe_trace", SQLITE_VdbeTrace },
92123: #endif
92124: #ifndef SQLITE_OMIT_CHECK
92125: { "ignore_check_constraints", SQLITE_IgnoreChecks },
92126: #endif
92127: /* The following is VERY experimental */
92128: { "writable_schema", SQLITE_WriteSchema|SQLITE_RecoveryMode },
92129: { "omit_readlock", SQLITE_NoReadlock },
92130:
92131: /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted
92132: ** flag if there are any active statements. */
92133: { "read_uncommitted", SQLITE_ReadUncommitted },
92134: { "recursive_triggers", SQLITE_RecTriggers },
92135:
92136: /* This flag may only be set if both foreign-key and trigger support
92137: ** are present in the build. */
92138: #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
92139: { "foreign_keys", SQLITE_ForeignKeys },
92140: #endif
92141: };
92142: int i;
92143: const struct sPragmaType *p;
92144: for(i=0, p=aPragma; i<ArraySize(aPragma); i++, p++){
92145: if( sqlite3StrICmp(zLeft, p->zName)==0 ){
92146: sqlite3 *db = pParse->db;
92147: Vdbe *v;
92148: v = sqlite3GetVdbe(pParse);
92149: assert( v!=0 ); /* Already allocated by sqlite3Pragma() */
92150: if( ALWAYS(v) ){
92151: if( zRight==0 ){
92152: returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
92153: }else{
92154: int mask = p->mask; /* Mask of bits to set or clear. */
92155: if( db->autoCommit==0 ){
92156: /* Foreign key support may not be enabled or disabled while not
92157: ** in auto-commit mode. */
92158: mask &= ~(SQLITE_ForeignKeys);
92159: }
92160:
92161: if( sqlite3GetBoolean(zRight) ){
92162: db->flags |= mask;
92163: }else{
92164: db->flags &= ~mask;
92165: }
92166:
92167: /* Many of the flag-pragmas modify the code generated by the SQL
92168: ** compiler (eg. count_changes). So add an opcode to expire all
92169: ** compiled SQL statements after modifying a pragma value.
92170: */
92171: sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
92172: }
92173: }
92174:
92175: return 1;
92176: }
92177: }
92178: return 0;
92179: }
92180: #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
92181:
92182: /*
92183: ** Return a human-readable name for a constraint resolution action.
92184: */
92185: #ifndef SQLITE_OMIT_FOREIGN_KEY
92186: static const char *actionName(u8 action){
92187: const char *zName;
92188: switch( action ){
92189: case OE_SetNull: zName = "SET NULL"; break;
92190: case OE_SetDflt: zName = "SET DEFAULT"; break;
92191: case OE_Cascade: zName = "CASCADE"; break;
92192: case OE_Restrict: zName = "RESTRICT"; break;
92193: default: zName = "NO ACTION";
92194: assert( action==OE_None ); break;
92195: }
92196: return zName;
92197: }
92198: #endif
92199:
92200:
92201: /*
92202: ** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants
92203: ** defined in pager.h. This function returns the associated lowercase
92204: ** journal-mode name.
92205: */
92206: SQLITE_PRIVATE const char *sqlite3JournalModename(int eMode){
92207: static char * const azModeName[] = {
92208: "delete", "persist", "off", "truncate", "memory"
92209: #ifndef SQLITE_OMIT_WAL
92210: , "wal"
92211: #endif
92212: };
92213: assert( PAGER_JOURNALMODE_DELETE==0 );
92214: assert( PAGER_JOURNALMODE_PERSIST==1 );
92215: assert( PAGER_JOURNALMODE_OFF==2 );
92216: assert( PAGER_JOURNALMODE_TRUNCATE==3 );
92217: assert( PAGER_JOURNALMODE_MEMORY==4 );
92218: assert( PAGER_JOURNALMODE_WAL==5 );
92219: assert( eMode>=0 && eMode<=ArraySize(azModeName) );
92220:
92221: if( eMode==ArraySize(azModeName) ) return 0;
92222: return azModeName[eMode];
92223: }
92224:
92225: /*
92226: ** Process a pragma statement.
92227: **
92228: ** Pragmas are of this form:
92229: **
92230: ** PRAGMA [database.]id [= value]
92231: **
92232: ** The identifier might also be a string. The value is a string, and
92233: ** identifier, or a number. If minusFlag is true, then the value is
92234: ** a number that was preceded by a minus sign.
92235: **
92236: ** If the left side is "database.id" then pId1 is the database name
92237: ** and pId2 is the id. If the left side is just "id" then pId1 is the
92238: ** id and pId2 is any empty string.
92239: */
92240: SQLITE_PRIVATE void sqlite3Pragma(
92241: Parse *pParse,
92242: Token *pId1, /* First part of [database.]id field */
92243: Token *pId2, /* Second part of [database.]id field, or NULL */
92244: Token *pValue, /* Token for <value>, or NULL */
92245: int minusFlag /* True if a '-' sign preceded <value> */
92246: ){
92247: char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */
92248: char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */
92249: const char *zDb = 0; /* The database name */
92250: Token *pId; /* Pointer to <id> token */
92251: int iDb; /* Database index for <database> */
92252: sqlite3 *db = pParse->db;
92253: Db *pDb;
92254: Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db);
92255: if( v==0 ) return;
92256: sqlite3VdbeRunOnlyOnce(v);
92257: pParse->nMem = 2;
92258:
92259: /* Interpret the [database.] part of the pragma statement. iDb is the
92260: ** index of the database this pragma is being applied to in db.aDb[]. */
92261: iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
92262: if( iDb<0 ) return;
92263: pDb = &db->aDb[iDb];
92264:
92265: /* If the temp database has been explicitly named as part of the
92266: ** pragma, make sure it is open.
92267: */
92268: if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
92269: return;
92270: }
92271:
92272: zLeft = sqlite3NameFromToken(db, pId);
92273: if( !zLeft ) return;
92274: if( minusFlag ){
92275: zRight = sqlite3MPrintf(db, "-%T", pValue);
92276: }else{
92277: zRight = sqlite3NameFromToken(db, pValue);
92278: }
92279:
92280: assert( pId2 );
92281: zDb = pId2->n>0 ? pDb->zName : 0;
92282: if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
92283: goto pragma_out;
92284: }
92285:
92286: #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && !defined(SQLITE_OMIT_DEPRECATED)
92287: /*
92288: ** PRAGMA [database.]default_cache_size
92289: ** PRAGMA [database.]default_cache_size=N
92290: **
92291: ** The first form reports the current persistent setting for the
92292: ** page cache size. The value returned is the maximum number of
92293: ** pages in the page cache. The second form sets both the current
92294: ** page cache size value and the persistent page cache size value
92295: ** stored in the database file.
92296: **
92297: ** Older versions of SQLite would set the default cache size to a
92298: ** negative number to indicate synchronous=OFF. These days, synchronous
92299: ** is always on by default regardless of the sign of the default cache
92300: ** size. But continue to take the absolute value of the default cache
92301: ** size of historical compatibility.
92302: */
92303: if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){
92304: static const VdbeOpList getCacheSize[] = {
92305: { OP_Transaction, 0, 0, 0}, /* 0 */
92306: { OP_ReadCookie, 0, 1, BTREE_DEFAULT_CACHE_SIZE}, /* 1 */
92307: { OP_IfPos, 1, 7, 0},
92308: { OP_Integer, 0, 2, 0},
92309: { OP_Subtract, 1, 2, 1},
92310: { OP_IfPos, 1, 7, 0},
92311: { OP_Integer, 0, 1, 0}, /* 6 */
92312: { OP_ResultRow, 1, 1, 0},
92313: };
92314: int addr;
92315: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
92316: sqlite3VdbeUsesBtree(v, iDb);
92317: if( !zRight ){
92318: sqlite3VdbeSetNumCols(v, 1);
92319: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", SQLITE_STATIC);
92320: pParse->nMem += 2;
92321: addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
92322: sqlite3VdbeChangeP1(v, addr, iDb);
92323: sqlite3VdbeChangeP1(v, addr+1, iDb);
92324: sqlite3VdbeChangeP1(v, addr+6, SQLITE_DEFAULT_CACHE_SIZE);
92325: }else{
92326: int size = sqlite3AbsInt32(sqlite3Atoi(zRight));
92327: sqlite3BeginWriteOperation(pParse, 0, iDb);
92328: sqlite3VdbeAddOp2(v, OP_Integer, size, 1);
92329: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1);
92330: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
92331: pDb->pSchema->cache_size = size;
92332: sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
92333: }
92334: }else
92335: #endif /* !SQLITE_OMIT_PAGER_PRAGMAS && !SQLITE_OMIT_DEPRECATED */
92336:
92337: #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
92338: /*
92339: ** PRAGMA [database.]page_size
92340: ** PRAGMA [database.]page_size=N
92341: **
92342: ** The first form reports the current setting for the
92343: ** database page size in bytes. The second form sets the
92344: ** database page size value. The value can only be set if
92345: ** the database has not yet been created.
92346: */
92347: if( sqlite3StrICmp(zLeft,"page_size")==0 ){
92348: Btree *pBt = pDb->pBt;
92349: assert( pBt!=0 );
92350: if( !zRight ){
92351: int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0;
92352: returnSingleInt(pParse, "page_size", size);
92353: }else{
92354: /* Malloc may fail when setting the page-size, as there is an internal
92355: ** buffer that the pager module resizes using sqlite3_realloc().
92356: */
92357: db->nextPagesize = sqlite3Atoi(zRight);
92358: if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){
92359: db->mallocFailed = 1;
92360: }
92361: }
92362: }else
92363:
92364: /*
92365: ** PRAGMA [database.]secure_delete
92366: ** PRAGMA [database.]secure_delete=ON/OFF
92367: **
92368: ** The first form reports the current setting for the
92369: ** secure_delete flag. The second form changes the secure_delete
92370: ** flag setting and reports thenew value.
92371: */
92372: if( sqlite3StrICmp(zLeft,"secure_delete")==0 ){
92373: Btree *pBt = pDb->pBt;
92374: int b = -1;
92375: assert( pBt!=0 );
92376: if( zRight ){
92377: b = sqlite3GetBoolean(zRight);
92378: }
92379: if( pId2->n==0 && b>=0 ){
92380: int ii;
92381: for(ii=0; ii<db->nDb; ii++){
92382: sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
92383: }
92384: }
92385: b = sqlite3BtreeSecureDelete(pBt, b);
92386: returnSingleInt(pParse, "secure_delete", b);
92387: }else
92388:
92389: /*
92390: ** PRAGMA [database.]max_page_count
92391: ** PRAGMA [database.]max_page_count=N
92392: **
92393: ** The first form reports the current setting for the
92394: ** maximum number of pages in the database file. The
92395: ** second form attempts to change this setting. Both
92396: ** forms return the current setting.
92397: **
92398: ** The absolute value of N is used. This is undocumented and might
92399: ** change. The only purpose is to provide an easy way to test
92400: ** the sqlite3AbsInt32() function.
92401: **
92402: ** PRAGMA [database.]page_count
92403: **
92404: ** Return the number of pages in the specified database.
92405: */
92406: if( sqlite3StrICmp(zLeft,"page_count")==0
92407: || sqlite3StrICmp(zLeft,"max_page_count")==0
92408: ){
92409: int iReg;
92410: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
92411: sqlite3CodeVerifySchema(pParse, iDb);
92412: iReg = ++pParse->nMem;
92413: if( sqlite3Tolower(zLeft[0])=='p' ){
92414: sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
92415: }else{
92416: sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg,
92417: sqlite3AbsInt32(sqlite3Atoi(zRight)));
92418: }
92419: sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);
92420: sqlite3VdbeSetNumCols(v, 1);
92421: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);
92422: }else
92423:
92424: /*
92425: ** PRAGMA [database.]locking_mode
92426: ** PRAGMA [database.]locking_mode = (normal|exclusive)
92427: */
92428: if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){
92429: const char *zRet = "normal";
92430: int eMode = getLockingMode(zRight);
92431:
92432: if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
92433: /* Simple "PRAGMA locking_mode;" statement. This is a query for
92434: ** the current default locking mode (which may be different to
92435: ** the locking-mode of the main database).
92436: */
92437: eMode = db->dfltLockMode;
92438: }else{
92439: Pager *pPager;
92440: if( pId2->n==0 ){
92441: /* This indicates that no database name was specified as part
92442: ** of the PRAGMA command. In this case the locking-mode must be
92443: ** set on all attached databases, as well as the main db file.
92444: **
92445: ** Also, the sqlite3.dfltLockMode variable is set so that
92446: ** any subsequently attached databases also use the specified
92447: ** locking mode.
92448: */
92449: int ii;
92450: assert(pDb==&db->aDb[0]);
92451: for(ii=2; ii<db->nDb; ii++){
92452: pPager = sqlite3BtreePager(db->aDb[ii].pBt);
92453: sqlite3PagerLockingMode(pPager, eMode);
92454: }
92455: db->dfltLockMode = (u8)eMode;
92456: }
92457: pPager = sqlite3BtreePager(pDb->pBt);
92458: eMode = sqlite3PagerLockingMode(pPager, eMode);
92459: }
92460:
92461: assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);
92462: if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){
92463: zRet = "exclusive";
92464: }
92465: sqlite3VdbeSetNumCols(v, 1);
92466: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", SQLITE_STATIC);
92467: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0);
92468: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
92469: }else
92470:
92471: /*
92472: ** PRAGMA [database.]journal_mode
92473: ** PRAGMA [database.]journal_mode =
92474: ** (delete|persist|off|truncate|memory|wal|off)
92475: */
92476: if( sqlite3StrICmp(zLeft,"journal_mode")==0 ){
92477: int eMode; /* One of the PAGER_JOURNALMODE_XXX symbols */
92478: int ii; /* Loop counter */
92479:
92480: /* Force the schema to be loaded on all databases. This causes all
92481: ** database files to be opened and the journal_modes set. This is
92482: ** necessary because subsequent processing must know if the databases
92483: ** are in WAL mode. */
92484: if( sqlite3ReadSchema(pParse) ){
92485: goto pragma_out;
92486: }
92487:
92488: sqlite3VdbeSetNumCols(v, 1);
92489: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "journal_mode", SQLITE_STATIC);
92490:
92491: if( zRight==0 ){
92492: /* If there is no "=MODE" part of the pragma, do a query for the
92493: ** current mode */
92494: eMode = PAGER_JOURNALMODE_QUERY;
92495: }else{
92496: const char *zMode;
92497: int n = sqlite3Strlen30(zRight);
92498: for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){
92499: if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break;
92500: }
92501: if( !zMode ){
92502: /* If the "=MODE" part does not match any known journal mode,
92503: ** then do a query */
92504: eMode = PAGER_JOURNALMODE_QUERY;
92505: }
92506: }
92507: if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){
92508: /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */
92509: iDb = 0;
92510: pId2->n = 1;
92511: }
92512: for(ii=db->nDb-1; ii>=0; ii--){
92513: if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
92514: sqlite3VdbeUsesBtree(v, ii);
92515: sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);
92516: }
92517: }
92518: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
92519: }else
92520:
92521: /*
92522: ** PRAGMA [database.]journal_size_limit
92523: ** PRAGMA [database.]journal_size_limit=N
92524: **
92525: ** Get or set the size limit on rollback journal files.
92526: */
92527: if( sqlite3StrICmp(zLeft,"journal_size_limit")==0 ){
92528: Pager *pPager = sqlite3BtreePager(pDb->pBt);
92529: i64 iLimit = -2;
92530: if( zRight ){
92531: sqlite3Atoi64(zRight, &iLimit, 1000000, SQLITE_UTF8);
92532: if( iLimit<-1 ) iLimit = -1;
92533: }
92534: iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
92535: returnSingleInt(pParse, "journal_size_limit", iLimit);
92536: }else
92537:
92538: #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
92539:
92540: /*
92541: ** PRAGMA [database.]auto_vacuum
92542: ** PRAGMA [database.]auto_vacuum=N
92543: **
92544: ** Get or set the value of the database 'auto-vacuum' parameter.
92545: ** The value is one of: 0 NONE 1 FULL 2 INCREMENTAL
92546: */
92547: #ifndef SQLITE_OMIT_AUTOVACUUM
92548: if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){
92549: Btree *pBt = pDb->pBt;
92550: assert( pBt!=0 );
92551: if( sqlite3ReadSchema(pParse) ){
92552: goto pragma_out;
92553: }
92554: if( !zRight ){
92555: int auto_vacuum;
92556: if( ALWAYS(pBt) ){
92557: auto_vacuum = sqlite3BtreeGetAutoVacuum(pBt);
92558: }else{
92559: auto_vacuum = SQLITE_DEFAULT_AUTOVACUUM;
92560: }
92561: returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
92562: }else{
92563: int eAuto = getAutoVacuum(zRight);
92564: assert( eAuto>=0 && eAuto<=2 );
92565: db->nextAutovac = (u8)eAuto;
92566: if( ALWAYS(eAuto>=0) ){
92567: /* Call SetAutoVacuum() to set initialize the internal auto and
92568: ** incr-vacuum flags. This is required in case this connection
92569: ** creates the database file. It is important that it is created
92570: ** as an auto-vacuum capable db.
92571: */
92572: int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
92573: if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
92574: /* When setting the auto_vacuum mode to either "full" or
92575: ** "incremental", write the value of meta[6] in the database
92576: ** file. Before writing to meta[6], check that meta[3] indicates
92577: ** that this really is an auto-vacuum capable database.
92578: */
92579: static const VdbeOpList setMeta6[] = {
92580: { OP_Transaction, 0, 1, 0}, /* 0 */
92581: { OP_ReadCookie, 0, 1, BTREE_LARGEST_ROOT_PAGE},
92582: { OP_If, 1, 0, 0}, /* 2 */
92583: { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */
92584: { OP_Integer, 0, 1, 0}, /* 4 */
92585: { OP_SetCookie, 0, BTREE_INCR_VACUUM, 1}, /* 5 */
92586: };
92587: int iAddr;
92588: iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);
92589: sqlite3VdbeChangeP1(v, iAddr, iDb);
92590: sqlite3VdbeChangeP1(v, iAddr+1, iDb);
92591: sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);
92592: sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);
92593: sqlite3VdbeChangeP1(v, iAddr+5, iDb);
92594: sqlite3VdbeUsesBtree(v, iDb);
92595: }
92596: }
92597: }
92598: }else
92599: #endif
92600:
92601: /*
92602: ** PRAGMA [database.]incremental_vacuum(N)
92603: **
92604: ** Do N steps of incremental vacuuming on a database.
92605: */
92606: #ifndef SQLITE_OMIT_AUTOVACUUM
92607: if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){
92608: int iLimit, addr;
92609: if( sqlite3ReadSchema(pParse) ){
92610: goto pragma_out;
92611: }
92612: if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
92613: iLimit = 0x7fffffff;
92614: }
92615: sqlite3BeginWriteOperation(pParse, 0, iDb);
92616: sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
92617: addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb);
92618: sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
92619: sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
92620: sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr);
92621: sqlite3VdbeJumpHere(v, addr);
92622: }else
92623: #endif
92624:
92625: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
92626: /*
92627: ** PRAGMA [database.]cache_size
92628: ** PRAGMA [database.]cache_size=N
92629: **
92630: ** The first form reports the current local setting for the
92631: ** page cache size. The second form sets the local
92632: ** page cache size value. If N is positive then that is the
92633: ** number of pages in the cache. If N is negative, then the
92634: ** number of pages is adjusted so that the cache uses -N kibibytes
92635: ** of memory.
92636: */
92637: if( sqlite3StrICmp(zLeft,"cache_size")==0 ){
92638: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
92639: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
92640: if( !zRight ){
92641: returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
92642: }else{
92643: int size = sqlite3Atoi(zRight);
92644: pDb->pSchema->cache_size = size;
92645: sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
92646: }
92647: }else
92648:
92649: /*
92650: ** PRAGMA temp_store
92651: ** PRAGMA temp_store = "default"|"memory"|"file"
92652: **
92653: ** Return or set the local value of the temp_store flag. Changing
92654: ** the local value does not make changes to the disk file and the default
92655: ** value will be restored the next time the database is opened.
92656: **
92657: ** Note that it is possible for the library compile-time options to
92658: ** override this setting
92659: */
92660: if( sqlite3StrICmp(zLeft, "temp_store")==0 ){
92661: if( !zRight ){
92662: returnSingleInt(pParse, "temp_store", db->temp_store);
92663: }else{
92664: changeTempStorage(pParse, zRight);
92665: }
92666: }else
92667:
92668: /*
92669: ** PRAGMA temp_store_directory
92670: ** PRAGMA temp_store_directory = ""|"directory_name"
92671: **
92672: ** Return or set the local value of the temp_store_directory flag. Changing
92673: ** the value sets a specific directory to be used for temporary files.
92674: ** Setting to a null string reverts to the default temporary directory search.
92675: ** If temporary directory is changed, then invalidateTempStorage.
92676: **
92677: */
92678: if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){
92679: if( !zRight ){
92680: if( sqlite3_temp_directory ){
92681: sqlite3VdbeSetNumCols(v, 1);
92682: sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
92683: "temp_store_directory", SQLITE_STATIC);
92684: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0);
92685: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
92686: }
92687: }else{
92688: #ifndef SQLITE_OMIT_WSD
92689: if( zRight[0] ){
92690: int rc;
92691: int res;
92692: rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
92693: if( rc!=SQLITE_OK || res==0 ){
92694: sqlite3ErrorMsg(pParse, "not a writable directory");
92695: goto pragma_out;
92696: }
92697: }
92698: if( SQLITE_TEMP_STORE==0
92699: || (SQLITE_TEMP_STORE==1 && db->temp_store<=1)
92700: || (SQLITE_TEMP_STORE==2 && db->temp_store==1)
92701: ){
92702: invalidateTempStorage(pParse);
92703: }
92704: sqlite3_free(sqlite3_temp_directory);
92705: if( zRight[0] ){
92706: sqlite3_temp_directory = sqlite3_mprintf("%s", zRight);
92707: }else{
92708: sqlite3_temp_directory = 0;
92709: }
92710: #endif /* SQLITE_OMIT_WSD */
92711: }
92712: }else
92713:
92714: #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
92715: # if defined(__APPLE__)
92716: # define SQLITE_ENABLE_LOCKING_STYLE 1
92717: # else
92718: # define SQLITE_ENABLE_LOCKING_STYLE 0
92719: # endif
92720: #endif
92721: #if SQLITE_ENABLE_LOCKING_STYLE
92722: /*
92723: ** PRAGMA [database.]lock_proxy_file
92724: ** PRAGMA [database.]lock_proxy_file = ":auto:"|"lock_file_path"
92725: **
92726: ** Return or set the value of the lock_proxy_file flag. Changing
92727: ** the value sets a specific file to be used for database access locks.
92728: **
92729: */
92730: if( sqlite3StrICmp(zLeft, "lock_proxy_file")==0 ){
92731: if( !zRight ){
92732: Pager *pPager = sqlite3BtreePager(pDb->pBt);
92733: char *proxy_file_path = NULL;
92734: sqlite3_file *pFile = sqlite3PagerFile(pPager);
92735: sqlite3OsFileControlHint(pFile, SQLITE_GET_LOCKPROXYFILE,
92736: &proxy_file_path);
92737:
92738: if( proxy_file_path ){
92739: sqlite3VdbeSetNumCols(v, 1);
92740: sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
92741: "lock_proxy_file", SQLITE_STATIC);
92742: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, proxy_file_path, 0);
92743: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
92744: }
92745: }else{
92746: Pager *pPager = sqlite3BtreePager(pDb->pBt);
92747: sqlite3_file *pFile = sqlite3PagerFile(pPager);
92748: int res;
92749: if( zRight[0] ){
92750: res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
92751: zRight);
92752: } else {
92753: res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
92754: NULL);
92755: }
92756: if( res!=SQLITE_OK ){
92757: sqlite3ErrorMsg(pParse, "failed to set lock proxy file");
92758: goto pragma_out;
92759: }
92760: }
92761: }else
92762: #endif /* SQLITE_ENABLE_LOCKING_STYLE */
92763:
92764: /*
92765: ** PRAGMA [database.]synchronous
92766: ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
92767: **
92768: ** Return or set the local value of the synchronous flag. Changing
92769: ** the local value does not make changes to the disk file and the
92770: ** default value will be restored the next time the database is
92771: ** opened.
92772: */
92773: if( sqlite3StrICmp(zLeft,"synchronous")==0 ){
92774: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
92775: if( !zRight ){
92776: returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
92777: }else{
92778: if( !db->autoCommit ){
92779: sqlite3ErrorMsg(pParse,
92780: "Safety level may not be changed inside a transaction");
92781: }else{
92782: pDb->safety_level = getSafetyLevel(zRight)+1;
92783: }
92784: }
92785: }else
92786: #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
92787:
92788: #ifndef SQLITE_OMIT_FLAG_PRAGMAS
92789: if( flagPragma(pParse, zLeft, zRight) ){
92790: /* The flagPragma() subroutine also generates any necessary code
92791: ** there is nothing more to do here */
92792: }else
92793: #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
92794:
92795: #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
92796: /*
92797: ** PRAGMA table_info(<table>)
92798: **
92799: ** Return a single row for each column of the named table. The columns of
92800: ** the returned data set are:
92801: **
92802: ** cid: Column id (numbered from left to right, starting at 0)
92803: ** name: Column name
92804: ** type: Column declaration type.
92805: ** notnull: True if 'NOT NULL' is part of column declaration
92806: ** dflt_value: The default value for the column, if any.
92807: */
92808: if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){
92809: Table *pTab;
92810: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
92811: pTab = sqlite3FindTable(db, zRight, zDb);
92812: if( pTab ){
92813: int i;
92814: int nHidden = 0;
92815: Column *pCol;
92816: sqlite3VdbeSetNumCols(v, 6);
92817: pParse->nMem = 6;
92818: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", SQLITE_STATIC);
92819: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
92820: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", SQLITE_STATIC);
92821: sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", SQLITE_STATIC);
92822: sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", SQLITE_STATIC);
92823: sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", SQLITE_STATIC);
92824: sqlite3ViewGetColumnNames(pParse, pTab);
92825: for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
92826: if( IsHiddenColumn(pCol) ){
92827: nHidden++;
92828: continue;
92829: }
92830: sqlite3VdbeAddOp2(v, OP_Integer, i-nHidden, 1);
92831: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
92832: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
92833: pCol->zType ? pCol->zType : "", 0);
92834: sqlite3VdbeAddOp2(v, OP_Integer, (pCol->notNull ? 1 : 0), 4);
92835: if( pCol->zDflt ){
92836: sqlite3VdbeAddOp4(v, OP_String8, 0, 5, 0, (char*)pCol->zDflt, 0);
92837: }else{
92838: sqlite3VdbeAddOp2(v, OP_Null, 0, 5);
92839: }
92840: sqlite3VdbeAddOp2(v, OP_Integer, pCol->isPrimKey, 6);
92841: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 6);
92842: }
92843: }
92844: }else
92845:
92846: if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){
92847: Index *pIdx;
92848: Table *pTab;
92849: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
92850: pIdx = sqlite3FindIndex(db, zRight, zDb);
92851: if( pIdx ){
92852: int i;
92853: pTab = pIdx->pTable;
92854: sqlite3VdbeSetNumCols(v, 3);
92855: pParse->nMem = 3;
92856: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", SQLITE_STATIC);
92857: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", SQLITE_STATIC);
92858: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", SQLITE_STATIC);
92859: for(i=0; i<pIdx->nColumn; i++){
92860: int cnum = pIdx->aiColumn[i];
92861: sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
92862: sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2);
92863: assert( pTab->nCol>cnum );
92864: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
92865: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
92866: }
92867: }
92868: }else
92869:
92870: if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){
92871: Index *pIdx;
92872: Table *pTab;
92873: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
92874: pTab = sqlite3FindTable(db, zRight, zDb);
92875: if( pTab ){
92876: v = sqlite3GetVdbe(pParse);
92877: pIdx = pTab->pIndex;
92878: if( pIdx ){
92879: int i = 0;
92880: sqlite3VdbeSetNumCols(v, 3);
92881: pParse->nMem = 3;
92882: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
92883: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
92884: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", SQLITE_STATIC);
92885: while(pIdx){
92886: sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
92887: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
92888: sqlite3VdbeAddOp2(v, OP_Integer, pIdx->onError!=OE_None, 3);
92889: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
92890: ++i;
92891: pIdx = pIdx->pNext;
92892: }
92893: }
92894: }
92895: }else
92896:
92897: if( sqlite3StrICmp(zLeft, "database_list")==0 ){
92898: int i;
92899: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
92900: sqlite3VdbeSetNumCols(v, 3);
92901: pParse->nMem = 3;
92902: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
92903: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
92904: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", SQLITE_STATIC);
92905: for(i=0; i<db->nDb; i++){
92906: if( db->aDb[i].pBt==0 ) continue;
92907: assert( db->aDb[i].zName!=0 );
92908: sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
92909: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
92910: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
92911: sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
92912: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
92913: }
92914: }else
92915:
92916: if( sqlite3StrICmp(zLeft, "collation_list")==0 ){
92917: int i = 0;
92918: HashElem *p;
92919: sqlite3VdbeSetNumCols(v, 2);
92920: pParse->nMem = 2;
92921: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
92922: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
92923: for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
92924: CollSeq *pColl = (CollSeq *)sqliteHashData(p);
92925: sqlite3VdbeAddOp2(v, OP_Integer, i++, 1);
92926: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
92927: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
92928: }
92929: }else
92930: #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
92931:
92932: #ifndef SQLITE_OMIT_FOREIGN_KEY
92933: if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
92934: FKey *pFK;
92935: Table *pTab;
92936: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
92937: pTab = sqlite3FindTable(db, zRight, zDb);
92938: if( pTab ){
92939: v = sqlite3GetVdbe(pParse);
92940: pFK = pTab->pFKey;
92941: if( pFK ){
92942: int i = 0;
92943: sqlite3VdbeSetNumCols(v, 8);
92944: pParse->nMem = 8;
92945: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", SQLITE_STATIC);
92946: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", SQLITE_STATIC);
92947: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", SQLITE_STATIC);
92948: sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", SQLITE_STATIC);
92949: sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", SQLITE_STATIC);
92950: sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "on_update", SQLITE_STATIC);
92951: sqlite3VdbeSetColName(v, 6, COLNAME_NAME, "on_delete", SQLITE_STATIC);
92952: sqlite3VdbeSetColName(v, 7, COLNAME_NAME, "match", SQLITE_STATIC);
92953: while(pFK){
92954: int j;
92955: for(j=0; j<pFK->nCol; j++){
92956: char *zCol = pFK->aCol[j].zCol;
92957: char *zOnDelete = (char *)actionName(pFK->aAction[0]);
92958: char *zOnUpdate = (char *)actionName(pFK->aAction[1]);
92959: sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
92960: sqlite3VdbeAddOp2(v, OP_Integer, j, 2);
92961: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pFK->zTo, 0);
92962: sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0,
92963: pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
92964: sqlite3VdbeAddOp4(v, zCol ? OP_String8 : OP_Null, 0, 5, 0, zCol, 0);
92965: sqlite3VdbeAddOp4(v, OP_String8, 0, 6, 0, zOnUpdate, 0);
92966: sqlite3VdbeAddOp4(v, OP_String8, 0, 7, 0, zOnDelete, 0);
92967: sqlite3VdbeAddOp4(v, OP_String8, 0, 8, 0, "NONE", 0);
92968: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 8);
92969: }
92970: ++i;
92971: pFK = pFK->pNextFrom;
92972: }
92973: }
92974: }
92975: }else
92976: #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
92977:
92978: #ifndef NDEBUG
92979: if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){
92980: if( zRight ){
92981: if( sqlite3GetBoolean(zRight) ){
92982: sqlite3ParserTrace(stderr, "parser: ");
92983: }else{
92984: sqlite3ParserTrace(0, 0);
92985: }
92986: }
92987: }else
92988: #endif
92989:
92990: /* Reinstall the LIKE and GLOB functions. The variant of LIKE
92991: ** used will be case sensitive or not depending on the RHS.
92992: */
92993: if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){
92994: if( zRight ){
92995: sqlite3RegisterLikeFunctions(db, sqlite3GetBoolean(zRight));
92996: }
92997: }else
92998:
92999: #ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
93000: # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
93001: #endif
93002:
93003: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
93004: /* Pragma "quick_check" is an experimental reduced version of
93005: ** integrity_check designed to detect most database corruption
93006: ** without most of the overhead of a full integrity-check.
93007: */
93008: if( sqlite3StrICmp(zLeft, "integrity_check")==0
93009: || sqlite3StrICmp(zLeft, "quick_check")==0
93010: ){
93011: int i, j, addr, mxErr;
93012:
93013: /* Code that appears at the end of the integrity check. If no error
93014: ** messages have been generated, output OK. Otherwise output the
93015: ** error message
93016: */
93017: static const VdbeOpList endCode[] = {
93018: { OP_AddImm, 1, 0, 0}, /* 0 */
93019: { OP_IfNeg, 1, 0, 0}, /* 1 */
93020: { OP_String8, 0, 3, 0}, /* 2 */
93021: { OP_ResultRow, 3, 1, 0},
93022: };
93023:
93024: int isQuick = (sqlite3Tolower(zLeft[0])=='q');
93025:
93026: /* Initialize the VDBE program */
93027: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
93028: pParse->nMem = 6;
93029: sqlite3VdbeSetNumCols(v, 1);
93030: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", SQLITE_STATIC);
93031:
93032: /* Set the maximum error count */
93033: mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
93034: if( zRight ){
93035: sqlite3GetInt32(zRight, &mxErr);
93036: if( mxErr<=0 ){
93037: mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
93038: }
93039: }
93040: sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1); /* reg[1] holds errors left */
93041:
93042: /* Do an integrity check on each database file */
93043: for(i=0; i<db->nDb; i++){
93044: HashElem *x;
93045: Hash *pTbls;
93046: int cnt = 0;
93047:
93048: if( OMIT_TEMPDB && i==1 ) continue;
93049:
93050: sqlite3CodeVerifySchema(pParse, i);
93051: addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
93052: sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
93053: sqlite3VdbeJumpHere(v, addr);
93054:
93055: /* Do an integrity check of the B-Tree
93056: **
93057: ** Begin by filling registers 2, 3, ... with the root pages numbers
93058: ** for all tables and indices in the database.
93059: */
93060: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
93061: pTbls = &db->aDb[i].pSchema->tblHash;
93062: for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
93063: Table *pTab = sqliteHashData(x);
93064: Index *pIdx;
93065: sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
93066: cnt++;
93067: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
93068: sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt);
93069: cnt++;
93070: }
93071: }
93072:
93073: /* Make sure sufficient number of registers have been allocated */
93074: if( pParse->nMem < cnt+4 ){
93075: pParse->nMem = cnt+4;
93076: }
93077:
93078: /* Do the b-tree integrity checks */
93079: sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1);
93080: sqlite3VdbeChangeP5(v, (u8)i);
93081: addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2);
93082: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
93083: sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
93084: P4_DYNAMIC);
93085: sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1);
93086: sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
93087: sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
93088: sqlite3VdbeJumpHere(v, addr);
93089:
93090: /* Make sure all the indices are constructed correctly.
93091: */
93092: for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
93093: Table *pTab = sqliteHashData(x);
93094: Index *pIdx;
93095: int loopTop;
93096:
93097: if( pTab->pIndex==0 ) continue;
93098: addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */
93099: sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
93100: sqlite3VdbeJumpHere(v, addr);
93101: sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
93102: sqlite3VdbeAddOp2(v, OP_Integer, 0, 2); /* reg(2) will count entries */
93103: loopTop = sqlite3VdbeAddOp2(v, OP_Rewind, 1, 0);
93104: sqlite3VdbeAddOp2(v, OP_AddImm, 2, 1); /* increment entry count */
93105: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
93106: int jmp2;
93107: int r1;
93108: static const VdbeOpList idxErr[] = {
93109: { OP_AddImm, 1, -1, 0},
93110: { OP_String8, 0, 3, 0}, /* 1 */
93111: { OP_Rowid, 1, 4, 0},
93112: { OP_String8, 0, 5, 0}, /* 3 */
93113: { OP_String8, 0, 6, 0}, /* 4 */
93114: { OP_Concat, 4, 3, 3},
93115: { OP_Concat, 5, 3, 3},
93116: { OP_Concat, 6, 3, 3},
93117: { OP_ResultRow, 3, 1, 0},
93118: { OP_IfPos, 1, 0, 0}, /* 9 */
93119: { OP_Halt, 0, 0, 0},
93120: };
93121: r1 = sqlite3GenerateIndexKey(pParse, pIdx, 1, 3, 0);
93122: jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, j+2, 0, r1, pIdx->nColumn+1);
93123: addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
93124: sqlite3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC);
93125: sqlite3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC);
93126: sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_TRANSIENT);
93127: sqlite3VdbeJumpHere(v, addr+9);
93128: sqlite3VdbeJumpHere(v, jmp2);
93129: }
93130: sqlite3VdbeAddOp2(v, OP_Next, 1, loopTop+1);
93131: sqlite3VdbeJumpHere(v, loopTop);
93132: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
93133: static const VdbeOpList cntIdx[] = {
93134: { OP_Integer, 0, 3, 0},
93135: { OP_Rewind, 0, 0, 0}, /* 1 */
93136: { OP_AddImm, 3, 1, 0},
93137: { OP_Next, 0, 0, 0}, /* 3 */
93138: { OP_Eq, 2, 0, 3}, /* 4 */
93139: { OP_AddImm, 1, -1, 0},
93140: { OP_String8, 0, 2, 0}, /* 6 */
93141: { OP_String8, 0, 3, 0}, /* 7 */
93142: { OP_Concat, 3, 2, 2},
93143: { OP_ResultRow, 2, 1, 0},
93144: };
93145: addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);
93146: sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
93147: sqlite3VdbeJumpHere(v, addr);
93148: addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
93149: sqlite3VdbeChangeP1(v, addr+1, j+2);
93150: sqlite3VdbeChangeP2(v, addr+1, addr+4);
93151: sqlite3VdbeChangeP1(v, addr+3, j+2);
93152: sqlite3VdbeChangeP2(v, addr+3, addr+2);
93153: sqlite3VdbeJumpHere(v, addr+4);
93154: sqlite3VdbeChangeP4(v, addr+6,
93155: "wrong # of entries in index ", P4_STATIC);
93156: sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_TRANSIENT);
93157: }
93158: }
93159: }
93160: addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
93161: sqlite3VdbeChangeP2(v, addr, -mxErr);
93162: sqlite3VdbeJumpHere(v, addr+1);
93163: sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC);
93164: }else
93165: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
93166:
93167: #ifndef SQLITE_OMIT_UTF16
93168: /*
93169: ** PRAGMA encoding
93170: ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
93171: **
93172: ** In its first form, this pragma returns the encoding of the main
93173: ** database. If the database is not initialized, it is initialized now.
93174: **
93175: ** The second form of this pragma is a no-op if the main database file
93176: ** has not already been initialized. In this case it sets the default
93177: ** encoding that will be used for the main database file if a new file
93178: ** is created. If an existing main database file is opened, then the
93179: ** default text encoding for the existing database is used.
93180: **
93181: ** In all cases new databases created using the ATTACH command are
93182: ** created to use the same default text encoding as the main database. If
93183: ** the main database has not been initialized and/or created when ATTACH
93184: ** is executed, this is done before the ATTACH operation.
93185: **
93186: ** In the second form this pragma sets the text encoding to be used in
93187: ** new database files created using this database handle. It is only
93188: ** useful if invoked immediately after the main database i
93189: */
93190: if( sqlite3StrICmp(zLeft, "encoding")==0 ){
93191: static const struct EncName {
93192: char *zName;
93193: u8 enc;
93194: } encnames[] = {
93195: { "UTF8", SQLITE_UTF8 },
93196: { "UTF-8", SQLITE_UTF8 }, /* Must be element [1] */
93197: { "UTF-16le", SQLITE_UTF16LE }, /* Must be element [2] */
93198: { "UTF-16be", SQLITE_UTF16BE }, /* Must be element [3] */
93199: { "UTF16le", SQLITE_UTF16LE },
93200: { "UTF16be", SQLITE_UTF16BE },
93201: { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */
93202: { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */
93203: { 0, 0 }
93204: };
93205: const struct EncName *pEnc;
93206: if( !zRight ){ /* "PRAGMA encoding" */
93207: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
93208: sqlite3VdbeSetNumCols(v, 1);
93209: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", SQLITE_STATIC);
93210: sqlite3VdbeAddOp2(v, OP_String8, 0, 1);
93211: assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
93212: assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
93213: assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE );
93214: sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
93215: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
93216: }else{ /* "PRAGMA encoding = XXX" */
93217: /* Only change the value of sqlite.enc if the database handle is not
93218: ** initialized. If the main database exists, the new sqlite.enc value
93219: ** will be overwritten when the schema is next loaded. If it does not
93220: ** already exists, it will be created to use the new encoding value.
93221: */
93222: if(
93223: !(DbHasProperty(db, 0, DB_SchemaLoaded)) ||
93224: DbHasProperty(db, 0, DB_Empty)
93225: ){
93226: for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
93227: if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
93228: ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
93229: break;
93230: }
93231: }
93232: if( !pEnc->zName ){
93233: sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
93234: }
93235: }
93236: }
93237: }else
93238: #endif /* SQLITE_OMIT_UTF16 */
93239:
93240: #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
93241: /*
93242: ** PRAGMA [database.]schema_version
93243: ** PRAGMA [database.]schema_version = <integer>
93244: **
93245: ** PRAGMA [database.]user_version
93246: ** PRAGMA [database.]user_version = <integer>
93247: **
93248: ** The pragma's schema_version and user_version are used to set or get
93249: ** the value of the schema-version and user-version, respectively. Both
93250: ** the schema-version and the user-version are 32-bit signed integers
93251: ** stored in the database header.
93252: **
93253: ** The schema-cookie is usually only manipulated internally by SQLite. It
93254: ** is incremented by SQLite whenever the database schema is modified (by
93255: ** creating or dropping a table or index). The schema version is used by
93256: ** SQLite each time a query is executed to ensure that the internal cache
93257: ** of the schema used when compiling the SQL query matches the schema of
93258: ** the database against which the compiled query is actually executed.
93259: ** Subverting this mechanism by using "PRAGMA schema_version" to modify
93260: ** the schema-version is potentially dangerous and may lead to program
93261: ** crashes or database corruption. Use with caution!
93262: **
93263: ** The user-version is not used internally by SQLite. It may be used by
93264: ** applications for any purpose.
93265: */
93266: if( sqlite3StrICmp(zLeft, "schema_version")==0
93267: || sqlite3StrICmp(zLeft, "user_version")==0
93268: || sqlite3StrICmp(zLeft, "freelist_count")==0
93269: ){
93270: int iCookie; /* Cookie index. 1 for schema-cookie, 6 for user-cookie. */
93271: sqlite3VdbeUsesBtree(v, iDb);
93272: switch( zLeft[0] ){
93273: case 'f': case 'F':
93274: iCookie = BTREE_FREE_PAGE_COUNT;
93275: break;
93276: case 's': case 'S':
93277: iCookie = BTREE_SCHEMA_VERSION;
93278: break;
93279: default:
93280: iCookie = BTREE_USER_VERSION;
93281: break;
93282: }
93283:
93284: if( zRight && iCookie!=BTREE_FREE_PAGE_COUNT ){
93285: /* Write the specified cookie value */
93286: static const VdbeOpList setCookie[] = {
93287: { OP_Transaction, 0, 1, 0}, /* 0 */
93288: { OP_Integer, 0, 1, 0}, /* 1 */
93289: { OP_SetCookie, 0, 0, 1}, /* 2 */
93290: };
93291: int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
93292: sqlite3VdbeChangeP1(v, addr, iDb);
93293: sqlite3VdbeChangeP1(v, addr+1, sqlite3Atoi(zRight));
93294: sqlite3VdbeChangeP1(v, addr+2, iDb);
93295: sqlite3VdbeChangeP2(v, addr+2, iCookie);
93296: }else{
93297: /* Read the specified cookie value */
93298: static const VdbeOpList readCookie[] = {
93299: { OP_Transaction, 0, 0, 0}, /* 0 */
93300: { OP_ReadCookie, 0, 1, 0}, /* 1 */
93301: { OP_ResultRow, 1, 1, 0}
93302: };
93303: int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
93304: sqlite3VdbeChangeP1(v, addr, iDb);
93305: sqlite3VdbeChangeP1(v, addr+1, iDb);
93306: sqlite3VdbeChangeP3(v, addr+1, iCookie);
93307: sqlite3VdbeSetNumCols(v, 1);
93308: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);
93309: }
93310: }else
93311: #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
93312:
93313: #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
93314: /*
93315: ** PRAGMA compile_options
93316: **
93317: ** Return the names of all compile-time options used in this build,
93318: ** one option per row.
93319: */
93320: if( sqlite3StrICmp(zLeft, "compile_options")==0 ){
93321: int i = 0;
93322: const char *zOpt;
93323: sqlite3VdbeSetNumCols(v, 1);
93324: pParse->nMem = 1;
93325: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "compile_option", SQLITE_STATIC);
93326: while( (zOpt = sqlite3_compileoption_get(i++))!=0 ){
93327: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zOpt, 0);
93328: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
93329: }
93330: }else
93331: #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
93332:
93333: #ifndef SQLITE_OMIT_WAL
93334: /*
93335: ** PRAGMA [database.]wal_checkpoint = passive|full|restart
93336: **
93337: ** Checkpoint the database.
93338: */
93339: if( sqlite3StrICmp(zLeft, "wal_checkpoint")==0 ){
93340: int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
93341: int eMode = SQLITE_CHECKPOINT_PASSIVE;
93342: if( zRight ){
93343: if( sqlite3StrICmp(zRight, "full")==0 ){
93344: eMode = SQLITE_CHECKPOINT_FULL;
93345: }else if( sqlite3StrICmp(zRight, "restart")==0 ){
93346: eMode = SQLITE_CHECKPOINT_RESTART;
93347: }
93348: }
93349: if( sqlite3ReadSchema(pParse) ) goto pragma_out;
93350: sqlite3VdbeSetNumCols(v, 3);
93351: pParse->nMem = 3;
93352: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "busy", SQLITE_STATIC);
93353: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "log", SQLITE_STATIC);
93354: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "checkpointed", SQLITE_STATIC);
93355:
93356: sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1);
93357: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
93358: }else
93359:
93360: /*
93361: ** PRAGMA wal_autocheckpoint
93362: ** PRAGMA wal_autocheckpoint = N
93363: **
93364: ** Configure a database connection to automatically checkpoint a database
93365: ** after accumulating N frames in the log. Or query for the current value
93366: ** of N.
93367: */
93368: if( sqlite3StrICmp(zLeft, "wal_autocheckpoint")==0 ){
93369: if( zRight ){
93370: sqlite3_wal_autocheckpoint(db, sqlite3Atoi(zRight));
93371: }
93372: returnSingleInt(pParse, "wal_autocheckpoint",
93373: db->xWalCallback==sqlite3WalDefaultHook ?
93374: SQLITE_PTR_TO_INT(db->pWalArg) : 0);
93375: }else
93376: #endif
93377:
93378: /*
93379: ** PRAGMA shrink_memory
93380: **
93381: ** This pragma attempts to free as much memory as possible from the
93382: ** current database connection.
93383: */
93384: if( sqlite3StrICmp(zLeft, "shrink_memory")==0 ){
93385: sqlite3_db_release_memory(db);
93386: }else
93387:
93388: #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
93389: /*
93390: ** Report the current state of file logs for all databases
93391: */
93392: if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
93393: static const char *const azLockName[] = {
93394: "unlocked", "shared", "reserved", "pending", "exclusive"
93395: };
93396: int i;
93397: sqlite3VdbeSetNumCols(v, 2);
93398: pParse->nMem = 2;
93399: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", SQLITE_STATIC);
93400: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", SQLITE_STATIC);
93401: for(i=0; i<db->nDb; i++){
93402: Btree *pBt;
93403: Pager *pPager;
93404: const char *zState = "unknown";
93405: int j;
93406: if( db->aDb[i].zName==0 ) continue;
93407: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
93408: pBt = db->aDb[i].pBt;
93409: if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
93410: zState = "closed";
93411: }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
93412: SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
93413: zState = azLockName[j];
93414: }
93415: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, zState, P4_STATIC);
93416: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
93417: }
93418:
93419: }else
93420: #endif
93421:
93422: #ifdef SQLITE_HAS_CODEC
93423: if( sqlite3StrICmp(zLeft, "key")==0 && zRight ){
93424: sqlite3_key(db, zRight, sqlite3Strlen30(zRight));
93425: }else
93426: if( sqlite3StrICmp(zLeft, "rekey")==0 && zRight ){
93427: sqlite3_rekey(db, zRight, sqlite3Strlen30(zRight));
93428: }else
93429: if( zRight && (sqlite3StrICmp(zLeft, "hexkey")==0 ||
93430: sqlite3StrICmp(zLeft, "hexrekey")==0) ){
93431: int i, h1, h2;
93432: char zKey[40];
93433: for(i=0; (h1 = zRight[i])!=0 && (h2 = zRight[i+1])!=0; i+=2){
93434: h1 += 9*(1&(h1>>6));
93435: h2 += 9*(1&(h2>>6));
93436: zKey[i/2] = (h2 & 0x0f) | ((h1 & 0xf)<<4);
93437: }
93438: if( (zLeft[3] & 0xf)==0xb ){
93439: sqlite3_key(db, zKey, i/2);
93440: }else{
93441: sqlite3_rekey(db, zKey, i/2);
93442: }
93443: }else
93444: #endif
93445: #if defined(SQLITE_HAS_CODEC) || defined(SQLITE_ENABLE_CEROD)
93446: if( sqlite3StrICmp(zLeft, "activate_extensions")==0 ){
93447: #ifdef SQLITE_HAS_CODEC
93448: if( sqlite3StrNICmp(zRight, "see-", 4)==0 ){
93449: sqlite3_activate_see(&zRight[4]);
93450: }
93451: #endif
93452: #ifdef SQLITE_ENABLE_CEROD
93453: if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){
93454: sqlite3_activate_cerod(&zRight[6]);
93455: }
93456: #endif
93457: }else
93458: #endif
93459:
93460:
93461: {/* Empty ELSE clause */}
93462:
93463: /*
93464: ** Reset the safety level, in case the fullfsync flag or synchronous
93465: ** setting changed.
93466: */
93467: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
93468: if( db->autoCommit ){
93469: sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level,
93470: (db->flags&SQLITE_FullFSync)!=0,
93471: (db->flags&SQLITE_CkptFullFSync)!=0);
93472: }
93473: #endif
93474: pragma_out:
93475: sqlite3DbFree(db, zLeft);
93476: sqlite3DbFree(db, zRight);
93477: }
93478:
93479: #endif /* SQLITE_OMIT_PRAGMA */
93480:
93481: /************** End of pragma.c **********************************************/
93482: /************** Begin file prepare.c *****************************************/
93483: /*
93484: ** 2005 May 25
93485: **
93486: ** The author disclaims copyright to this source code. In place of
93487: ** a legal notice, here is a blessing:
93488: **
93489: ** May you do good and not evil.
93490: ** May you find forgiveness for yourself and forgive others.
93491: ** May you share freely, never taking more than you give.
93492: **
93493: *************************************************************************
93494: ** This file contains the implementation of the sqlite3_prepare()
93495: ** interface, and routines that contribute to loading the database schema
93496: ** from disk.
93497: */
93498:
93499: /*
93500: ** Fill the InitData structure with an error message that indicates
93501: ** that the database is corrupt.
93502: */
93503: static void corruptSchema(
93504: InitData *pData, /* Initialization context */
93505: const char *zObj, /* Object being parsed at the point of error */
93506: const char *zExtra /* Error information */
93507: ){
93508: sqlite3 *db = pData->db;
93509: if( !db->mallocFailed && (db->flags & SQLITE_RecoveryMode)==0 ){
93510: if( zObj==0 ) zObj = "?";
93511: sqlite3SetString(pData->pzErrMsg, db,
93512: "malformed database schema (%s)", zObj);
93513: if( zExtra ){
93514: *pData->pzErrMsg = sqlite3MAppendf(db, *pData->pzErrMsg,
93515: "%s - %s", *pData->pzErrMsg, zExtra);
93516: }
93517: }
93518: pData->rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_CORRUPT_BKPT;
93519: }
93520:
93521: /*
93522: ** This is the callback routine for the code that initializes the
93523: ** database. See sqlite3Init() below for additional information.
93524: ** This routine is also called from the OP_ParseSchema opcode of the VDBE.
93525: **
93526: ** Each callback contains the following information:
93527: **
93528: ** argv[0] = name of thing being created
93529: ** argv[1] = root page number for table or index. 0 for trigger or view.
93530: ** argv[2] = SQL text for the CREATE statement.
93531: **
93532: */
93533: SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
93534: InitData *pData = (InitData*)pInit;
93535: sqlite3 *db = pData->db;
93536: int iDb = pData->iDb;
93537:
93538: assert( argc==3 );
93539: UNUSED_PARAMETER2(NotUsed, argc);
93540: assert( sqlite3_mutex_held(db->mutex) );
93541: DbClearProperty(db, iDb, DB_Empty);
93542: if( db->mallocFailed ){
93543: corruptSchema(pData, argv[0], 0);
93544: return 1;
93545: }
93546:
93547: assert( iDb>=0 && iDb<db->nDb );
93548: if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
93549: if( argv[1]==0 ){
93550: corruptSchema(pData, argv[0], 0);
93551: }else if( argv[2] && argv[2][0] ){
93552: /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
93553: ** But because db->init.busy is set to 1, no VDBE code is generated
93554: ** or executed. All the parser does is build the internal data
93555: ** structures that describe the table, index, or view.
93556: */
93557: int rc;
93558: sqlite3_stmt *pStmt;
93559: TESTONLY(int rcp); /* Return code from sqlite3_prepare() */
93560:
93561: assert( db->init.busy );
93562: db->init.iDb = iDb;
93563: db->init.newTnum = sqlite3Atoi(argv[1]);
93564: db->init.orphanTrigger = 0;
93565: TESTONLY(rcp = ) sqlite3_prepare(db, argv[2], -1, &pStmt, 0);
93566: rc = db->errCode;
93567: assert( (rc&0xFF)==(rcp&0xFF) );
93568: db->init.iDb = 0;
93569: if( SQLITE_OK!=rc ){
93570: if( db->init.orphanTrigger ){
93571: assert( iDb==1 );
93572: }else{
93573: pData->rc = rc;
93574: if( rc==SQLITE_NOMEM ){
93575: db->mallocFailed = 1;
93576: }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
93577: corruptSchema(pData, argv[0], sqlite3_errmsg(db));
93578: }
93579: }
93580: }
93581: sqlite3_finalize(pStmt);
93582: }else if( argv[0]==0 ){
93583: corruptSchema(pData, 0, 0);
93584: }else{
93585: /* If the SQL column is blank it means this is an index that
93586: ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
93587: ** constraint for a CREATE TABLE. The index should have already
93588: ** been created when we processed the CREATE TABLE. All we have
93589: ** to do here is record the root page number for that index.
93590: */
93591: Index *pIndex;
93592: pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
93593: if( pIndex==0 ){
93594: /* This can occur if there exists an index on a TEMP table which
93595: ** has the same name as another index on a permanent index. Since
93596: ** the permanent table is hidden by the TEMP table, we can also
93597: ** safely ignore the index on the permanent table.
93598: */
93599: /* Do Nothing */;
93600: }else if( sqlite3GetInt32(argv[1], &pIndex->tnum)==0 ){
93601: corruptSchema(pData, argv[0], "invalid rootpage");
93602: }
93603: }
93604: return 0;
93605: }
93606:
93607: /*
93608: ** Attempt to read the database schema and initialize internal
93609: ** data structures for a single database file. The index of the
93610: ** database file is given by iDb. iDb==0 is used for the main
93611: ** database. iDb==1 should never be used. iDb>=2 is used for
93612: ** auxiliary databases. Return one of the SQLITE_ error codes to
93613: ** indicate success or failure.
93614: */
93615: static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
93616: int rc;
93617: int i;
93618: int size;
93619: Table *pTab;
93620: Db *pDb;
93621: char const *azArg[4];
93622: int meta[5];
93623: InitData initData;
93624: char const *zMasterSchema;
93625: char const *zMasterName;
93626: int openedTransaction = 0;
93627:
93628: /*
93629: ** The master database table has a structure like this
93630: */
93631: static const char master_schema[] =
93632: "CREATE TABLE sqlite_master(\n"
93633: " type text,\n"
93634: " name text,\n"
93635: " tbl_name text,\n"
93636: " rootpage integer,\n"
93637: " sql text\n"
93638: ")"
93639: ;
93640: #ifndef SQLITE_OMIT_TEMPDB
93641: static const char temp_master_schema[] =
93642: "CREATE TEMP TABLE sqlite_temp_master(\n"
93643: " type text,\n"
93644: " name text,\n"
93645: " tbl_name text,\n"
93646: " rootpage integer,\n"
93647: " sql text\n"
93648: ")"
93649: ;
93650: #else
93651: #define temp_master_schema 0
93652: #endif
93653:
93654: assert( iDb>=0 && iDb<db->nDb );
93655: assert( db->aDb[iDb].pSchema );
93656: assert( sqlite3_mutex_held(db->mutex) );
93657: assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
93658:
93659: /* zMasterSchema and zInitScript are set to point at the master schema
93660: ** and initialisation script appropriate for the database being
93661: ** initialised. zMasterName is the name of the master table.
93662: */
93663: if( !OMIT_TEMPDB && iDb==1 ){
93664: zMasterSchema = temp_master_schema;
93665: }else{
93666: zMasterSchema = master_schema;
93667: }
93668: zMasterName = SCHEMA_TABLE(iDb);
93669:
93670: /* Construct the schema tables. */
93671: azArg[0] = zMasterName;
93672: azArg[1] = "1";
93673: azArg[2] = zMasterSchema;
93674: azArg[3] = 0;
93675: initData.db = db;
93676: initData.iDb = iDb;
93677: initData.rc = SQLITE_OK;
93678: initData.pzErrMsg = pzErrMsg;
93679: sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
93680: if( initData.rc ){
93681: rc = initData.rc;
93682: goto error_out;
93683: }
93684: pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
93685: if( ALWAYS(pTab) ){
93686: pTab->tabFlags |= TF_Readonly;
93687: }
93688:
93689: /* Create a cursor to hold the database open
93690: */
93691: pDb = &db->aDb[iDb];
93692: if( pDb->pBt==0 ){
93693: if( !OMIT_TEMPDB && ALWAYS(iDb==1) ){
93694: DbSetProperty(db, 1, DB_SchemaLoaded);
93695: }
93696: return SQLITE_OK;
93697: }
93698:
93699: /* If there is not already a read-only (or read-write) transaction opened
93700: ** on the b-tree database, open one now. If a transaction is opened, it
93701: ** will be closed before this function returns. */
93702: sqlite3BtreeEnter(pDb->pBt);
93703: if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){
93704: rc = sqlite3BtreeBeginTrans(pDb->pBt, 0);
93705: if( rc!=SQLITE_OK ){
93706: sqlite3SetString(pzErrMsg, db, "%s", sqlite3ErrStr(rc));
93707: goto initone_error_out;
93708: }
93709: openedTransaction = 1;
93710: }
93711:
93712: /* Get the database meta information.
93713: **
93714: ** Meta values are as follows:
93715: ** meta[0] Schema cookie. Changes with each schema change.
93716: ** meta[1] File format of schema layer.
93717: ** meta[2] Size of the page cache.
93718: ** meta[3] Largest rootpage (auto/incr_vacuum mode)
93719: ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
93720: ** meta[5] User version
93721: ** meta[6] Incremental vacuum mode
93722: ** meta[7] unused
93723: ** meta[8] unused
93724: ** meta[9] unused
93725: **
93726: ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
93727: ** the possible values of meta[4].
93728: */
93729: for(i=0; i<ArraySize(meta); i++){
93730: sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
93731: }
93732: pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1];
93733:
93734: /* If opening a non-empty database, check the text encoding. For the
93735: ** main database, set sqlite3.enc to the encoding of the main database.
93736: ** For an attached db, it is an error if the encoding is not the same
93737: ** as sqlite3.enc.
93738: */
93739: if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */
93740: if( iDb==0 ){
93741: u8 encoding;
93742: /* If opening the main database, set ENC(db). */
93743: encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3;
93744: if( encoding==0 ) encoding = SQLITE_UTF8;
93745: ENC(db) = encoding;
93746: db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 0);
93747: }else{
93748: /* If opening an attached database, the encoding much match ENC(db) */
93749: if( meta[BTREE_TEXT_ENCODING-1]!=ENC(db) ){
93750: sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
93751: " text encoding as main database");
93752: rc = SQLITE_ERROR;
93753: goto initone_error_out;
93754: }
93755: }
93756: }else{
93757: DbSetProperty(db, iDb, DB_Empty);
93758: }
93759: pDb->pSchema->enc = ENC(db);
93760:
93761: if( pDb->pSchema->cache_size==0 ){
93762: #ifndef SQLITE_OMIT_DEPRECATED
93763: size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]);
93764: if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
93765: pDb->pSchema->cache_size = size;
93766: #else
93767: pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE;
93768: #endif
93769: sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
93770: }
93771:
93772: /*
93773: ** file_format==1 Version 3.0.0.
93774: ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN
93775: ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
93776: ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants
93777: */
93778: pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1];
93779: if( pDb->pSchema->file_format==0 ){
93780: pDb->pSchema->file_format = 1;
93781: }
93782: if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
93783: sqlite3SetString(pzErrMsg, db, "unsupported file format");
93784: rc = SQLITE_ERROR;
93785: goto initone_error_out;
93786: }
93787:
93788: /* Ticket #2804: When we open a database in the newer file format,
93789: ** clear the legacy_file_format pragma flag so that a VACUUM will
93790: ** not downgrade the database and thus invalidate any descending
93791: ** indices that the user might have created.
93792: */
93793: if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
93794: db->flags &= ~SQLITE_LegacyFileFmt;
93795: }
93796:
93797: /* Read the schema information out of the schema tables
93798: */
93799: assert( db->init.busy );
93800: {
93801: char *zSql;
93802: zSql = sqlite3MPrintf(db,
93803: "SELECT name, rootpage, sql FROM '%q'.%s ORDER BY rowid",
93804: db->aDb[iDb].zName, zMasterName);
93805: #ifndef SQLITE_OMIT_AUTHORIZATION
93806: {
93807: int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
93808: xAuth = db->xAuth;
93809: db->xAuth = 0;
93810: #endif
93811: rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
93812: #ifndef SQLITE_OMIT_AUTHORIZATION
93813: db->xAuth = xAuth;
93814: }
93815: #endif
93816: if( rc==SQLITE_OK ) rc = initData.rc;
93817: sqlite3DbFree(db, zSql);
93818: #ifndef SQLITE_OMIT_ANALYZE
93819: if( rc==SQLITE_OK ){
93820: sqlite3AnalysisLoad(db, iDb);
93821: }
93822: #endif
93823: }
93824: if( db->mallocFailed ){
93825: rc = SQLITE_NOMEM;
93826: sqlite3ResetInternalSchema(db, -1);
93827: }
93828: if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
93829: /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
93830: ** the schema loaded, even if errors occurred. In this situation the
93831: ** current sqlite3_prepare() operation will fail, but the following one
93832: ** will attempt to compile the supplied statement against whatever subset
93833: ** of the schema was loaded before the error occurred. The primary
93834: ** purpose of this is to allow access to the sqlite_master table
93835: ** even when its contents have been corrupted.
93836: */
93837: DbSetProperty(db, iDb, DB_SchemaLoaded);
93838: rc = SQLITE_OK;
93839: }
93840:
93841: /* Jump here for an error that occurs after successfully allocating
93842: ** curMain and calling sqlite3BtreeEnter(). For an error that occurs
93843: ** before that point, jump to error_out.
93844: */
93845: initone_error_out:
93846: if( openedTransaction ){
93847: sqlite3BtreeCommit(pDb->pBt);
93848: }
93849: sqlite3BtreeLeave(pDb->pBt);
93850:
93851: error_out:
93852: if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
93853: db->mallocFailed = 1;
93854: }
93855: return rc;
93856: }
93857:
93858: /*
93859: ** Initialize all database files - the main database file, the file
93860: ** used to store temporary tables, and any additional database files
93861: ** created using ATTACH statements. Return a success code. If an
93862: ** error occurs, write an error message into *pzErrMsg.
93863: **
93864: ** After a database is initialized, the DB_SchemaLoaded bit is set
93865: ** bit is set in the flags field of the Db structure. If the database
93866: ** file was of zero-length, then the DB_Empty flag is also set.
93867: */
93868: SQLITE_PRIVATE int sqlite3Init(sqlite3 *db, char **pzErrMsg){
93869: int i, rc;
93870: int commit_internal = !(db->flags&SQLITE_InternChanges);
93871:
93872: assert( sqlite3_mutex_held(db->mutex) );
93873: rc = SQLITE_OK;
93874: db->init.busy = 1;
93875: for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
93876: if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
93877: rc = sqlite3InitOne(db, i, pzErrMsg);
93878: if( rc ){
93879: sqlite3ResetInternalSchema(db, i);
93880: }
93881: }
93882:
93883: /* Once all the other databases have been initialised, load the schema
93884: ** for the TEMP database. This is loaded last, as the TEMP database
93885: ** schema may contain references to objects in other databases.
93886: */
93887: #ifndef SQLITE_OMIT_TEMPDB
93888: if( rc==SQLITE_OK && ALWAYS(db->nDb>1)
93889: && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
93890: rc = sqlite3InitOne(db, 1, pzErrMsg);
93891: if( rc ){
93892: sqlite3ResetInternalSchema(db, 1);
93893: }
93894: }
93895: #endif
93896:
93897: db->init.busy = 0;
93898: if( rc==SQLITE_OK && commit_internal ){
93899: sqlite3CommitInternalChanges(db);
93900: }
93901:
93902: return rc;
93903: }
93904:
93905: /*
93906: ** This routine is a no-op if the database schema is already initialised.
93907: ** Otherwise, the schema is loaded. An error code is returned.
93908: */
93909: SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){
93910: int rc = SQLITE_OK;
93911: sqlite3 *db = pParse->db;
93912: assert( sqlite3_mutex_held(db->mutex) );
93913: if( !db->init.busy ){
93914: rc = sqlite3Init(db, &pParse->zErrMsg);
93915: }
93916: if( rc!=SQLITE_OK ){
93917: pParse->rc = rc;
93918: pParse->nErr++;
93919: }
93920: return rc;
93921: }
93922:
93923:
93924: /*
93925: ** Check schema cookies in all databases. If any cookie is out
93926: ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies
93927: ** make no changes to pParse->rc.
93928: */
93929: static void schemaIsValid(Parse *pParse){
93930: sqlite3 *db = pParse->db;
93931: int iDb;
93932: int rc;
93933: int cookie;
93934:
93935: assert( pParse->checkSchema );
93936: assert( sqlite3_mutex_held(db->mutex) );
93937: for(iDb=0; iDb<db->nDb; iDb++){
93938: int openedTransaction = 0; /* True if a transaction is opened */
93939: Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
93940: if( pBt==0 ) continue;
93941:
93942: /* If there is not already a read-only (or read-write) transaction opened
93943: ** on the b-tree database, open one now. If a transaction is opened, it
93944: ** will be closed immediately after reading the meta-value. */
93945: if( !sqlite3BtreeIsInReadTrans(pBt) ){
93946: rc = sqlite3BtreeBeginTrans(pBt, 0);
93947: if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
93948: db->mallocFailed = 1;
93949: }
93950: if( rc!=SQLITE_OK ) return;
93951: openedTransaction = 1;
93952: }
93953:
93954: /* Read the schema cookie from the database. If it does not match the
93955: ** value stored as part of the in-memory schema representation,
93956: ** set Parse.rc to SQLITE_SCHEMA. */
93957: sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
93958: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
93959: if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
93960: sqlite3ResetInternalSchema(db, iDb);
93961: pParse->rc = SQLITE_SCHEMA;
93962: }
93963:
93964: /* Close the transaction, if one was opened. */
93965: if( openedTransaction ){
93966: sqlite3BtreeCommit(pBt);
93967: }
93968: }
93969: }
93970:
93971: /*
93972: ** Convert a schema pointer into the iDb index that indicates
93973: ** which database file in db->aDb[] the schema refers to.
93974: **
93975: ** If the same database is attached more than once, the first
93976: ** attached database is returned.
93977: */
93978: SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
93979: int i = -1000000;
93980:
93981: /* If pSchema is NULL, then return -1000000. This happens when code in
93982: ** expr.c is trying to resolve a reference to a transient table (i.e. one
93983: ** created by a sub-select). In this case the return value of this
93984: ** function should never be used.
93985: **
93986: ** We return -1000000 instead of the more usual -1 simply because using
93987: ** -1000000 as the incorrect index into db->aDb[] is much
93988: ** more likely to cause a segfault than -1 (of course there are assert()
93989: ** statements too, but it never hurts to play the odds).
93990: */
93991: assert( sqlite3_mutex_held(db->mutex) );
93992: if( pSchema ){
93993: for(i=0; ALWAYS(i<db->nDb); i++){
93994: if( db->aDb[i].pSchema==pSchema ){
93995: break;
93996: }
93997: }
93998: assert( i>=0 && i<db->nDb );
93999: }
94000: return i;
94001: }
94002:
94003: /*
94004: ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
94005: */
94006: static int sqlite3Prepare(
94007: sqlite3 *db, /* Database handle. */
94008: const char *zSql, /* UTF-8 encoded SQL statement. */
94009: int nBytes, /* Length of zSql in bytes. */
94010: int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
94011: Vdbe *pReprepare, /* VM being reprepared */
94012: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
94013: const char **pzTail /* OUT: End of parsed string */
94014: ){
94015: Parse *pParse; /* Parsing context */
94016: char *zErrMsg = 0; /* Error message */
94017: int rc = SQLITE_OK; /* Result code */
94018: int i; /* Loop counter */
94019:
94020: /* Allocate the parsing context */
94021: pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
94022: if( pParse==0 ){
94023: rc = SQLITE_NOMEM;
94024: goto end_prepare;
94025: }
94026: pParse->pReprepare = pReprepare;
94027: assert( ppStmt && *ppStmt==0 );
94028: assert( !db->mallocFailed );
94029: assert( sqlite3_mutex_held(db->mutex) );
94030:
94031: /* Check to verify that it is possible to get a read lock on all
94032: ** database schemas. The inability to get a read lock indicates that
94033: ** some other database connection is holding a write-lock, which in
94034: ** turn means that the other connection has made uncommitted changes
94035: ** to the schema.
94036: **
94037: ** Were we to proceed and prepare the statement against the uncommitted
94038: ** schema changes and if those schema changes are subsequently rolled
94039: ** back and different changes are made in their place, then when this
94040: ** prepared statement goes to run the schema cookie would fail to detect
94041: ** the schema change. Disaster would follow.
94042: **
94043: ** This thread is currently holding mutexes on all Btrees (because
94044: ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it
94045: ** is not possible for another thread to start a new schema change
94046: ** while this routine is running. Hence, we do not need to hold
94047: ** locks on the schema, we just need to make sure nobody else is
94048: ** holding them.
94049: **
94050: ** Note that setting READ_UNCOMMITTED overrides most lock detection,
94051: ** but it does *not* override schema lock detection, so this all still
94052: ** works even if READ_UNCOMMITTED is set.
94053: */
94054: for(i=0; i<db->nDb; i++) {
94055: Btree *pBt = db->aDb[i].pBt;
94056: if( pBt ){
94057: assert( sqlite3BtreeHoldsMutex(pBt) );
94058: rc = sqlite3BtreeSchemaLocked(pBt);
94059: if( rc ){
94060: const char *zDb = db->aDb[i].zName;
94061: sqlite3Error(db, rc, "database schema is locked: %s", zDb);
94062: testcase( db->flags & SQLITE_ReadUncommitted );
94063: goto end_prepare;
94064: }
94065: }
94066: }
94067:
94068: sqlite3VtabUnlockList(db);
94069:
94070: pParse->db = db;
94071: pParse->nQueryLoop = (double)1;
94072: if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
94073: char *zSqlCopy;
94074: int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
94075: testcase( nBytes==mxLen );
94076: testcase( nBytes==mxLen+1 );
94077: if( nBytes>mxLen ){
94078: sqlite3Error(db, SQLITE_TOOBIG, "statement too long");
94079: rc = sqlite3ApiExit(db, SQLITE_TOOBIG);
94080: goto end_prepare;
94081: }
94082: zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
94083: if( zSqlCopy ){
94084: sqlite3RunParser(pParse, zSqlCopy, &zErrMsg);
94085: sqlite3DbFree(db, zSqlCopy);
94086: pParse->zTail = &zSql[pParse->zTail-zSqlCopy];
94087: }else{
94088: pParse->zTail = &zSql[nBytes];
94089: }
94090: }else{
94091: sqlite3RunParser(pParse, zSql, &zErrMsg);
94092: }
94093: assert( 1==(int)pParse->nQueryLoop );
94094:
94095: if( db->mallocFailed ){
94096: pParse->rc = SQLITE_NOMEM;
94097: }
94098: if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
94099: if( pParse->checkSchema ){
94100: schemaIsValid(pParse);
94101: }
94102: if( db->mallocFailed ){
94103: pParse->rc = SQLITE_NOMEM;
94104: }
94105: if( pzTail ){
94106: *pzTail = pParse->zTail;
94107: }
94108: rc = pParse->rc;
94109:
94110: #ifndef SQLITE_OMIT_EXPLAIN
94111: if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){
94112: static const char * const azColName[] = {
94113: "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
94114: "selectid", "order", "from", "detail"
94115: };
94116: int iFirst, mx;
94117: if( pParse->explain==2 ){
94118: sqlite3VdbeSetNumCols(pParse->pVdbe, 4);
94119: iFirst = 8;
94120: mx = 12;
94121: }else{
94122: sqlite3VdbeSetNumCols(pParse->pVdbe, 8);
94123: iFirst = 0;
94124: mx = 8;
94125: }
94126: for(i=iFirst; i<mx; i++){
94127: sqlite3VdbeSetColName(pParse->pVdbe, i-iFirst, COLNAME_NAME,
94128: azColName[i], SQLITE_STATIC);
94129: }
94130: }
94131: #endif
94132:
94133: assert( db->init.busy==0 || saveSqlFlag==0 );
94134: if( db->init.busy==0 ){
94135: Vdbe *pVdbe = pParse->pVdbe;
94136: sqlite3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag);
94137: }
94138: if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
94139: sqlite3VdbeFinalize(pParse->pVdbe);
94140: assert(!(*ppStmt));
94141: }else{
94142: *ppStmt = (sqlite3_stmt*)pParse->pVdbe;
94143: }
94144:
94145: if( zErrMsg ){
94146: sqlite3Error(db, rc, "%s", zErrMsg);
94147: sqlite3DbFree(db, zErrMsg);
94148: }else{
94149: sqlite3Error(db, rc, 0);
94150: }
94151:
94152: /* Delete any TriggerPrg structures allocated while parsing this statement. */
94153: while( pParse->pTriggerPrg ){
94154: TriggerPrg *pT = pParse->pTriggerPrg;
94155: pParse->pTriggerPrg = pT->pNext;
94156: sqlite3DbFree(db, pT);
94157: }
94158:
94159: end_prepare:
94160:
94161: sqlite3StackFree(db, pParse);
94162: rc = sqlite3ApiExit(db, rc);
94163: assert( (rc&db->errMask)==rc );
94164: return rc;
94165: }
94166: static int sqlite3LockAndPrepare(
94167: sqlite3 *db, /* Database handle. */
94168: const char *zSql, /* UTF-8 encoded SQL statement. */
94169: int nBytes, /* Length of zSql in bytes. */
94170: int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
94171: Vdbe *pOld, /* VM being reprepared */
94172: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
94173: const char **pzTail /* OUT: End of parsed string */
94174: ){
94175: int rc;
94176: assert( ppStmt!=0 );
94177: *ppStmt = 0;
94178: if( !sqlite3SafetyCheckOk(db) ){
94179: return SQLITE_MISUSE_BKPT;
94180: }
94181: sqlite3_mutex_enter(db->mutex);
94182: sqlite3BtreeEnterAll(db);
94183: rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
94184: if( rc==SQLITE_SCHEMA ){
94185: sqlite3_finalize(*ppStmt);
94186: rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
94187: }
94188: sqlite3BtreeLeaveAll(db);
94189: sqlite3_mutex_leave(db->mutex);
94190: return rc;
94191: }
94192:
94193: /*
94194: ** Rerun the compilation of a statement after a schema change.
94195: **
94196: ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
94197: ** if the statement cannot be recompiled because another connection has
94198: ** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error
94199: ** occurs, return SQLITE_SCHEMA.
94200: */
94201: SQLITE_PRIVATE int sqlite3Reprepare(Vdbe *p){
94202: int rc;
94203: sqlite3_stmt *pNew;
94204: const char *zSql;
94205: sqlite3 *db;
94206:
94207: assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
94208: zSql = sqlite3_sql((sqlite3_stmt *)p);
94209: assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */
94210: db = sqlite3VdbeDb(p);
94211: assert( sqlite3_mutex_held(db->mutex) );
94212: rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
94213: if( rc ){
94214: if( rc==SQLITE_NOMEM ){
94215: db->mallocFailed = 1;
94216: }
94217: assert( pNew==0 );
94218: return rc;
94219: }else{
94220: assert( pNew!=0 );
94221: }
94222: sqlite3VdbeSwap((Vdbe*)pNew, p);
94223: sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
94224: sqlite3VdbeResetStepResult((Vdbe*)pNew);
94225: sqlite3VdbeFinalize((Vdbe*)pNew);
94226: return SQLITE_OK;
94227: }
94228:
94229:
94230: /*
94231: ** Two versions of the official API. Legacy and new use. In the legacy
94232: ** version, the original SQL text is not saved in the prepared statement
94233: ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
94234: ** sqlite3_step(). In the new version, the original SQL text is retained
94235: ** and the statement is automatically recompiled if an schema change
94236: ** occurs.
94237: */
94238: SQLITE_API int sqlite3_prepare(
94239: sqlite3 *db, /* Database handle. */
94240: const char *zSql, /* UTF-8 encoded SQL statement. */
94241: int nBytes, /* Length of zSql in bytes. */
94242: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
94243: const char **pzTail /* OUT: End of parsed string */
94244: ){
94245: int rc;
94246: rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
94247: assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
94248: return rc;
94249: }
94250: SQLITE_API int sqlite3_prepare_v2(
94251: sqlite3 *db, /* Database handle. */
94252: const char *zSql, /* UTF-8 encoded SQL statement. */
94253: int nBytes, /* Length of zSql in bytes. */
94254: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
94255: const char **pzTail /* OUT: End of parsed string */
94256: ){
94257: int rc;
94258: rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail);
94259: assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
94260: return rc;
94261: }
94262:
94263:
94264: #ifndef SQLITE_OMIT_UTF16
94265: /*
94266: ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
94267: */
94268: static int sqlite3Prepare16(
94269: sqlite3 *db, /* Database handle. */
94270: const void *zSql, /* UTF-16 encoded SQL statement. */
94271: int nBytes, /* Length of zSql in bytes. */
94272: int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */
94273: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
94274: const void **pzTail /* OUT: End of parsed string */
94275: ){
94276: /* This function currently works by first transforming the UTF-16
94277: ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
94278: ** tricky bit is figuring out the pointer to return in *pzTail.
94279: */
94280: char *zSql8;
94281: const char *zTail8 = 0;
94282: int rc = SQLITE_OK;
94283:
94284: assert( ppStmt );
94285: *ppStmt = 0;
94286: if( !sqlite3SafetyCheckOk(db) ){
94287: return SQLITE_MISUSE_BKPT;
94288: }
94289: sqlite3_mutex_enter(db->mutex);
94290: zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
94291: if( zSql8 ){
94292: rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8);
94293: }
94294:
94295: if( zTail8 && pzTail ){
94296: /* If sqlite3_prepare returns a tail pointer, we calculate the
94297: ** equivalent pointer into the UTF-16 string by counting the unicode
94298: ** characters between zSql8 and zTail8, and then returning a pointer
94299: ** the same number of characters into the UTF-16 string.
94300: */
94301: int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
94302: *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
94303: }
94304: sqlite3DbFree(db, zSql8);
94305: rc = sqlite3ApiExit(db, rc);
94306: sqlite3_mutex_leave(db->mutex);
94307: return rc;
94308: }
94309:
94310: /*
94311: ** Two versions of the official API. Legacy and new use. In the legacy
94312: ** version, the original SQL text is not saved in the prepared statement
94313: ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
94314: ** sqlite3_step(). In the new version, the original SQL text is retained
94315: ** and the statement is automatically recompiled if an schema change
94316: ** occurs.
94317: */
94318: SQLITE_API int sqlite3_prepare16(
94319: sqlite3 *db, /* Database handle. */
94320: const void *zSql, /* UTF-16 encoded SQL statement. */
94321: int nBytes, /* Length of zSql in bytes. */
94322: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
94323: const void **pzTail /* OUT: End of parsed string */
94324: ){
94325: int rc;
94326: rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
94327: assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
94328: return rc;
94329: }
94330: SQLITE_API int sqlite3_prepare16_v2(
94331: sqlite3 *db, /* Database handle. */
94332: const void *zSql, /* UTF-16 encoded SQL statement. */
94333: int nBytes, /* Length of zSql in bytes. */
94334: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
94335: const void **pzTail /* OUT: End of parsed string */
94336: ){
94337: int rc;
94338: rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
94339: assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
94340: return rc;
94341: }
94342:
94343: #endif /* SQLITE_OMIT_UTF16 */
94344:
94345: /************** End of prepare.c *********************************************/
94346: /************** Begin file select.c ******************************************/
94347: /*
94348: ** 2001 September 15
94349: **
94350: ** The author disclaims copyright to this source code. In place of
94351: ** a legal notice, here is a blessing:
94352: **
94353: ** May you do good and not evil.
94354: ** May you find forgiveness for yourself and forgive others.
94355: ** May you share freely, never taking more than you give.
94356: **
94357: *************************************************************************
94358: ** This file contains C code routines that are called by the parser
94359: ** to handle SELECT statements in SQLite.
94360: */
94361:
94362:
94363: /*
94364: ** Delete all the content of a Select structure but do not deallocate
94365: ** the select structure itself.
94366: */
94367: static void clearSelect(sqlite3 *db, Select *p){
94368: sqlite3ExprListDelete(db, p->pEList);
94369: sqlite3SrcListDelete(db, p->pSrc);
94370: sqlite3ExprDelete(db, p->pWhere);
94371: sqlite3ExprListDelete(db, p->pGroupBy);
94372: sqlite3ExprDelete(db, p->pHaving);
94373: sqlite3ExprListDelete(db, p->pOrderBy);
94374: sqlite3SelectDelete(db, p->pPrior);
94375: sqlite3ExprDelete(db, p->pLimit);
94376: sqlite3ExprDelete(db, p->pOffset);
94377: }
94378:
94379: /*
94380: ** Initialize a SelectDest structure.
94381: */
94382: SQLITE_PRIVATE void sqlite3SelectDestInit(SelectDest *pDest, int eDest, int iParm){
94383: pDest->eDest = (u8)eDest;
94384: pDest->iParm = iParm;
94385: pDest->affinity = 0;
94386: pDest->iMem = 0;
94387: pDest->nMem = 0;
94388: }
94389:
94390:
94391: /*
94392: ** Allocate a new Select structure and return a pointer to that
94393: ** structure.
94394: */
94395: SQLITE_PRIVATE Select *sqlite3SelectNew(
94396: Parse *pParse, /* Parsing context */
94397: ExprList *pEList, /* which columns to include in the result */
94398: SrcList *pSrc, /* the FROM clause -- which tables to scan */
94399: Expr *pWhere, /* the WHERE clause */
94400: ExprList *pGroupBy, /* the GROUP BY clause */
94401: Expr *pHaving, /* the HAVING clause */
94402: ExprList *pOrderBy, /* the ORDER BY clause */
94403: int isDistinct, /* true if the DISTINCT keyword is present */
94404: Expr *pLimit, /* LIMIT value. NULL means not used */
94405: Expr *pOffset /* OFFSET value. NULL means no offset */
94406: ){
94407: Select *pNew;
94408: Select standin;
94409: sqlite3 *db = pParse->db;
94410: pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
94411: assert( db->mallocFailed || !pOffset || pLimit ); /* OFFSET implies LIMIT */
94412: if( pNew==0 ){
94413: assert( db->mallocFailed );
94414: pNew = &standin;
94415: memset(pNew, 0, sizeof(*pNew));
94416: }
94417: if( pEList==0 ){
94418: pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0));
94419: }
94420: pNew->pEList = pEList;
94421: pNew->pSrc = pSrc;
94422: pNew->pWhere = pWhere;
94423: pNew->pGroupBy = pGroupBy;
94424: pNew->pHaving = pHaving;
94425: pNew->pOrderBy = pOrderBy;
94426: pNew->selFlags = isDistinct ? SF_Distinct : 0;
94427: pNew->op = TK_SELECT;
94428: pNew->pLimit = pLimit;
94429: pNew->pOffset = pOffset;
94430: assert( pOffset==0 || pLimit!=0 );
94431: pNew->addrOpenEphm[0] = -1;
94432: pNew->addrOpenEphm[1] = -1;
94433: pNew->addrOpenEphm[2] = -1;
94434: if( db->mallocFailed ) {
94435: clearSelect(db, pNew);
94436: if( pNew!=&standin ) sqlite3DbFree(db, pNew);
94437: pNew = 0;
94438: }else{
94439: assert( pNew->pSrc!=0 || pParse->nErr>0 );
94440: }
94441: assert( pNew!=&standin );
94442: return pNew;
94443: }
94444:
94445: /*
94446: ** Delete the given Select structure and all of its substructures.
94447: */
94448: SQLITE_PRIVATE void sqlite3SelectDelete(sqlite3 *db, Select *p){
94449: if( p ){
94450: clearSelect(db, p);
94451: sqlite3DbFree(db, p);
94452: }
94453: }
94454:
94455: /*
94456: ** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the
94457: ** type of join. Return an integer constant that expresses that type
94458: ** in terms of the following bit values:
94459: **
94460: ** JT_INNER
94461: ** JT_CROSS
94462: ** JT_OUTER
94463: ** JT_NATURAL
94464: ** JT_LEFT
94465: ** JT_RIGHT
94466: **
94467: ** A full outer join is the combination of JT_LEFT and JT_RIGHT.
94468: **
94469: ** If an illegal or unsupported join type is seen, then still return
94470: ** a join type, but put an error in the pParse structure.
94471: */
94472: SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
94473: int jointype = 0;
94474: Token *apAll[3];
94475: Token *p;
94476: /* 0123456789 123456789 123456789 123 */
94477: static const char zKeyText[] = "naturaleftouterightfullinnercross";
94478: static const struct {
94479: u8 i; /* Beginning of keyword text in zKeyText[] */
94480: u8 nChar; /* Length of the keyword in characters */
94481: u8 code; /* Join type mask */
94482: } aKeyword[] = {
94483: /* natural */ { 0, 7, JT_NATURAL },
94484: /* left */ { 6, 4, JT_LEFT|JT_OUTER },
94485: /* outer */ { 10, 5, JT_OUTER },
94486: /* right */ { 14, 5, JT_RIGHT|JT_OUTER },
94487: /* full */ { 19, 4, JT_LEFT|JT_RIGHT|JT_OUTER },
94488: /* inner */ { 23, 5, JT_INNER },
94489: /* cross */ { 28, 5, JT_INNER|JT_CROSS },
94490: };
94491: int i, j;
94492: apAll[0] = pA;
94493: apAll[1] = pB;
94494: apAll[2] = pC;
94495: for(i=0; i<3 && apAll[i]; i++){
94496: p = apAll[i];
94497: for(j=0; j<ArraySize(aKeyword); j++){
94498: if( p->n==aKeyword[j].nChar
94499: && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
94500: jointype |= aKeyword[j].code;
94501: break;
94502: }
94503: }
94504: testcase( j==0 || j==1 || j==2 || j==3 || j==4 || j==5 || j==6 );
94505: if( j>=ArraySize(aKeyword) ){
94506: jointype |= JT_ERROR;
94507: break;
94508: }
94509: }
94510: if(
94511: (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) ||
94512: (jointype & JT_ERROR)!=0
94513: ){
94514: const char *zSp = " ";
94515: assert( pB!=0 );
94516: if( pC==0 ){ zSp++; }
94517: sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
94518: "%T %T%s%T", pA, pB, zSp, pC);
94519: jointype = JT_INNER;
94520: }else if( (jointype & JT_OUTER)!=0
94521: && (jointype & (JT_LEFT|JT_RIGHT))!=JT_LEFT ){
94522: sqlite3ErrorMsg(pParse,
94523: "RIGHT and FULL OUTER JOINs are not currently supported");
94524: jointype = JT_INNER;
94525: }
94526: return jointype;
94527: }
94528:
94529: /*
94530: ** Return the index of a column in a table. Return -1 if the column
94531: ** is not contained in the table.
94532: */
94533: static int columnIndex(Table *pTab, const char *zCol){
94534: int i;
94535: for(i=0; i<pTab->nCol; i++){
94536: if( sqlite3StrICmp(pTab->aCol[i].zName, zCol)==0 ) return i;
94537: }
94538: return -1;
94539: }
94540:
94541: /*
94542: ** Search the first N tables in pSrc, from left to right, looking for a
94543: ** table that has a column named zCol.
94544: **
94545: ** When found, set *piTab and *piCol to the table index and column index
94546: ** of the matching column and return TRUE.
94547: **
94548: ** If not found, return FALSE.
94549: */
94550: static int tableAndColumnIndex(
94551: SrcList *pSrc, /* Array of tables to search */
94552: int N, /* Number of tables in pSrc->a[] to search */
94553: const char *zCol, /* Name of the column we are looking for */
94554: int *piTab, /* Write index of pSrc->a[] here */
94555: int *piCol /* Write index of pSrc->a[*piTab].pTab->aCol[] here */
94556: ){
94557: int i; /* For looping over tables in pSrc */
94558: int iCol; /* Index of column matching zCol */
94559:
94560: assert( (piTab==0)==(piCol==0) ); /* Both or neither are NULL */
94561: for(i=0; i<N; i++){
94562: iCol = columnIndex(pSrc->a[i].pTab, zCol);
94563: if( iCol>=0 ){
94564: if( piTab ){
94565: *piTab = i;
94566: *piCol = iCol;
94567: }
94568: return 1;
94569: }
94570: }
94571: return 0;
94572: }
94573:
94574: /*
94575: ** This function is used to add terms implied by JOIN syntax to the
94576: ** WHERE clause expression of a SELECT statement. The new term, which
94577: ** is ANDed with the existing WHERE clause, is of the form:
94578: **
94579: ** (tab1.col1 = tab2.col2)
94580: **
94581: ** where tab1 is the iSrc'th table in SrcList pSrc and tab2 is the
94582: ** (iSrc+1)'th. Column col1 is column iColLeft of tab1, and col2 is
94583: ** column iColRight of tab2.
94584: */
94585: static void addWhereTerm(
94586: Parse *pParse, /* Parsing context */
94587: SrcList *pSrc, /* List of tables in FROM clause */
94588: int iLeft, /* Index of first table to join in pSrc */
94589: int iColLeft, /* Index of column in first table */
94590: int iRight, /* Index of second table in pSrc */
94591: int iColRight, /* Index of column in second table */
94592: int isOuterJoin, /* True if this is an OUTER join */
94593: Expr **ppWhere /* IN/OUT: The WHERE clause to add to */
94594: ){
94595: sqlite3 *db = pParse->db;
94596: Expr *pE1;
94597: Expr *pE2;
94598: Expr *pEq;
94599:
94600: assert( iLeft<iRight );
94601: assert( pSrc->nSrc>iRight );
94602: assert( pSrc->a[iLeft].pTab );
94603: assert( pSrc->a[iRight].pTab );
94604:
94605: pE1 = sqlite3CreateColumnExpr(db, pSrc, iLeft, iColLeft);
94606: pE2 = sqlite3CreateColumnExpr(db, pSrc, iRight, iColRight);
94607:
94608: pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2, 0);
94609: if( pEq && isOuterJoin ){
94610: ExprSetProperty(pEq, EP_FromJoin);
94611: assert( !ExprHasAnyProperty(pEq, EP_TokenOnly|EP_Reduced) );
94612: ExprSetIrreducible(pEq);
94613: pEq->iRightJoinTable = (i16)pE2->iTable;
94614: }
94615: *ppWhere = sqlite3ExprAnd(db, *ppWhere, pEq);
94616: }
94617:
94618: /*
94619: ** Set the EP_FromJoin property on all terms of the given expression.
94620: ** And set the Expr.iRightJoinTable to iTable for every term in the
94621: ** expression.
94622: **
94623: ** The EP_FromJoin property is used on terms of an expression to tell
94624: ** the LEFT OUTER JOIN processing logic that this term is part of the
94625: ** join restriction specified in the ON or USING clause and not a part
94626: ** of the more general WHERE clause. These terms are moved over to the
94627: ** WHERE clause during join processing but we need to remember that they
94628: ** originated in the ON or USING clause.
94629: **
94630: ** The Expr.iRightJoinTable tells the WHERE clause processing that the
94631: ** expression depends on table iRightJoinTable even if that table is not
94632: ** explicitly mentioned in the expression. That information is needed
94633: ** for cases like this:
94634: **
94635: ** SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.b AND t1.x=5
94636: **
94637: ** The where clause needs to defer the handling of the t1.x=5
94638: ** term until after the t2 loop of the join. In that way, a
94639: ** NULL t2 row will be inserted whenever t1.x!=5. If we do not
94640: ** defer the handling of t1.x=5, it will be processed immediately
94641: ** after the t1 loop and rows with t1.x!=5 will never appear in
94642: ** the output, which is incorrect.
94643: */
94644: static void setJoinExpr(Expr *p, int iTable){
94645: while( p ){
94646: ExprSetProperty(p, EP_FromJoin);
94647: assert( !ExprHasAnyProperty(p, EP_TokenOnly|EP_Reduced) );
94648: ExprSetIrreducible(p);
94649: p->iRightJoinTable = (i16)iTable;
94650: setJoinExpr(p->pLeft, iTable);
94651: p = p->pRight;
94652: }
94653: }
94654:
94655: /*
94656: ** This routine processes the join information for a SELECT statement.
94657: ** ON and USING clauses are converted into extra terms of the WHERE clause.
94658: ** NATURAL joins also create extra WHERE clause terms.
94659: **
94660: ** The terms of a FROM clause are contained in the Select.pSrc structure.
94661: ** The left most table is the first entry in Select.pSrc. The right-most
94662: ** table is the last entry. The join operator is held in the entry to
94663: ** the left. Thus entry 0 contains the join operator for the join between
94664: ** entries 0 and 1. Any ON or USING clauses associated with the join are
94665: ** also attached to the left entry.
94666: **
94667: ** This routine returns the number of errors encountered.
94668: */
94669: static int sqliteProcessJoin(Parse *pParse, Select *p){
94670: SrcList *pSrc; /* All tables in the FROM clause */
94671: int i, j; /* Loop counters */
94672: struct SrcList_item *pLeft; /* Left table being joined */
94673: struct SrcList_item *pRight; /* Right table being joined */
94674:
94675: pSrc = p->pSrc;
94676: pLeft = &pSrc->a[0];
94677: pRight = &pLeft[1];
94678: for(i=0; i<pSrc->nSrc-1; i++, pRight++, pLeft++){
94679: Table *pLeftTab = pLeft->pTab;
94680: Table *pRightTab = pRight->pTab;
94681: int isOuter;
94682:
94683: if( NEVER(pLeftTab==0 || pRightTab==0) ) continue;
94684: isOuter = (pRight->jointype & JT_OUTER)!=0;
94685:
94686: /* When the NATURAL keyword is present, add WHERE clause terms for
94687: ** every column that the two tables have in common.
94688: */
94689: if( pRight->jointype & JT_NATURAL ){
94690: if( pRight->pOn || pRight->pUsing ){
94691: sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
94692: "an ON or USING clause", 0);
94693: return 1;
94694: }
94695: for(j=0; j<pRightTab->nCol; j++){
94696: char *zName; /* Name of column in the right table */
94697: int iLeft; /* Matching left table */
94698: int iLeftCol; /* Matching column in the left table */
94699:
94700: zName = pRightTab->aCol[j].zName;
94701: if( tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol) ){
94702: addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
94703: isOuter, &p->pWhere);
94704: }
94705: }
94706: }
94707:
94708: /* Disallow both ON and USING clauses in the same join
94709: */
94710: if( pRight->pOn && pRight->pUsing ){
94711: sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
94712: "clauses in the same join");
94713: return 1;
94714: }
94715:
94716: /* Add the ON clause to the end of the WHERE clause, connected by
94717: ** an AND operator.
94718: */
94719: if( pRight->pOn ){
94720: if( isOuter ) setJoinExpr(pRight->pOn, pRight->iCursor);
94721: p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
94722: pRight->pOn = 0;
94723: }
94724:
94725: /* Create extra terms on the WHERE clause for each column named
94726: ** in the USING clause. Example: If the two tables to be joined are
94727: ** A and B and the USING clause names X, Y, and Z, then add this
94728: ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z
94729: ** Report an error if any column mentioned in the USING clause is
94730: ** not contained in both tables to be joined.
94731: */
94732: if( pRight->pUsing ){
94733: IdList *pList = pRight->pUsing;
94734: for(j=0; j<pList->nId; j++){
94735: char *zName; /* Name of the term in the USING clause */
94736: int iLeft; /* Table on the left with matching column name */
94737: int iLeftCol; /* Column number of matching column on the left */
94738: int iRightCol; /* Column number of matching column on the right */
94739:
94740: zName = pList->a[j].zName;
94741: iRightCol = columnIndex(pRightTab, zName);
94742: if( iRightCol<0
94743: || !tableAndColumnIndex(pSrc, i+1, zName, &iLeft, &iLeftCol)
94744: ){
94745: sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
94746: "not present in both tables", zName);
94747: return 1;
94748: }
94749: addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,
94750: isOuter, &p->pWhere);
94751: }
94752: }
94753: }
94754: return 0;
94755: }
94756:
94757: /*
94758: ** Insert code into "v" that will push the record on the top of the
94759: ** stack into the sorter.
94760: */
94761: static void pushOntoSorter(
94762: Parse *pParse, /* Parser context */
94763: ExprList *pOrderBy, /* The ORDER BY clause */
94764: Select *pSelect, /* The whole SELECT statement */
94765: int regData /* Register holding data to be sorted */
94766: ){
94767: Vdbe *v = pParse->pVdbe;
94768: int nExpr = pOrderBy->nExpr;
94769: int regBase = sqlite3GetTempRange(pParse, nExpr+2);
94770: int regRecord = sqlite3GetTempReg(pParse);
94771: int op;
94772: sqlite3ExprCacheClear(pParse);
94773: sqlite3ExprCodeExprList(pParse, pOrderBy, regBase, 0);
94774: sqlite3VdbeAddOp2(v, OP_Sequence, pOrderBy->iECursor, regBase+nExpr);
94775: sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+1, 1);
94776: sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nExpr + 2, regRecord);
94777: if( pSelect->selFlags & SF_UseSorter ){
94778: op = OP_SorterInsert;
94779: }else{
94780: op = OP_IdxInsert;
94781: }
94782: sqlite3VdbeAddOp2(v, op, pOrderBy->iECursor, regRecord);
94783: sqlite3ReleaseTempReg(pParse, regRecord);
94784: sqlite3ReleaseTempRange(pParse, regBase, nExpr+2);
94785: if( pSelect->iLimit ){
94786: int addr1, addr2;
94787: int iLimit;
94788: if( pSelect->iOffset ){
94789: iLimit = pSelect->iOffset+1;
94790: }else{
94791: iLimit = pSelect->iLimit;
94792: }
94793: addr1 = sqlite3VdbeAddOp1(v, OP_IfZero, iLimit);
94794: sqlite3VdbeAddOp2(v, OP_AddImm, iLimit, -1);
94795: addr2 = sqlite3VdbeAddOp0(v, OP_Goto);
94796: sqlite3VdbeJumpHere(v, addr1);
94797: sqlite3VdbeAddOp1(v, OP_Last, pOrderBy->iECursor);
94798: sqlite3VdbeAddOp1(v, OP_Delete, pOrderBy->iECursor);
94799: sqlite3VdbeJumpHere(v, addr2);
94800: }
94801: }
94802:
94803: /*
94804: ** Add code to implement the OFFSET
94805: */
94806: static void codeOffset(
94807: Vdbe *v, /* Generate code into this VM */
94808: Select *p, /* The SELECT statement being coded */
94809: int iContinue /* Jump here to skip the current record */
94810: ){
94811: if( p->iOffset && iContinue!=0 ){
94812: int addr;
94813: sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
94814: addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
94815: sqlite3VdbeAddOp2(v, OP_Goto, 0, iContinue);
94816: VdbeComment((v, "skip OFFSET records"));
94817: sqlite3VdbeJumpHere(v, addr);
94818: }
94819: }
94820:
94821: /*
94822: ** Add code that will check to make sure the N registers starting at iMem
94823: ** form a distinct entry. iTab is a sorting index that holds previously
94824: ** seen combinations of the N values. A new entry is made in iTab
94825: ** if the current N values are new.
94826: **
94827: ** A jump to addrRepeat is made and the N+1 values are popped from the
94828: ** stack if the top N elements are not distinct.
94829: */
94830: static void codeDistinct(
94831: Parse *pParse, /* Parsing and code generating context */
94832: int iTab, /* A sorting index used to test for distinctness */
94833: int addrRepeat, /* Jump to here if not distinct */
94834: int N, /* Number of elements */
94835: int iMem /* First element */
94836: ){
94837: Vdbe *v;
94838: int r1;
94839:
94840: v = pParse->pVdbe;
94841: r1 = sqlite3GetTempReg(pParse);
94842: sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N);
94843: sqlite3VdbeAddOp3(v, OP_MakeRecord, iMem, N, r1);
94844: sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1);
94845: sqlite3ReleaseTempReg(pParse, r1);
94846: }
94847:
94848: #ifndef SQLITE_OMIT_SUBQUERY
94849: /*
94850: ** Generate an error message when a SELECT is used within a subexpression
94851: ** (example: "a IN (SELECT * FROM table)") but it has more than 1 result
94852: ** column. We do this in a subroutine because the error used to occur
94853: ** in multiple places. (The error only occurs in one place now, but we
94854: ** retain the subroutine to minimize code disruption.)
94855: */
94856: static int checkForMultiColumnSelectError(
94857: Parse *pParse, /* Parse context. */
94858: SelectDest *pDest, /* Destination of SELECT results */
94859: int nExpr /* Number of result columns returned by SELECT */
94860: ){
94861: int eDest = pDest->eDest;
94862: if( nExpr>1 && (eDest==SRT_Mem || eDest==SRT_Set) ){
94863: sqlite3ErrorMsg(pParse, "only a single result allowed for "
94864: "a SELECT that is part of an expression");
94865: return 1;
94866: }else{
94867: return 0;
94868: }
94869: }
94870: #endif
94871:
94872: /*
94873: ** This routine generates the code for the inside of the inner loop
94874: ** of a SELECT.
94875: **
94876: ** If srcTab and nColumn are both zero, then the pEList expressions
94877: ** are evaluated in order to get the data for this row. If nColumn>0
94878: ** then data is pulled from srcTab and pEList is used only to get the
94879: ** datatypes for each column.
94880: */
94881: static void selectInnerLoop(
94882: Parse *pParse, /* The parser context */
94883: Select *p, /* The complete select statement being coded */
94884: ExprList *pEList, /* List of values being extracted */
94885: int srcTab, /* Pull data from this table */
94886: int nColumn, /* Number of columns in the source table */
94887: ExprList *pOrderBy, /* If not NULL, sort results using this key */
94888: int distinct, /* If >=0, make sure results are distinct */
94889: SelectDest *pDest, /* How to dispose of the results */
94890: int iContinue, /* Jump here to continue with next row */
94891: int iBreak /* Jump here to break out of the inner loop */
94892: ){
94893: Vdbe *v = pParse->pVdbe;
94894: int i;
94895: int hasDistinct; /* True if the DISTINCT keyword is present */
94896: int regResult; /* Start of memory holding result set */
94897: int eDest = pDest->eDest; /* How to dispose of results */
94898: int iParm = pDest->iParm; /* First argument to disposal method */
94899: int nResultCol; /* Number of result columns */
94900:
94901: assert( v );
94902: if( NEVER(v==0) ) return;
94903: assert( pEList!=0 );
94904: hasDistinct = distinct>=0;
94905: if( pOrderBy==0 && !hasDistinct ){
94906: codeOffset(v, p, iContinue);
94907: }
94908:
94909: /* Pull the requested columns.
94910: */
94911: if( nColumn>0 ){
94912: nResultCol = nColumn;
94913: }else{
94914: nResultCol = pEList->nExpr;
94915: }
94916: if( pDest->iMem==0 ){
94917: pDest->iMem = pParse->nMem+1;
94918: pDest->nMem = nResultCol;
94919: pParse->nMem += nResultCol;
94920: }else{
94921: assert( pDest->nMem==nResultCol );
94922: }
94923: regResult = pDest->iMem;
94924: if( nColumn>0 ){
94925: for(i=0; i<nColumn; i++){
94926: sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
94927: }
94928: }else if( eDest!=SRT_Exists ){
94929: /* If the destination is an EXISTS(...) expression, the actual
94930: ** values returned by the SELECT are not required.
94931: */
94932: sqlite3ExprCacheClear(pParse);
94933: sqlite3ExprCodeExprList(pParse, pEList, regResult, eDest==SRT_Output);
94934: }
94935: nColumn = nResultCol;
94936:
94937: /* If the DISTINCT keyword was present on the SELECT statement
94938: ** and this row has been seen before, then do not make this row
94939: ** part of the result.
94940: */
94941: if( hasDistinct ){
94942: assert( pEList!=0 );
94943: assert( pEList->nExpr==nColumn );
94944: codeDistinct(pParse, distinct, iContinue, nColumn, regResult);
94945: if( pOrderBy==0 ){
94946: codeOffset(v, p, iContinue);
94947: }
94948: }
94949:
94950: switch( eDest ){
94951: /* In this mode, write each query result to the key of the temporary
94952: ** table iParm.
94953: */
94954: #ifndef SQLITE_OMIT_COMPOUND_SELECT
94955: case SRT_Union: {
94956: int r1;
94957: r1 = sqlite3GetTempReg(pParse);
94958: sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
94959: sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
94960: sqlite3ReleaseTempReg(pParse, r1);
94961: break;
94962: }
94963:
94964: /* Construct a record from the query result, but instead of
94965: ** saving that record, use it as a key to delete elements from
94966: ** the temporary table iParm.
94967: */
94968: case SRT_Except: {
94969: sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nColumn);
94970: break;
94971: }
94972: #endif
94973:
94974: /* Store the result as data using a unique key.
94975: */
94976: case SRT_Table:
94977: case SRT_EphemTab: {
94978: int r1 = sqlite3GetTempReg(pParse);
94979: testcase( eDest==SRT_Table );
94980: testcase( eDest==SRT_EphemTab );
94981: sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
94982: if( pOrderBy ){
94983: pushOntoSorter(pParse, pOrderBy, p, r1);
94984: }else{
94985: int r2 = sqlite3GetTempReg(pParse);
94986: sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
94987: sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
94988: sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
94989: sqlite3ReleaseTempReg(pParse, r2);
94990: }
94991: sqlite3ReleaseTempReg(pParse, r1);
94992: break;
94993: }
94994:
94995: #ifndef SQLITE_OMIT_SUBQUERY
94996: /* If we are creating a set for an "expr IN (SELECT ...)" construct,
94997: ** then there should be a single item on the stack. Write this
94998: ** item into the set table with bogus data.
94999: */
95000: case SRT_Set: {
95001: assert( nColumn==1 );
95002: p->affinity = sqlite3CompareAffinity(pEList->a[0].pExpr, pDest->affinity);
95003: if( pOrderBy ){
95004: /* At first glance you would think we could optimize out the
95005: ** ORDER BY in this case since the order of entries in the set
95006: ** does not matter. But there might be a LIMIT clause, in which
95007: ** case the order does matter */
95008: pushOntoSorter(pParse, pOrderBy, p, regResult);
95009: }else{
95010: int r1 = sqlite3GetTempReg(pParse);
95011: sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, 1, r1, &p->affinity, 1);
95012: sqlite3ExprCacheAffinityChange(pParse, regResult, 1);
95013: sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, r1);
95014: sqlite3ReleaseTempReg(pParse, r1);
95015: }
95016: break;
95017: }
95018:
95019: /* If any row exist in the result set, record that fact and abort.
95020: */
95021: case SRT_Exists: {
95022: sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
95023: /* The LIMIT clause will terminate the loop for us */
95024: break;
95025: }
95026:
95027: /* If this is a scalar select that is part of an expression, then
95028: ** store the results in the appropriate memory cell and break out
95029: ** of the scan loop.
95030: */
95031: case SRT_Mem: {
95032: assert( nColumn==1 );
95033: if( pOrderBy ){
95034: pushOntoSorter(pParse, pOrderBy, p, regResult);
95035: }else{
95036: sqlite3ExprCodeMove(pParse, regResult, iParm, 1);
95037: /* The LIMIT clause will jump out of the loop for us */
95038: }
95039: break;
95040: }
95041: #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
95042:
95043: /* Send the data to the callback function or to a subroutine. In the
95044: ** case of a subroutine, the subroutine itself is responsible for
95045: ** popping the data from the stack.
95046: */
95047: case SRT_Coroutine:
95048: case SRT_Output: {
95049: testcase( eDest==SRT_Coroutine );
95050: testcase( eDest==SRT_Output );
95051: if( pOrderBy ){
95052: int r1 = sqlite3GetTempReg(pParse);
95053: sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nColumn, r1);
95054: pushOntoSorter(pParse, pOrderBy, p, r1);
95055: sqlite3ReleaseTempReg(pParse, r1);
95056: }else if( eDest==SRT_Coroutine ){
95057: sqlite3VdbeAddOp1(v, OP_Yield, pDest->iParm);
95058: }else{
95059: sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nColumn);
95060: sqlite3ExprCacheAffinityChange(pParse, regResult, nColumn);
95061: }
95062: break;
95063: }
95064:
95065: #if !defined(SQLITE_OMIT_TRIGGER)
95066: /* Discard the results. This is used for SELECT statements inside
95067: ** the body of a TRIGGER. The purpose of such selects is to call
95068: ** user-defined functions that have side effects. We do not care
95069: ** about the actual results of the select.
95070: */
95071: default: {
95072: assert( eDest==SRT_Discard );
95073: break;
95074: }
95075: #endif
95076: }
95077:
95078: /* Jump to the end of the loop if the LIMIT is reached. Except, if
95079: ** there is a sorter, in which case the sorter has already limited
95080: ** the output for us.
95081: */
95082: if( pOrderBy==0 && p->iLimit ){
95083: sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1);
95084: }
95085: }
95086:
95087: /*
95088: ** Given an expression list, generate a KeyInfo structure that records
95089: ** the collating sequence for each expression in that expression list.
95090: **
95091: ** If the ExprList is an ORDER BY or GROUP BY clause then the resulting
95092: ** KeyInfo structure is appropriate for initializing a virtual index to
95093: ** implement that clause. If the ExprList is the result set of a SELECT
95094: ** then the KeyInfo structure is appropriate for initializing a virtual
95095: ** index to implement a DISTINCT test.
95096: **
95097: ** Space to hold the KeyInfo structure is obtain from malloc. The calling
95098: ** function is responsible for seeing that this structure is eventually
95099: ** freed. Add the KeyInfo structure to the P4 field of an opcode using
95100: ** P4_KEYINFO_HANDOFF is the usual way of dealing with this.
95101: */
95102: static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
95103: sqlite3 *db = pParse->db;
95104: int nExpr;
95105: KeyInfo *pInfo;
95106: struct ExprList_item *pItem;
95107: int i;
95108:
95109: nExpr = pList->nExpr;
95110: pInfo = sqlite3DbMallocZero(db, sizeof(*pInfo) + nExpr*(sizeof(CollSeq*)+1) );
95111: if( pInfo ){
95112: pInfo->aSortOrder = (u8*)&pInfo->aColl[nExpr];
95113: pInfo->nField = (u16)nExpr;
95114: pInfo->enc = ENC(db);
95115: pInfo->db = db;
95116: for(i=0, pItem=pList->a; i<nExpr; i++, pItem++){
95117: CollSeq *pColl;
95118: pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
95119: if( !pColl ){
95120: pColl = db->pDfltColl;
95121: }
95122: pInfo->aColl[i] = pColl;
95123: pInfo->aSortOrder[i] = pItem->sortOrder;
95124: }
95125: }
95126: return pInfo;
95127: }
95128:
95129: #ifndef SQLITE_OMIT_COMPOUND_SELECT
95130: /*
95131: ** Name of the connection operator, used for error messages.
95132: */
95133: static const char *selectOpName(int id){
95134: char *z;
95135: switch( id ){
95136: case TK_ALL: z = "UNION ALL"; break;
95137: case TK_INTERSECT: z = "INTERSECT"; break;
95138: case TK_EXCEPT: z = "EXCEPT"; break;
95139: default: z = "UNION"; break;
95140: }
95141: return z;
95142: }
95143: #endif /* SQLITE_OMIT_COMPOUND_SELECT */
95144:
95145: #ifndef SQLITE_OMIT_EXPLAIN
95146: /*
95147: ** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
95148: ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
95149: ** where the caption is of the form:
95150: **
95151: ** "USE TEMP B-TREE FOR xxx"
95152: **
95153: ** where xxx is one of "DISTINCT", "ORDER BY" or "GROUP BY". Exactly which
95154: ** is determined by the zUsage argument.
95155: */
95156: static void explainTempTable(Parse *pParse, const char *zUsage){
95157: if( pParse->explain==2 ){
95158: Vdbe *v = pParse->pVdbe;
95159: char *zMsg = sqlite3MPrintf(pParse->db, "USE TEMP B-TREE FOR %s", zUsage);
95160: sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
95161: }
95162: }
95163:
95164: /*
95165: ** Assign expression b to lvalue a. A second, no-op, version of this macro
95166: ** is provided when SQLITE_OMIT_EXPLAIN is defined. This allows the code
95167: ** in sqlite3Select() to assign values to structure member variables that
95168: ** only exist if SQLITE_OMIT_EXPLAIN is not defined without polluting the
95169: ** code with #ifndef directives.
95170: */
95171: # define explainSetInteger(a, b) a = b
95172:
95173: #else
95174: /* No-op versions of the explainXXX() functions and macros. */
95175: # define explainTempTable(y,z)
95176: # define explainSetInteger(y,z)
95177: #endif
95178:
95179: #if !defined(SQLITE_OMIT_EXPLAIN) && !defined(SQLITE_OMIT_COMPOUND_SELECT)
95180: /*
95181: ** Unless an "EXPLAIN QUERY PLAN" command is being processed, this function
95182: ** is a no-op. Otherwise, it adds a single row of output to the EQP result,
95183: ** where the caption is of one of the two forms:
95184: **
95185: ** "COMPOSITE SUBQUERIES iSub1 and iSub2 (op)"
95186: ** "COMPOSITE SUBQUERIES iSub1 and iSub2 USING TEMP B-TREE (op)"
95187: **
95188: ** where iSub1 and iSub2 are the integers passed as the corresponding
95189: ** function parameters, and op is the text representation of the parameter
95190: ** of the same name. The parameter "op" must be one of TK_UNION, TK_EXCEPT,
95191: ** TK_INTERSECT or TK_ALL. The first form is used if argument bUseTmp is
95192: ** false, or the second form if it is true.
95193: */
95194: static void explainComposite(
95195: Parse *pParse, /* Parse context */
95196: int op, /* One of TK_UNION, TK_EXCEPT etc. */
95197: int iSub1, /* Subquery id 1 */
95198: int iSub2, /* Subquery id 2 */
95199: int bUseTmp /* True if a temp table was used */
95200: ){
95201: assert( op==TK_UNION || op==TK_EXCEPT || op==TK_INTERSECT || op==TK_ALL );
95202: if( pParse->explain==2 ){
95203: Vdbe *v = pParse->pVdbe;
95204: char *zMsg = sqlite3MPrintf(
95205: pParse->db, "COMPOUND SUBQUERIES %d AND %d %s(%s)", iSub1, iSub2,
95206: bUseTmp?"USING TEMP B-TREE ":"", selectOpName(op)
95207: );
95208: sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
95209: }
95210: }
95211: #else
95212: /* No-op versions of the explainXXX() functions and macros. */
95213: # define explainComposite(v,w,x,y,z)
95214: #endif
95215:
95216: /*
95217: ** If the inner loop was generated using a non-null pOrderBy argument,
95218: ** then the results were placed in a sorter. After the loop is terminated
95219: ** we need to run the sorter and output the results. The following
95220: ** routine generates the code needed to do that.
95221: */
95222: static void generateSortTail(
95223: Parse *pParse, /* Parsing context */
95224: Select *p, /* The SELECT statement */
95225: Vdbe *v, /* Generate code into this VDBE */
95226: int nColumn, /* Number of columns of data */
95227: SelectDest *pDest /* Write the sorted results here */
95228: ){
95229: int addrBreak = sqlite3VdbeMakeLabel(v); /* Jump here to exit loop */
95230: int addrContinue = sqlite3VdbeMakeLabel(v); /* Jump here for next cycle */
95231: int addr;
95232: int iTab;
95233: int pseudoTab = 0;
95234: ExprList *pOrderBy = p->pOrderBy;
95235:
95236: int eDest = pDest->eDest;
95237: int iParm = pDest->iParm;
95238:
95239: int regRow;
95240: int regRowid;
95241:
95242: iTab = pOrderBy->iECursor;
95243: regRow = sqlite3GetTempReg(pParse);
95244: if( eDest==SRT_Output || eDest==SRT_Coroutine ){
95245: pseudoTab = pParse->nTab++;
95246: sqlite3VdbeAddOp3(v, OP_OpenPseudo, pseudoTab, regRow, nColumn);
95247: regRowid = 0;
95248: }else{
95249: regRowid = sqlite3GetTempReg(pParse);
95250: }
95251: if( p->selFlags & SF_UseSorter ){
95252: int regSortOut = ++pParse->nMem;
95253: int ptab2 = pParse->nTab++;
95254: sqlite3VdbeAddOp3(v, OP_OpenPseudo, ptab2, regSortOut, pOrderBy->nExpr+2);
95255: addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
95256: codeOffset(v, p, addrContinue);
95257: sqlite3VdbeAddOp2(v, OP_SorterData, iTab, regSortOut);
95258: sqlite3VdbeAddOp3(v, OP_Column, ptab2, pOrderBy->nExpr+1, regRow);
95259: sqlite3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
95260: }else{
95261: addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak);
95262: codeOffset(v, p, addrContinue);
95263: sqlite3VdbeAddOp3(v, OP_Column, iTab, pOrderBy->nExpr+1, regRow);
95264: }
95265: switch( eDest ){
95266: case SRT_Table:
95267: case SRT_EphemTab: {
95268: testcase( eDest==SRT_Table );
95269: testcase( eDest==SRT_EphemTab );
95270: sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
95271: sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
95272: sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
95273: break;
95274: }
95275: #ifndef SQLITE_OMIT_SUBQUERY
95276: case SRT_Set: {
95277: assert( nColumn==1 );
95278: sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid, &p->affinity, 1);
95279: sqlite3ExprCacheAffinityChange(pParse, regRow, 1);
95280: sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRowid);
95281: break;
95282: }
95283: case SRT_Mem: {
95284: assert( nColumn==1 );
95285: sqlite3ExprCodeMove(pParse, regRow, iParm, 1);
95286: /* The LIMIT clause will terminate the loop for us */
95287: break;
95288: }
95289: #endif
95290: default: {
95291: int i;
95292: assert( eDest==SRT_Output || eDest==SRT_Coroutine );
95293: testcase( eDest==SRT_Output );
95294: testcase( eDest==SRT_Coroutine );
95295: for(i=0; i<nColumn; i++){
95296: assert( regRow!=pDest->iMem+i );
95297: sqlite3VdbeAddOp3(v, OP_Column, pseudoTab, i, pDest->iMem+i);
95298: if( i==0 ){
95299: sqlite3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
95300: }
95301: }
95302: if( eDest==SRT_Output ){
95303: sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iMem, nColumn);
95304: sqlite3ExprCacheAffinityChange(pParse, pDest->iMem, nColumn);
95305: }else{
95306: sqlite3VdbeAddOp1(v, OP_Yield, pDest->iParm);
95307: }
95308: break;
95309: }
95310: }
95311: sqlite3ReleaseTempReg(pParse, regRow);
95312: sqlite3ReleaseTempReg(pParse, regRowid);
95313:
95314: /* The bottom of the loop
95315: */
95316: sqlite3VdbeResolveLabel(v, addrContinue);
95317: if( p->selFlags & SF_UseSorter ){
95318: sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr);
95319: }else{
95320: sqlite3VdbeAddOp2(v, OP_Next, iTab, addr);
95321: }
95322: sqlite3VdbeResolveLabel(v, addrBreak);
95323: if( eDest==SRT_Output || eDest==SRT_Coroutine ){
95324: sqlite3VdbeAddOp2(v, OP_Close, pseudoTab, 0);
95325: }
95326: }
95327:
95328: /*
95329: ** Return a pointer to a string containing the 'declaration type' of the
95330: ** expression pExpr. The string may be treated as static by the caller.
95331: **
95332: ** The declaration type is the exact datatype definition extracted from the
95333: ** original CREATE TABLE statement if the expression is a column. The
95334: ** declaration type for a ROWID field is INTEGER. Exactly when an expression
95335: ** is considered a column can be complex in the presence of subqueries. The
95336: ** result-set expression in all of the following SELECT statements is
95337: ** considered a column by this function.
95338: **
95339: ** SELECT col FROM tbl;
95340: ** SELECT (SELECT col FROM tbl;
95341: ** SELECT (SELECT col FROM tbl);
95342: ** SELECT abc FROM (SELECT col AS abc FROM tbl);
95343: **
95344: ** The declaration type for any expression other than a column is NULL.
95345: */
95346: static const char *columnType(
95347: NameContext *pNC,
95348: Expr *pExpr,
95349: const char **pzOriginDb,
95350: const char **pzOriginTab,
95351: const char **pzOriginCol
95352: ){
95353: char const *zType = 0;
95354: char const *zOriginDb = 0;
95355: char const *zOriginTab = 0;
95356: char const *zOriginCol = 0;
95357: int j;
95358: if( NEVER(pExpr==0) || pNC->pSrcList==0 ) return 0;
95359:
95360: switch( pExpr->op ){
95361: case TK_AGG_COLUMN:
95362: case TK_COLUMN: {
95363: /* The expression is a column. Locate the table the column is being
95364: ** extracted from in NameContext.pSrcList. This table may be real
95365: ** database table or a subquery.
95366: */
95367: Table *pTab = 0; /* Table structure column is extracted from */
95368: Select *pS = 0; /* Select the column is extracted from */
95369: int iCol = pExpr->iColumn; /* Index of column in pTab */
95370: testcase( pExpr->op==TK_AGG_COLUMN );
95371: testcase( pExpr->op==TK_COLUMN );
95372: while( pNC && !pTab ){
95373: SrcList *pTabList = pNC->pSrcList;
95374: for(j=0;j<pTabList->nSrc && pTabList->a[j].iCursor!=pExpr->iTable;j++);
95375: if( j<pTabList->nSrc ){
95376: pTab = pTabList->a[j].pTab;
95377: pS = pTabList->a[j].pSelect;
95378: }else{
95379: pNC = pNC->pNext;
95380: }
95381: }
95382:
95383: if( pTab==0 ){
95384: /* At one time, code such as "SELECT new.x" within a trigger would
95385: ** cause this condition to run. Since then, we have restructured how
95386: ** trigger code is generated and so this condition is no longer
95387: ** possible. However, it can still be true for statements like
95388: ** the following:
95389: **
95390: ** CREATE TABLE t1(col INTEGER);
95391: ** SELECT (SELECT t1.col) FROM FROM t1;
95392: **
95393: ** when columnType() is called on the expression "t1.col" in the
95394: ** sub-select. In this case, set the column type to NULL, even
95395: ** though it should really be "INTEGER".
95396: **
95397: ** This is not a problem, as the column type of "t1.col" is never
95398: ** used. When columnType() is called on the expression
95399: ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
95400: ** branch below. */
95401: break;
95402: }
95403:
95404: assert( pTab && pExpr->pTab==pTab );
95405: if( pS ){
95406: /* The "table" is actually a sub-select or a view in the FROM clause
95407: ** of the SELECT statement. Return the declaration type and origin
95408: ** data for the result-set column of the sub-select.
95409: */
95410: if( iCol>=0 && ALWAYS(iCol<pS->pEList->nExpr) ){
95411: /* If iCol is less than zero, then the expression requests the
95412: ** rowid of the sub-select or view. This expression is legal (see
95413: ** test case misc2.2.2) - it always evaluates to NULL.
95414: */
95415: NameContext sNC;
95416: Expr *p = pS->pEList->a[iCol].pExpr;
95417: sNC.pSrcList = pS->pSrc;
95418: sNC.pNext = pNC;
95419: sNC.pParse = pNC->pParse;
95420: zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol);
95421: }
95422: }else if( ALWAYS(pTab->pSchema) ){
95423: /* A real table */
95424: assert( !pS );
95425: if( iCol<0 ) iCol = pTab->iPKey;
95426: assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95427: if( iCol<0 ){
95428: zType = "INTEGER";
95429: zOriginCol = "rowid";
95430: }else{
95431: zType = pTab->aCol[iCol].zType;
95432: zOriginCol = pTab->aCol[iCol].zName;
95433: }
95434: zOriginTab = pTab->zName;
95435: if( pNC->pParse ){
95436: int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
95437: zOriginDb = pNC->pParse->db->aDb[iDb].zName;
95438: }
95439: }
95440: break;
95441: }
95442: #ifndef SQLITE_OMIT_SUBQUERY
95443: case TK_SELECT: {
95444: /* The expression is a sub-select. Return the declaration type and
95445: ** origin info for the single column in the result set of the SELECT
95446: ** statement.
95447: */
95448: NameContext sNC;
95449: Select *pS = pExpr->x.pSelect;
95450: Expr *p = pS->pEList->a[0].pExpr;
95451: assert( ExprHasProperty(pExpr, EP_xIsSelect) );
95452: sNC.pSrcList = pS->pSrc;
95453: sNC.pNext = pNC;
95454: sNC.pParse = pNC->pParse;
95455: zType = columnType(&sNC, p, &zOriginDb, &zOriginTab, &zOriginCol);
95456: break;
95457: }
95458: #endif
95459: }
95460:
95461: if( pzOriginDb ){
95462: assert( pzOriginTab && pzOriginCol );
95463: *pzOriginDb = zOriginDb;
95464: *pzOriginTab = zOriginTab;
95465: *pzOriginCol = zOriginCol;
95466: }
95467: return zType;
95468: }
95469:
95470: /*
95471: ** Generate code that will tell the VDBE the declaration types of columns
95472: ** in the result set.
95473: */
95474: static void generateColumnTypes(
95475: Parse *pParse, /* Parser context */
95476: SrcList *pTabList, /* List of tables */
95477: ExprList *pEList /* Expressions defining the result set */
95478: ){
95479: #ifndef SQLITE_OMIT_DECLTYPE
95480: Vdbe *v = pParse->pVdbe;
95481: int i;
95482: NameContext sNC;
95483: sNC.pSrcList = pTabList;
95484: sNC.pParse = pParse;
95485: for(i=0; i<pEList->nExpr; i++){
95486: Expr *p = pEList->a[i].pExpr;
95487: const char *zType;
95488: #ifdef SQLITE_ENABLE_COLUMN_METADATA
95489: const char *zOrigDb = 0;
95490: const char *zOrigTab = 0;
95491: const char *zOrigCol = 0;
95492: zType = columnType(&sNC, p, &zOrigDb, &zOrigTab, &zOrigCol);
95493:
95494: /* The vdbe must make its own copy of the column-type and other
95495: ** column specific strings, in case the schema is reset before this
95496: ** virtual machine is deleted.
95497: */
95498: sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT);
95499: sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT);
95500: sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT);
95501: #else
95502: zType = columnType(&sNC, p, 0, 0, 0);
95503: #endif
95504: sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT);
95505: }
95506: #endif /* SQLITE_OMIT_DECLTYPE */
95507: }
95508:
95509: /*
95510: ** Generate code that will tell the VDBE the names of columns
95511: ** in the result set. This information is used to provide the
95512: ** azCol[] values in the callback.
95513: */
95514: static void generateColumnNames(
95515: Parse *pParse, /* Parser context */
95516: SrcList *pTabList, /* List of tables */
95517: ExprList *pEList /* Expressions defining the result set */
95518: ){
95519: Vdbe *v = pParse->pVdbe;
95520: int i, j;
95521: sqlite3 *db = pParse->db;
95522: int fullNames, shortNames;
95523:
95524: #ifndef SQLITE_OMIT_EXPLAIN
95525: /* If this is an EXPLAIN, skip this step */
95526: if( pParse->explain ){
95527: return;
95528: }
95529: #endif
95530:
95531: if( pParse->colNamesSet || NEVER(v==0) || db->mallocFailed ) return;
95532: pParse->colNamesSet = 1;
95533: fullNames = (db->flags & SQLITE_FullColNames)!=0;
95534: shortNames = (db->flags & SQLITE_ShortColNames)!=0;
95535: sqlite3VdbeSetNumCols(v, pEList->nExpr);
95536: for(i=0; i<pEList->nExpr; i++){
95537: Expr *p;
95538: p = pEList->a[i].pExpr;
95539: if( NEVER(p==0) ) continue;
95540: if( pEList->a[i].zName ){
95541: char *zName = pEList->a[i].zName;
95542: sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
95543: }else if( (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN) && pTabList ){
95544: Table *pTab;
95545: char *zCol;
95546: int iCol = p->iColumn;
95547: for(j=0; ALWAYS(j<pTabList->nSrc); j++){
95548: if( pTabList->a[j].iCursor==p->iTable ) break;
95549: }
95550: assert( j<pTabList->nSrc );
95551: pTab = pTabList->a[j].pTab;
95552: if( iCol<0 ) iCol = pTab->iPKey;
95553: assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
95554: if( iCol<0 ){
95555: zCol = "rowid";
95556: }else{
95557: zCol = pTab->aCol[iCol].zName;
95558: }
95559: if( !shortNames && !fullNames ){
95560: sqlite3VdbeSetColName(v, i, COLNAME_NAME,
95561: sqlite3DbStrDup(db, pEList->a[i].zSpan), SQLITE_DYNAMIC);
95562: }else if( fullNames ){
95563: char *zName = 0;
95564: zName = sqlite3MPrintf(db, "%s.%s", pTab->zName, zCol);
95565: sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
95566: }else{
95567: sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT);
95568: }
95569: }else{
95570: sqlite3VdbeSetColName(v, i, COLNAME_NAME,
95571: sqlite3DbStrDup(db, pEList->a[i].zSpan), SQLITE_DYNAMIC);
95572: }
95573: }
95574: generateColumnTypes(pParse, pTabList, pEList);
95575: }
95576:
95577: /*
95578: ** Given a an expression list (which is really the list of expressions
95579: ** that form the result set of a SELECT statement) compute appropriate
95580: ** column names for a table that would hold the expression list.
95581: **
95582: ** All column names will be unique.
95583: **
95584: ** Only the column names are computed. Column.zType, Column.zColl,
95585: ** and other fields of Column are zeroed.
95586: **
95587: ** Return SQLITE_OK on success. If a memory allocation error occurs,
95588: ** store NULL in *paCol and 0 in *pnCol and return SQLITE_NOMEM.
95589: */
95590: static int selectColumnsFromExprList(
95591: Parse *pParse, /* Parsing context */
95592: ExprList *pEList, /* Expr list from which to derive column names */
95593: int *pnCol, /* Write the number of columns here */
95594: Column **paCol /* Write the new column list here */
95595: ){
95596: sqlite3 *db = pParse->db; /* Database connection */
95597: int i, j; /* Loop counters */
95598: int cnt; /* Index added to make the name unique */
95599: Column *aCol, *pCol; /* For looping over result columns */
95600: int nCol; /* Number of columns in the result set */
95601: Expr *p; /* Expression for a single result column */
95602: char *zName; /* Column name */
95603: int nName; /* Size of name in zName[] */
95604:
95605: *pnCol = nCol = pEList->nExpr;
95606: aCol = *paCol = sqlite3DbMallocZero(db, sizeof(aCol[0])*nCol);
95607: if( aCol==0 ) return SQLITE_NOMEM;
95608: for(i=0, pCol=aCol; i<nCol; i++, pCol++){
95609: /* Get an appropriate name for the column
95610: */
95611: p = pEList->a[i].pExpr;
95612: assert( p->pRight==0 || ExprHasProperty(p->pRight, EP_IntValue)
95613: || p->pRight->u.zToken==0 || p->pRight->u.zToken[0]!=0 );
95614: if( (zName = pEList->a[i].zName)!=0 ){
95615: /* If the column contains an "AS <name>" phrase, use <name> as the name */
95616: zName = sqlite3DbStrDup(db, zName);
95617: }else{
95618: Expr *pColExpr = p; /* The expression that is the result column name */
95619: Table *pTab; /* Table associated with this expression */
95620: while( pColExpr->op==TK_DOT ){
95621: pColExpr = pColExpr->pRight;
95622: assert( pColExpr!=0 );
95623: }
95624: if( pColExpr->op==TK_COLUMN && ALWAYS(pColExpr->pTab!=0) ){
95625: /* For columns use the column name name */
95626: int iCol = pColExpr->iColumn;
95627: pTab = pColExpr->pTab;
95628: if( iCol<0 ) iCol = pTab->iPKey;
95629: zName = sqlite3MPrintf(db, "%s",
95630: iCol>=0 ? pTab->aCol[iCol].zName : "rowid");
95631: }else if( pColExpr->op==TK_ID ){
95632: assert( !ExprHasProperty(pColExpr, EP_IntValue) );
95633: zName = sqlite3MPrintf(db, "%s", pColExpr->u.zToken);
95634: }else{
95635: /* Use the original text of the column expression as its name */
95636: zName = sqlite3MPrintf(db, "%s", pEList->a[i].zSpan);
95637: }
95638: }
95639: if( db->mallocFailed ){
95640: sqlite3DbFree(db, zName);
95641: break;
95642: }
95643:
95644: /* Make sure the column name is unique. If the name is not unique,
95645: ** append a integer to the name so that it becomes unique.
95646: */
95647: nName = sqlite3Strlen30(zName);
95648: for(j=cnt=0; j<i; j++){
95649: if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
95650: char *zNewName;
95651: zName[nName] = 0;
95652: zNewName = sqlite3MPrintf(db, "%s:%d", zName, ++cnt);
95653: sqlite3DbFree(db, zName);
95654: zName = zNewName;
95655: j = -1;
95656: if( zName==0 ) break;
95657: }
95658: }
95659: pCol->zName = zName;
95660: }
95661: if( db->mallocFailed ){
95662: for(j=0; j<i; j++){
95663: sqlite3DbFree(db, aCol[j].zName);
95664: }
95665: sqlite3DbFree(db, aCol);
95666: *paCol = 0;
95667: *pnCol = 0;
95668: return SQLITE_NOMEM;
95669: }
95670: return SQLITE_OK;
95671: }
95672:
95673: /*
95674: ** Add type and collation information to a column list based on
95675: ** a SELECT statement.
95676: **
95677: ** The column list presumably came from selectColumnNamesFromExprList().
95678: ** The column list has only names, not types or collations. This
95679: ** routine goes through and adds the types and collations.
95680: **
95681: ** This routine requires that all identifiers in the SELECT
95682: ** statement be resolved.
95683: */
95684: static void selectAddColumnTypeAndCollation(
95685: Parse *pParse, /* Parsing contexts */
95686: int nCol, /* Number of columns */
95687: Column *aCol, /* List of columns */
95688: Select *pSelect /* SELECT used to determine types and collations */
95689: ){
95690: sqlite3 *db = pParse->db;
95691: NameContext sNC;
95692: Column *pCol;
95693: CollSeq *pColl;
95694: int i;
95695: Expr *p;
95696: struct ExprList_item *a;
95697:
95698: assert( pSelect!=0 );
95699: assert( (pSelect->selFlags & SF_Resolved)!=0 );
95700: assert( nCol==pSelect->pEList->nExpr || db->mallocFailed );
95701: if( db->mallocFailed ) return;
95702: memset(&sNC, 0, sizeof(sNC));
95703: sNC.pSrcList = pSelect->pSrc;
95704: a = pSelect->pEList->a;
95705: for(i=0, pCol=aCol; i<nCol; i++, pCol++){
95706: p = a[i].pExpr;
95707: pCol->zType = sqlite3DbStrDup(db, columnType(&sNC, p, 0, 0, 0));
95708: pCol->affinity = sqlite3ExprAffinity(p);
95709: if( pCol->affinity==0 ) pCol->affinity = SQLITE_AFF_NONE;
95710: pColl = sqlite3ExprCollSeq(pParse, p);
95711: if( pColl ){
95712: pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
95713: }
95714: }
95715: }
95716:
95717: /*
95718: ** Given a SELECT statement, generate a Table structure that describes
95719: ** the result set of that SELECT.
95720: */
95721: SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect){
95722: Table *pTab;
95723: sqlite3 *db = pParse->db;
95724: int savedFlags;
95725:
95726: savedFlags = db->flags;
95727: db->flags &= ~SQLITE_FullColNames;
95728: db->flags |= SQLITE_ShortColNames;
95729: sqlite3SelectPrep(pParse, pSelect, 0);
95730: if( pParse->nErr ) return 0;
95731: while( pSelect->pPrior ) pSelect = pSelect->pPrior;
95732: db->flags = savedFlags;
95733: pTab = sqlite3DbMallocZero(db, sizeof(Table) );
95734: if( pTab==0 ){
95735: return 0;
95736: }
95737: /* The sqlite3ResultSetOfSelect() is only used n contexts where lookaside
95738: ** is disabled */
95739: assert( db->lookaside.bEnabled==0 );
95740: pTab->nRef = 1;
95741: pTab->zName = 0;
95742: pTab->nRowEst = 1000000;
95743: selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
95744: selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSelect);
95745: pTab->iPKey = -1;
95746: if( db->mallocFailed ){
95747: sqlite3DeleteTable(db, pTab);
95748: return 0;
95749: }
95750: return pTab;
95751: }
95752:
95753: /*
95754: ** Get a VDBE for the given parser context. Create a new one if necessary.
95755: ** If an error occurs, return NULL and leave a message in pParse.
95756: */
95757: SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){
95758: Vdbe *v = pParse->pVdbe;
95759: if( v==0 ){
95760: v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db);
95761: #ifndef SQLITE_OMIT_TRACE
95762: if( v ){
95763: sqlite3VdbeAddOp0(v, OP_Trace);
95764: }
95765: #endif
95766: }
95767: return v;
95768: }
95769:
95770:
95771: /*
95772: ** Compute the iLimit and iOffset fields of the SELECT based on the
95773: ** pLimit and pOffset expressions. pLimit and pOffset hold the expressions
95774: ** that appear in the original SQL statement after the LIMIT and OFFSET
95775: ** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
95776: ** are the integer memory register numbers for counters used to compute
95777: ** the limit and offset. If there is no limit and/or offset, then
95778: ** iLimit and iOffset are negative.
95779: **
95780: ** This routine changes the values of iLimit and iOffset only if
95781: ** a limit or offset is defined by pLimit and pOffset. iLimit and
95782: ** iOffset should have been preset to appropriate default values
95783: ** (usually but not always -1) prior to calling this routine.
95784: ** Only if pLimit!=0 or pOffset!=0 do the limit registers get
95785: ** redefined. The UNION ALL operator uses this property to force
95786: ** the reuse of the same limit and offset registers across multiple
95787: ** SELECT statements.
95788: */
95789: static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
95790: Vdbe *v = 0;
95791: int iLimit = 0;
95792: int iOffset;
95793: int addr1, n;
95794: if( p->iLimit ) return;
95795:
95796: /*
95797: ** "LIMIT -1" always shows all rows. There is some
95798: ** contraversy about what the correct behavior should be.
95799: ** The current implementation interprets "LIMIT 0" to mean
95800: ** no rows.
95801: */
95802: sqlite3ExprCacheClear(pParse);
95803: assert( p->pOffset==0 || p->pLimit!=0 );
95804: if( p->pLimit ){
95805: p->iLimit = iLimit = ++pParse->nMem;
95806: v = sqlite3GetVdbe(pParse);
95807: if( NEVER(v==0) ) return; /* VDBE should have already been allocated */
95808: if( sqlite3ExprIsInteger(p->pLimit, &n) ){
95809: sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
95810: VdbeComment((v, "LIMIT counter"));
95811: if( n==0 ){
95812: sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
95813: }else{
95814: if( p->nSelectRow > (double)n ) p->nSelectRow = (double)n;
95815: }
95816: }else{
95817: sqlite3ExprCode(pParse, p->pLimit, iLimit);
95818: sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit);
95819: VdbeComment((v, "LIMIT counter"));
95820: sqlite3VdbeAddOp2(v, OP_IfZero, iLimit, iBreak);
95821: }
95822: if( p->pOffset ){
95823: p->iOffset = iOffset = ++pParse->nMem;
95824: pParse->nMem++; /* Allocate an extra register for limit+offset */
95825: sqlite3ExprCode(pParse, p->pOffset, iOffset);
95826: sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset);
95827: VdbeComment((v, "OFFSET counter"));
95828: addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset);
95829: sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset);
95830: sqlite3VdbeJumpHere(v, addr1);
95831: sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
95832: VdbeComment((v, "LIMIT+OFFSET"));
95833: addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iLimit);
95834: sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
95835: sqlite3VdbeJumpHere(v, addr1);
95836: }
95837: }
95838: }
95839:
95840: #ifndef SQLITE_OMIT_COMPOUND_SELECT
95841: /*
95842: ** Return the appropriate collating sequence for the iCol-th column of
95843: ** the result set for the compound-select statement "p". Return NULL if
95844: ** the column has no default collating sequence.
95845: **
95846: ** The collating sequence for the compound select is taken from the
95847: ** left-most term of the select that has a collating sequence.
95848: */
95849: static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
95850: CollSeq *pRet;
95851: if( p->pPrior ){
95852: pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
95853: }else{
95854: pRet = 0;
95855: }
95856: assert( iCol>=0 );
95857: if( pRet==0 && iCol<p->pEList->nExpr ){
95858: pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
95859: }
95860: return pRet;
95861: }
95862: #endif /* SQLITE_OMIT_COMPOUND_SELECT */
95863:
95864: /* Forward reference */
95865: static int multiSelectOrderBy(
95866: Parse *pParse, /* Parsing context */
95867: Select *p, /* The right-most of SELECTs to be coded */
95868: SelectDest *pDest /* What to do with query results */
95869: );
95870:
95871:
95872: #ifndef SQLITE_OMIT_COMPOUND_SELECT
95873: /*
95874: ** This routine is called to process a compound query form from
95875: ** two or more separate queries using UNION, UNION ALL, EXCEPT, or
95876: ** INTERSECT
95877: **
95878: ** "p" points to the right-most of the two queries. the query on the
95879: ** left is p->pPrior. The left query could also be a compound query
95880: ** in which case this routine will be called recursively.
95881: **
95882: ** The results of the total query are to be written into a destination
95883: ** of type eDest with parameter iParm.
95884: **
95885: ** Example 1: Consider a three-way compound SQL statement.
95886: **
95887: ** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
95888: **
95889: ** This statement is parsed up as follows:
95890: **
95891: ** SELECT c FROM t3
95892: ** |
95893: ** `-----> SELECT b FROM t2
95894: ** |
95895: ** `------> SELECT a FROM t1
95896: **
95897: ** The arrows in the diagram above represent the Select.pPrior pointer.
95898: ** So if this routine is called with p equal to the t3 query, then
95899: ** pPrior will be the t2 query. p->op will be TK_UNION in this case.
95900: **
95901: ** Notice that because of the way SQLite parses compound SELECTs, the
95902: ** individual selects always group from left to right.
95903: */
95904: static int multiSelect(
95905: Parse *pParse, /* Parsing context */
95906: Select *p, /* The right-most of SELECTs to be coded */
95907: SelectDest *pDest /* What to do with query results */
95908: ){
95909: int rc = SQLITE_OK; /* Success code from a subroutine */
95910: Select *pPrior; /* Another SELECT immediately to our left */
95911: Vdbe *v; /* Generate code to this VDBE */
95912: SelectDest dest; /* Alternative data destination */
95913: Select *pDelete = 0; /* Chain of simple selects to delete */
95914: sqlite3 *db; /* Database connection */
95915: #ifndef SQLITE_OMIT_EXPLAIN
95916: int iSub1; /* EQP id of left-hand query */
95917: int iSub2; /* EQP id of right-hand query */
95918: #endif
95919:
95920: /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only
95921: ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
95922: */
95923: assert( p && p->pPrior ); /* Calling function guarantees this much */
95924: db = pParse->db;
95925: pPrior = p->pPrior;
95926: assert( pPrior->pRightmost!=pPrior );
95927: assert( pPrior->pRightmost==p->pRightmost );
95928: dest = *pDest;
95929: if( pPrior->pOrderBy ){
95930: sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
95931: selectOpName(p->op));
95932: rc = 1;
95933: goto multi_select_end;
95934: }
95935: if( pPrior->pLimit ){
95936: sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
95937: selectOpName(p->op));
95938: rc = 1;
95939: goto multi_select_end;
95940: }
95941:
95942: v = sqlite3GetVdbe(pParse);
95943: assert( v!=0 ); /* The VDBE already created by calling function */
95944:
95945: /* Create the destination temporary table if necessary
95946: */
95947: if( dest.eDest==SRT_EphemTab ){
95948: assert( p->pEList );
95949: sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iParm, p->pEList->nExpr);
95950: sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
95951: dest.eDest = SRT_Table;
95952: }
95953:
95954: /* Make sure all SELECTs in the statement have the same number of elements
95955: ** in their result sets.
95956: */
95957: assert( p->pEList && pPrior->pEList );
95958: if( p->pEList->nExpr!=pPrior->pEList->nExpr ){
95959: sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
95960: " do not have the same number of result columns", selectOpName(p->op));
95961: rc = 1;
95962: goto multi_select_end;
95963: }
95964:
95965: /* Compound SELECTs that have an ORDER BY clause are handled separately.
95966: */
95967: if( p->pOrderBy ){
95968: return multiSelectOrderBy(pParse, p, pDest);
95969: }
95970:
95971: /* Generate code for the left and right SELECT statements.
95972: */
95973: switch( p->op ){
95974: case TK_ALL: {
95975: int addr = 0;
95976: int nLimit;
95977: assert( !pPrior->pLimit );
95978: pPrior->pLimit = p->pLimit;
95979: pPrior->pOffset = p->pOffset;
95980: explainSetInteger(iSub1, pParse->iNextSelectId);
95981: rc = sqlite3Select(pParse, pPrior, &dest);
95982: p->pLimit = 0;
95983: p->pOffset = 0;
95984: if( rc ){
95985: goto multi_select_end;
95986: }
95987: p->pPrior = 0;
95988: p->iLimit = pPrior->iLimit;
95989: p->iOffset = pPrior->iOffset;
95990: if( p->iLimit ){
95991: addr = sqlite3VdbeAddOp1(v, OP_IfZero, p->iLimit);
95992: VdbeComment((v, "Jump ahead if LIMIT reached"));
95993: }
95994: explainSetInteger(iSub2, pParse->iNextSelectId);
95995: rc = sqlite3Select(pParse, p, &dest);
95996: testcase( rc!=SQLITE_OK );
95997: pDelete = p->pPrior;
95998: p->pPrior = pPrior;
95999: p->nSelectRow += pPrior->nSelectRow;
96000: if( pPrior->pLimit
96001: && sqlite3ExprIsInteger(pPrior->pLimit, &nLimit)
96002: && p->nSelectRow > (double)nLimit
96003: ){
96004: p->nSelectRow = (double)nLimit;
96005: }
96006: if( addr ){
96007: sqlite3VdbeJumpHere(v, addr);
96008: }
96009: break;
96010: }
96011: case TK_EXCEPT:
96012: case TK_UNION: {
96013: int unionTab; /* Cursor number of the temporary table holding result */
96014: u8 op = 0; /* One of the SRT_ operations to apply to self */
96015: int priorOp; /* The SRT_ operation to apply to prior selects */
96016: Expr *pLimit, *pOffset; /* Saved values of p->nLimit and p->nOffset */
96017: int addr;
96018: SelectDest uniondest;
96019:
96020: testcase( p->op==TK_EXCEPT );
96021: testcase( p->op==TK_UNION );
96022: priorOp = SRT_Union;
96023: if( dest.eDest==priorOp && ALWAYS(!p->pLimit &&!p->pOffset) ){
96024: /* We can reuse a temporary table generated by a SELECT to our
96025: ** right.
96026: */
96027: assert( p->pRightmost!=p ); /* Can only happen for leftward elements
96028: ** of a 3-way or more compound */
96029: assert( p->pLimit==0 ); /* Not allowed on leftward elements */
96030: assert( p->pOffset==0 ); /* Not allowed on leftward elements */
96031: unionTab = dest.iParm;
96032: }else{
96033: /* We will need to create our own temporary table to hold the
96034: ** intermediate results.
96035: */
96036: unionTab = pParse->nTab++;
96037: assert( p->pOrderBy==0 );
96038: addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
96039: assert( p->addrOpenEphm[0] == -1 );
96040: p->addrOpenEphm[0] = addr;
96041: p->pRightmost->selFlags |= SF_UsesEphemeral;
96042: assert( p->pEList );
96043: }
96044:
96045: /* Code the SELECT statements to our left
96046: */
96047: assert( !pPrior->pOrderBy );
96048: sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
96049: explainSetInteger(iSub1, pParse->iNextSelectId);
96050: rc = sqlite3Select(pParse, pPrior, &uniondest);
96051: if( rc ){
96052: goto multi_select_end;
96053: }
96054:
96055: /* Code the current SELECT statement
96056: */
96057: if( p->op==TK_EXCEPT ){
96058: op = SRT_Except;
96059: }else{
96060: assert( p->op==TK_UNION );
96061: op = SRT_Union;
96062: }
96063: p->pPrior = 0;
96064: pLimit = p->pLimit;
96065: p->pLimit = 0;
96066: pOffset = p->pOffset;
96067: p->pOffset = 0;
96068: uniondest.eDest = op;
96069: explainSetInteger(iSub2, pParse->iNextSelectId);
96070: rc = sqlite3Select(pParse, p, &uniondest);
96071: testcase( rc!=SQLITE_OK );
96072: /* Query flattening in sqlite3Select() might refill p->pOrderBy.
96073: ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
96074: sqlite3ExprListDelete(db, p->pOrderBy);
96075: pDelete = p->pPrior;
96076: p->pPrior = pPrior;
96077: p->pOrderBy = 0;
96078: if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow;
96079: sqlite3ExprDelete(db, p->pLimit);
96080: p->pLimit = pLimit;
96081: p->pOffset = pOffset;
96082: p->iLimit = 0;
96083: p->iOffset = 0;
96084:
96085: /* Convert the data in the temporary table into whatever form
96086: ** it is that we currently need.
96087: */
96088: assert( unionTab==dest.iParm || dest.eDest!=priorOp );
96089: if( dest.eDest!=priorOp ){
96090: int iCont, iBreak, iStart;
96091: assert( p->pEList );
96092: if( dest.eDest==SRT_Output ){
96093: Select *pFirst = p;
96094: while( pFirst->pPrior ) pFirst = pFirst->pPrior;
96095: generateColumnNames(pParse, 0, pFirst->pEList);
96096: }
96097: iBreak = sqlite3VdbeMakeLabel(v);
96098: iCont = sqlite3VdbeMakeLabel(v);
96099: computeLimitRegisters(pParse, p, iBreak);
96100: sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak);
96101: iStart = sqlite3VdbeCurrentAddr(v);
96102: selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
96103: 0, -1, &dest, iCont, iBreak);
96104: sqlite3VdbeResolveLabel(v, iCont);
96105: sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart);
96106: sqlite3VdbeResolveLabel(v, iBreak);
96107: sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
96108: }
96109: break;
96110: }
96111: default: assert( p->op==TK_INTERSECT ); {
96112: int tab1, tab2;
96113: int iCont, iBreak, iStart;
96114: Expr *pLimit, *pOffset;
96115: int addr;
96116: SelectDest intersectdest;
96117: int r1;
96118:
96119: /* INTERSECT is different from the others since it requires
96120: ** two temporary tables. Hence it has its own case. Begin
96121: ** by allocating the tables we will need.
96122: */
96123: tab1 = pParse->nTab++;
96124: tab2 = pParse->nTab++;
96125: assert( p->pOrderBy==0 );
96126:
96127: addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
96128: assert( p->addrOpenEphm[0] == -1 );
96129: p->addrOpenEphm[0] = addr;
96130: p->pRightmost->selFlags |= SF_UsesEphemeral;
96131: assert( p->pEList );
96132:
96133: /* Code the SELECTs to our left into temporary table "tab1".
96134: */
96135: sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
96136: explainSetInteger(iSub1, pParse->iNextSelectId);
96137: rc = sqlite3Select(pParse, pPrior, &intersectdest);
96138: if( rc ){
96139: goto multi_select_end;
96140: }
96141:
96142: /* Code the current SELECT into temporary table "tab2"
96143: */
96144: addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
96145: assert( p->addrOpenEphm[1] == -1 );
96146: p->addrOpenEphm[1] = addr;
96147: p->pPrior = 0;
96148: pLimit = p->pLimit;
96149: p->pLimit = 0;
96150: pOffset = p->pOffset;
96151: p->pOffset = 0;
96152: intersectdest.iParm = tab2;
96153: explainSetInteger(iSub2, pParse->iNextSelectId);
96154: rc = sqlite3Select(pParse, p, &intersectdest);
96155: testcase( rc!=SQLITE_OK );
96156: pDelete = p->pPrior;
96157: p->pPrior = pPrior;
96158: if( p->nSelectRow>pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
96159: sqlite3ExprDelete(db, p->pLimit);
96160: p->pLimit = pLimit;
96161: p->pOffset = pOffset;
96162:
96163: /* Generate code to take the intersection of the two temporary
96164: ** tables.
96165: */
96166: assert( p->pEList );
96167: if( dest.eDest==SRT_Output ){
96168: Select *pFirst = p;
96169: while( pFirst->pPrior ) pFirst = pFirst->pPrior;
96170: generateColumnNames(pParse, 0, pFirst->pEList);
96171: }
96172: iBreak = sqlite3VdbeMakeLabel(v);
96173: iCont = sqlite3VdbeMakeLabel(v);
96174: computeLimitRegisters(pParse, p, iBreak);
96175: sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak);
96176: r1 = sqlite3GetTempReg(pParse);
96177: iStart = sqlite3VdbeAddOp2(v, OP_RowKey, tab1, r1);
96178: sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
96179: sqlite3ReleaseTempReg(pParse, r1);
96180: selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
96181: 0, -1, &dest, iCont, iBreak);
96182: sqlite3VdbeResolveLabel(v, iCont);
96183: sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart);
96184: sqlite3VdbeResolveLabel(v, iBreak);
96185: sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
96186: sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
96187: break;
96188: }
96189: }
96190:
96191: explainComposite(pParse, p->op, iSub1, iSub2, p->op!=TK_ALL);
96192:
96193: /* Compute collating sequences used by
96194: ** temporary tables needed to implement the compound select.
96195: ** Attach the KeyInfo structure to all temporary tables.
96196: **
96197: ** This section is run by the right-most SELECT statement only.
96198: ** SELECT statements to the left always skip this part. The right-most
96199: ** SELECT might also skip this part if it has no ORDER BY clause and
96200: ** no temp tables are required.
96201: */
96202: if( p->selFlags & SF_UsesEphemeral ){
96203: int i; /* Loop counter */
96204: KeyInfo *pKeyInfo; /* Collating sequence for the result set */
96205: Select *pLoop; /* For looping through SELECT statements */
96206: CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
96207: int nCol; /* Number of columns in result set */
96208:
96209: assert( p->pRightmost==p );
96210: nCol = p->pEList->nExpr;
96211: pKeyInfo = sqlite3DbMallocZero(db,
96212: sizeof(*pKeyInfo)+nCol*(sizeof(CollSeq*) + 1));
96213: if( !pKeyInfo ){
96214: rc = SQLITE_NOMEM;
96215: goto multi_select_end;
96216: }
96217:
96218: pKeyInfo->enc = ENC(db);
96219: pKeyInfo->nField = (u16)nCol;
96220:
96221: for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
96222: *apColl = multiSelectCollSeq(pParse, p, i);
96223: if( 0==*apColl ){
96224: *apColl = db->pDfltColl;
96225: }
96226: }
96227:
96228: for(pLoop=p; pLoop; pLoop=pLoop->pPrior){
96229: for(i=0; i<2; i++){
96230: int addr = pLoop->addrOpenEphm[i];
96231: if( addr<0 ){
96232: /* If [0] is unused then [1] is also unused. So we can
96233: ** always safely abort as soon as the first unused slot is found */
96234: assert( pLoop->addrOpenEphm[1]<0 );
96235: break;
96236: }
96237: sqlite3VdbeChangeP2(v, addr, nCol);
96238: sqlite3VdbeChangeP4(v, addr, (char*)pKeyInfo, P4_KEYINFO);
96239: pLoop->addrOpenEphm[i] = -1;
96240: }
96241: }
96242: sqlite3DbFree(db, pKeyInfo);
96243: }
96244:
96245: multi_select_end:
96246: pDest->iMem = dest.iMem;
96247: pDest->nMem = dest.nMem;
96248: sqlite3SelectDelete(db, pDelete);
96249: return rc;
96250: }
96251: #endif /* SQLITE_OMIT_COMPOUND_SELECT */
96252:
96253: /*
96254: ** Code an output subroutine for a coroutine implementation of a
96255: ** SELECT statment.
96256: **
96257: ** The data to be output is contained in pIn->iMem. There are
96258: ** pIn->nMem columns to be output. pDest is where the output should
96259: ** be sent.
96260: **
96261: ** regReturn is the number of the register holding the subroutine
96262: ** return address.
96263: **
96264: ** If regPrev>0 then it is the first register in a vector that
96265: ** records the previous output. mem[regPrev] is a flag that is false
96266: ** if there has been no previous output. If regPrev>0 then code is
96267: ** generated to suppress duplicates. pKeyInfo is used for comparing
96268: ** keys.
96269: **
96270: ** If the LIMIT found in p->iLimit is reached, jump immediately to
96271: ** iBreak.
96272: */
96273: static int generateOutputSubroutine(
96274: Parse *pParse, /* Parsing context */
96275: Select *p, /* The SELECT statement */
96276: SelectDest *pIn, /* Coroutine supplying data */
96277: SelectDest *pDest, /* Where to send the data */
96278: int regReturn, /* The return address register */
96279: int regPrev, /* Previous result register. No uniqueness if 0 */
96280: KeyInfo *pKeyInfo, /* For comparing with previous entry */
96281: int p4type, /* The p4 type for pKeyInfo */
96282: int iBreak /* Jump here if we hit the LIMIT */
96283: ){
96284: Vdbe *v = pParse->pVdbe;
96285: int iContinue;
96286: int addr;
96287:
96288: addr = sqlite3VdbeCurrentAddr(v);
96289: iContinue = sqlite3VdbeMakeLabel(v);
96290:
96291: /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
96292: */
96293: if( regPrev ){
96294: int j1, j2;
96295: j1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev);
96296: j2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iMem, regPrev+1, pIn->nMem,
96297: (char*)pKeyInfo, p4type);
96298: sqlite3VdbeAddOp3(v, OP_Jump, j2+2, iContinue, j2+2);
96299: sqlite3VdbeJumpHere(v, j1);
96300: sqlite3ExprCodeCopy(pParse, pIn->iMem, regPrev+1, pIn->nMem);
96301: sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);
96302: }
96303: if( pParse->db->mallocFailed ) return 0;
96304:
96305: /* Suppress the the first OFFSET entries if there is an OFFSET clause
96306: */
96307: codeOffset(v, p, iContinue);
96308:
96309: switch( pDest->eDest ){
96310: /* Store the result as data using a unique key.
96311: */
96312: case SRT_Table:
96313: case SRT_EphemTab: {
96314: int r1 = sqlite3GetTempReg(pParse);
96315: int r2 = sqlite3GetTempReg(pParse);
96316: testcase( pDest->eDest==SRT_Table );
96317: testcase( pDest->eDest==SRT_EphemTab );
96318: sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iMem, pIn->nMem, r1);
96319: sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iParm, r2);
96320: sqlite3VdbeAddOp3(v, OP_Insert, pDest->iParm, r1, r2);
96321: sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
96322: sqlite3ReleaseTempReg(pParse, r2);
96323: sqlite3ReleaseTempReg(pParse, r1);
96324: break;
96325: }
96326:
96327: #ifndef SQLITE_OMIT_SUBQUERY
96328: /* If we are creating a set for an "expr IN (SELECT ...)" construct,
96329: ** then there should be a single item on the stack. Write this
96330: ** item into the set table with bogus data.
96331: */
96332: case SRT_Set: {
96333: int r1;
96334: assert( pIn->nMem==1 );
96335: p->affinity =
96336: sqlite3CompareAffinity(p->pEList->a[0].pExpr, pDest->affinity);
96337: r1 = sqlite3GetTempReg(pParse);
96338: sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iMem, 1, r1, &p->affinity, 1);
96339: sqlite3ExprCacheAffinityChange(pParse, pIn->iMem, 1);
96340: sqlite3VdbeAddOp2(v, OP_IdxInsert, pDest->iParm, r1);
96341: sqlite3ReleaseTempReg(pParse, r1);
96342: break;
96343: }
96344:
96345: #if 0 /* Never occurs on an ORDER BY query */
96346: /* If any row exist in the result set, record that fact and abort.
96347: */
96348: case SRT_Exists: {
96349: sqlite3VdbeAddOp2(v, OP_Integer, 1, pDest->iParm);
96350: /* The LIMIT clause will terminate the loop for us */
96351: break;
96352: }
96353: #endif
96354:
96355: /* If this is a scalar select that is part of an expression, then
96356: ** store the results in the appropriate memory cell and break out
96357: ** of the scan loop.
96358: */
96359: case SRT_Mem: {
96360: assert( pIn->nMem==1 );
96361: sqlite3ExprCodeMove(pParse, pIn->iMem, pDest->iParm, 1);
96362: /* The LIMIT clause will jump out of the loop for us */
96363: break;
96364: }
96365: #endif /* #ifndef SQLITE_OMIT_SUBQUERY */
96366:
96367: /* The results are stored in a sequence of registers
96368: ** starting at pDest->iMem. Then the co-routine yields.
96369: */
96370: case SRT_Coroutine: {
96371: if( pDest->iMem==0 ){
96372: pDest->iMem = sqlite3GetTempRange(pParse, pIn->nMem);
96373: pDest->nMem = pIn->nMem;
96374: }
96375: sqlite3ExprCodeMove(pParse, pIn->iMem, pDest->iMem, pDest->nMem);
96376: sqlite3VdbeAddOp1(v, OP_Yield, pDest->iParm);
96377: break;
96378: }
96379:
96380: /* If none of the above, then the result destination must be
96381: ** SRT_Output. This routine is never called with any other
96382: ** destination other than the ones handled above or SRT_Output.
96383: **
96384: ** For SRT_Output, results are stored in a sequence of registers.
96385: ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
96386: ** return the next row of result.
96387: */
96388: default: {
96389: assert( pDest->eDest==SRT_Output );
96390: sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iMem, pIn->nMem);
96391: sqlite3ExprCacheAffinityChange(pParse, pIn->iMem, pIn->nMem);
96392: break;
96393: }
96394: }
96395:
96396: /* Jump to the end of the loop if the LIMIT is reached.
96397: */
96398: if( p->iLimit ){
96399: sqlite3VdbeAddOp3(v, OP_IfZero, p->iLimit, iBreak, -1);
96400: }
96401:
96402: /* Generate the subroutine return
96403: */
96404: sqlite3VdbeResolveLabel(v, iContinue);
96405: sqlite3VdbeAddOp1(v, OP_Return, regReturn);
96406:
96407: return addr;
96408: }
96409:
96410: /*
96411: ** Alternative compound select code generator for cases when there
96412: ** is an ORDER BY clause.
96413: **
96414: ** We assume a query of the following form:
96415: **
96416: ** <selectA> <operator> <selectB> ORDER BY <orderbylist>
96417: **
96418: ** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT. The idea
96419: ** is to code both <selectA> and <selectB> with the ORDER BY clause as
96420: ** co-routines. Then run the co-routines in parallel and merge the results
96421: ** into the output. In addition to the two coroutines (called selectA and
96422: ** selectB) there are 7 subroutines:
96423: **
96424: ** outA: Move the output of the selectA coroutine into the output
96425: ** of the compound query.
96426: **
96427: ** outB: Move the output of the selectB coroutine into the output
96428: ** of the compound query. (Only generated for UNION and
96429: ** UNION ALL. EXCEPT and INSERTSECT never output a row that
96430: ** appears only in B.)
96431: **
96432: ** AltB: Called when there is data from both coroutines and A<B.
96433: **
96434: ** AeqB: Called when there is data from both coroutines and A==B.
96435: **
96436: ** AgtB: Called when there is data from both coroutines and A>B.
96437: **
96438: ** EofA: Called when data is exhausted from selectA.
96439: **
96440: ** EofB: Called when data is exhausted from selectB.
96441: **
96442: ** The implementation of the latter five subroutines depend on which
96443: ** <operator> is used:
96444: **
96445: **
96446: ** UNION ALL UNION EXCEPT INTERSECT
96447: ** ------------- ----------------- -------------- -----------------
96448: ** AltB: outA, nextA outA, nextA outA, nextA nextA
96449: **
96450: ** AeqB: outA, nextA nextA nextA outA, nextA
96451: **
96452: ** AgtB: outB, nextB outB, nextB nextB nextB
96453: **
96454: ** EofA: outB, nextB outB, nextB halt halt
96455: **
96456: ** EofB: outA, nextA outA, nextA outA, nextA halt
96457: **
96458: ** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
96459: ** causes an immediate jump to EofA and an EOF on B following nextB causes
96460: ** an immediate jump to EofB. Within EofA and EofB, and EOF on entry or
96461: ** following nextX causes a jump to the end of the select processing.
96462: **
96463: ** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
96464: ** within the output subroutine. The regPrev register set holds the previously
96465: ** output value. A comparison is made against this value and the output
96466: ** is skipped if the next results would be the same as the previous.
96467: **
96468: ** The implementation plan is to implement the two coroutines and seven
96469: ** subroutines first, then put the control logic at the bottom. Like this:
96470: **
96471: ** goto Init
96472: ** coA: coroutine for left query (A)
96473: ** coB: coroutine for right query (B)
96474: ** outA: output one row of A
96475: ** outB: output one row of B (UNION and UNION ALL only)
96476: ** EofA: ...
96477: ** EofB: ...
96478: ** AltB: ...
96479: ** AeqB: ...
96480: ** AgtB: ...
96481: ** Init: initialize coroutine registers
96482: ** yield coA
96483: ** if eof(A) goto EofA
96484: ** yield coB
96485: ** if eof(B) goto EofB
96486: ** Cmpr: Compare A, B
96487: ** Jump AltB, AeqB, AgtB
96488: ** End: ...
96489: **
96490: ** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
96491: ** actually called using Gosub and they do not Return. EofA and EofB loop
96492: ** until all data is exhausted then jump to the "end" labe. AltB, AeqB,
96493: ** and AgtB jump to either L2 or to one of EofA or EofB.
96494: */
96495: #ifndef SQLITE_OMIT_COMPOUND_SELECT
96496: static int multiSelectOrderBy(
96497: Parse *pParse, /* Parsing context */
96498: Select *p, /* The right-most of SELECTs to be coded */
96499: SelectDest *pDest /* What to do with query results */
96500: ){
96501: int i, j; /* Loop counters */
96502: Select *pPrior; /* Another SELECT immediately to our left */
96503: Vdbe *v; /* Generate code to this VDBE */
96504: SelectDest destA; /* Destination for coroutine A */
96505: SelectDest destB; /* Destination for coroutine B */
96506: int regAddrA; /* Address register for select-A coroutine */
96507: int regEofA; /* Flag to indicate when select-A is complete */
96508: int regAddrB; /* Address register for select-B coroutine */
96509: int regEofB; /* Flag to indicate when select-B is complete */
96510: int addrSelectA; /* Address of the select-A coroutine */
96511: int addrSelectB; /* Address of the select-B coroutine */
96512: int regOutA; /* Address register for the output-A subroutine */
96513: int regOutB; /* Address register for the output-B subroutine */
96514: int addrOutA; /* Address of the output-A subroutine */
96515: int addrOutB = 0; /* Address of the output-B subroutine */
96516: int addrEofA; /* Address of the select-A-exhausted subroutine */
96517: int addrEofB; /* Address of the select-B-exhausted subroutine */
96518: int addrAltB; /* Address of the A<B subroutine */
96519: int addrAeqB; /* Address of the A==B subroutine */
96520: int addrAgtB; /* Address of the A>B subroutine */
96521: int regLimitA; /* Limit register for select-A */
96522: int regLimitB; /* Limit register for select-A */
96523: int regPrev; /* A range of registers to hold previous output */
96524: int savedLimit; /* Saved value of p->iLimit */
96525: int savedOffset; /* Saved value of p->iOffset */
96526: int labelCmpr; /* Label for the start of the merge algorithm */
96527: int labelEnd; /* Label for the end of the overall SELECT stmt */
96528: int j1; /* Jump instructions that get retargetted */
96529: int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
96530: KeyInfo *pKeyDup = 0; /* Comparison information for duplicate removal */
96531: KeyInfo *pKeyMerge; /* Comparison information for merging rows */
96532: sqlite3 *db; /* Database connection */
96533: ExprList *pOrderBy; /* The ORDER BY clause */
96534: int nOrderBy; /* Number of terms in the ORDER BY clause */
96535: int *aPermute; /* Mapping from ORDER BY terms to result set columns */
96536: #ifndef SQLITE_OMIT_EXPLAIN
96537: int iSub1; /* EQP id of left-hand query */
96538: int iSub2; /* EQP id of right-hand query */
96539: #endif
96540:
96541: assert( p->pOrderBy!=0 );
96542: assert( pKeyDup==0 ); /* "Managed" code needs this. Ticket #3382. */
96543: db = pParse->db;
96544: v = pParse->pVdbe;
96545: assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
96546: labelEnd = sqlite3VdbeMakeLabel(v);
96547: labelCmpr = sqlite3VdbeMakeLabel(v);
96548:
96549:
96550: /* Patch up the ORDER BY clause
96551: */
96552: op = p->op;
96553: pPrior = p->pPrior;
96554: assert( pPrior->pOrderBy==0 );
96555: pOrderBy = p->pOrderBy;
96556: assert( pOrderBy );
96557: nOrderBy = pOrderBy->nExpr;
96558:
96559: /* For operators other than UNION ALL we have to make sure that
96560: ** the ORDER BY clause covers every term of the result set. Add
96561: ** terms to the ORDER BY clause as necessary.
96562: */
96563: if( op!=TK_ALL ){
96564: for(i=1; db->mallocFailed==0 && i<=p->pEList->nExpr; i++){
96565: struct ExprList_item *pItem;
96566: for(j=0, pItem=pOrderBy->a; j<nOrderBy; j++, pItem++){
96567: assert( pItem->iOrderByCol>0 );
96568: if( pItem->iOrderByCol==i ) break;
96569: }
96570: if( j==nOrderBy ){
96571: Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
96572: if( pNew==0 ) return SQLITE_NOMEM;
96573: pNew->flags |= EP_IntValue;
96574: pNew->u.iValue = i;
96575: pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
96576: pOrderBy->a[nOrderBy++].iOrderByCol = (u16)i;
96577: }
96578: }
96579: }
96580:
96581: /* Compute the comparison permutation and keyinfo that is used with
96582: ** the permutation used to determine if the next
96583: ** row of results comes from selectA or selectB. Also add explicit
96584: ** collations to the ORDER BY clause terms so that when the subqueries
96585: ** to the right and the left are evaluated, they use the correct
96586: ** collation.
96587: */
96588: aPermute = sqlite3DbMallocRaw(db, sizeof(int)*nOrderBy);
96589: if( aPermute ){
96590: struct ExprList_item *pItem;
96591: for(i=0, pItem=pOrderBy->a; i<nOrderBy; i++, pItem++){
96592: assert( pItem->iOrderByCol>0 && pItem->iOrderByCol<=p->pEList->nExpr );
96593: aPermute[i] = pItem->iOrderByCol - 1;
96594: }
96595: pKeyMerge =
96596: sqlite3DbMallocRaw(db, sizeof(*pKeyMerge)+nOrderBy*(sizeof(CollSeq*)+1));
96597: if( pKeyMerge ){
96598: pKeyMerge->aSortOrder = (u8*)&pKeyMerge->aColl[nOrderBy];
96599: pKeyMerge->nField = (u16)nOrderBy;
96600: pKeyMerge->enc = ENC(db);
96601: for(i=0; i<nOrderBy; i++){
96602: CollSeq *pColl;
96603: Expr *pTerm = pOrderBy->a[i].pExpr;
96604: if( pTerm->flags & EP_ExpCollate ){
96605: pColl = pTerm->pColl;
96606: }else{
96607: pColl = multiSelectCollSeq(pParse, p, aPermute[i]);
96608: pTerm->flags |= EP_ExpCollate;
96609: pTerm->pColl = pColl;
96610: }
96611: pKeyMerge->aColl[i] = pColl;
96612: pKeyMerge->aSortOrder[i] = pOrderBy->a[i].sortOrder;
96613: }
96614: }
96615: }else{
96616: pKeyMerge = 0;
96617: }
96618:
96619: /* Reattach the ORDER BY clause to the query.
96620: */
96621: p->pOrderBy = pOrderBy;
96622: pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
96623:
96624: /* Allocate a range of temporary registers and the KeyInfo needed
96625: ** for the logic that removes duplicate result rows when the
96626: ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
96627: */
96628: if( op==TK_ALL ){
96629: regPrev = 0;
96630: }else{
96631: int nExpr = p->pEList->nExpr;
96632: assert( nOrderBy>=nExpr || db->mallocFailed );
96633: regPrev = sqlite3GetTempRange(pParse, nExpr+1);
96634: sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
96635: pKeyDup = sqlite3DbMallocZero(db,
96636: sizeof(*pKeyDup) + nExpr*(sizeof(CollSeq*)+1) );
96637: if( pKeyDup ){
96638: pKeyDup->aSortOrder = (u8*)&pKeyDup->aColl[nExpr];
96639: pKeyDup->nField = (u16)nExpr;
96640: pKeyDup->enc = ENC(db);
96641: for(i=0; i<nExpr; i++){
96642: pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
96643: pKeyDup->aSortOrder[i] = 0;
96644: }
96645: }
96646: }
96647:
96648: /* Separate the left and the right query from one another
96649: */
96650: p->pPrior = 0;
96651: sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
96652: if( pPrior->pPrior==0 ){
96653: sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
96654: }
96655:
96656: /* Compute the limit registers */
96657: computeLimitRegisters(pParse, p, labelEnd);
96658: if( p->iLimit && op==TK_ALL ){
96659: regLimitA = ++pParse->nMem;
96660: regLimitB = ++pParse->nMem;
96661: sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
96662: regLimitA);
96663: sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
96664: }else{
96665: regLimitA = regLimitB = 0;
96666: }
96667: sqlite3ExprDelete(db, p->pLimit);
96668: p->pLimit = 0;
96669: sqlite3ExprDelete(db, p->pOffset);
96670: p->pOffset = 0;
96671:
96672: regAddrA = ++pParse->nMem;
96673: regEofA = ++pParse->nMem;
96674: regAddrB = ++pParse->nMem;
96675: regEofB = ++pParse->nMem;
96676: regOutA = ++pParse->nMem;
96677: regOutB = ++pParse->nMem;
96678: sqlite3SelectDestInit(&destA, SRT_Coroutine, regAddrA);
96679: sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
96680:
96681: /* Jump past the various subroutines and coroutines to the main
96682: ** merge loop
96683: */
96684: j1 = sqlite3VdbeAddOp0(v, OP_Goto);
96685: addrSelectA = sqlite3VdbeCurrentAddr(v);
96686:
96687:
96688: /* Generate a coroutine to evaluate the SELECT statement to the
96689: ** left of the compound operator - the "A" select.
96690: */
96691: VdbeNoopComment((v, "Begin coroutine for left SELECT"));
96692: pPrior->iLimit = regLimitA;
96693: explainSetInteger(iSub1, pParse->iNextSelectId);
96694: sqlite3Select(pParse, pPrior, &destA);
96695: sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofA);
96696: sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
96697: VdbeNoopComment((v, "End coroutine for left SELECT"));
96698:
96699: /* Generate a coroutine to evaluate the SELECT statement on
96700: ** the right - the "B" select
96701: */
96702: addrSelectB = sqlite3VdbeCurrentAddr(v);
96703: VdbeNoopComment((v, "Begin coroutine for right SELECT"));
96704: savedLimit = p->iLimit;
96705: savedOffset = p->iOffset;
96706: p->iLimit = regLimitB;
96707: p->iOffset = 0;
96708: explainSetInteger(iSub2, pParse->iNextSelectId);
96709: sqlite3Select(pParse, p, &destB);
96710: p->iLimit = savedLimit;
96711: p->iOffset = savedOffset;
96712: sqlite3VdbeAddOp2(v, OP_Integer, 1, regEofB);
96713: sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
96714: VdbeNoopComment((v, "End coroutine for right SELECT"));
96715:
96716: /* Generate a subroutine that outputs the current row of the A
96717: ** select as the next output row of the compound select.
96718: */
96719: VdbeNoopComment((v, "Output routine for A"));
96720: addrOutA = generateOutputSubroutine(pParse,
96721: p, &destA, pDest, regOutA,
96722: regPrev, pKeyDup, P4_KEYINFO_HANDOFF, labelEnd);
96723:
96724: /* Generate a subroutine that outputs the current row of the B
96725: ** select as the next output row of the compound select.
96726: */
96727: if( op==TK_ALL || op==TK_UNION ){
96728: VdbeNoopComment((v, "Output routine for B"));
96729: addrOutB = generateOutputSubroutine(pParse,
96730: p, &destB, pDest, regOutB,
96731: regPrev, pKeyDup, P4_KEYINFO_STATIC, labelEnd);
96732: }
96733:
96734: /* Generate a subroutine to run when the results from select A
96735: ** are exhausted and only data in select B remains.
96736: */
96737: VdbeNoopComment((v, "eof-A subroutine"));
96738: if( op==TK_EXCEPT || op==TK_INTERSECT ){
96739: addrEofA = sqlite3VdbeAddOp2(v, OP_Goto, 0, labelEnd);
96740: }else{
96741: addrEofA = sqlite3VdbeAddOp2(v, OP_If, regEofB, labelEnd);
96742: sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
96743: sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
96744: sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofA);
96745: p->nSelectRow += pPrior->nSelectRow;
96746: }
96747:
96748: /* Generate a subroutine to run when the results from select B
96749: ** are exhausted and only data in select A remains.
96750: */
96751: if( op==TK_INTERSECT ){
96752: addrEofB = addrEofA;
96753: if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
96754: }else{
96755: VdbeNoopComment((v, "eof-B subroutine"));
96756: addrEofB = sqlite3VdbeAddOp2(v, OP_If, regEofA, labelEnd);
96757: sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
96758: sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
96759: sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofB);
96760: }
96761:
96762: /* Generate code to handle the case of A<B
96763: */
96764: VdbeNoopComment((v, "A-lt-B subroutine"));
96765: addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
96766: sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
96767: sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
96768: sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
96769:
96770: /* Generate code to handle the case of A==B
96771: */
96772: if( op==TK_ALL ){
96773: addrAeqB = addrAltB;
96774: }else if( op==TK_INTERSECT ){
96775: addrAeqB = addrAltB;
96776: addrAltB++;
96777: }else{
96778: VdbeNoopComment((v, "A-eq-B subroutine"));
96779: addrAeqB =
96780: sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
96781: sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
96782: sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
96783: }
96784:
96785: /* Generate code to handle the case of A>B
96786: */
96787: VdbeNoopComment((v, "A-gt-B subroutine"));
96788: addrAgtB = sqlite3VdbeCurrentAddr(v);
96789: if( op==TK_ALL || op==TK_UNION ){
96790: sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
96791: }
96792: sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
96793: sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
96794: sqlite3VdbeAddOp2(v, OP_Goto, 0, labelCmpr);
96795:
96796: /* This code runs once to initialize everything.
96797: */
96798: sqlite3VdbeJumpHere(v, j1);
96799: sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofA);
96800: sqlite3VdbeAddOp2(v, OP_Integer, 0, regEofB);
96801: sqlite3VdbeAddOp2(v, OP_Gosub, regAddrA, addrSelectA);
96802: sqlite3VdbeAddOp2(v, OP_Gosub, regAddrB, addrSelectB);
96803: sqlite3VdbeAddOp2(v, OP_If, regEofA, addrEofA);
96804: sqlite3VdbeAddOp2(v, OP_If, regEofB, addrEofB);
96805:
96806: /* Implement the main merge loop
96807: */
96808: sqlite3VdbeResolveLabel(v, labelCmpr);
96809: sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
96810: sqlite3VdbeAddOp4(v, OP_Compare, destA.iMem, destB.iMem, nOrderBy,
96811: (char*)pKeyMerge, P4_KEYINFO_HANDOFF);
96812: sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB);
96813:
96814: /* Release temporary registers
96815: */
96816: if( regPrev ){
96817: sqlite3ReleaseTempRange(pParse, regPrev, nOrderBy+1);
96818: }
96819:
96820: /* Jump to the this point in order to terminate the query.
96821: */
96822: sqlite3VdbeResolveLabel(v, labelEnd);
96823:
96824: /* Set the number of output columns
96825: */
96826: if( pDest->eDest==SRT_Output ){
96827: Select *pFirst = pPrior;
96828: while( pFirst->pPrior ) pFirst = pFirst->pPrior;
96829: generateColumnNames(pParse, 0, pFirst->pEList);
96830: }
96831:
96832: /* Reassembly the compound query so that it will be freed correctly
96833: ** by the calling function */
96834: if( p->pPrior ){
96835: sqlite3SelectDelete(db, p->pPrior);
96836: }
96837: p->pPrior = pPrior;
96838:
96839: /*** TBD: Insert subroutine calls to close cursors on incomplete
96840: **** subqueries ****/
96841: explainComposite(pParse, p->op, iSub1, iSub2, 0);
96842: return SQLITE_OK;
96843: }
96844: #endif
96845:
96846: #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
96847: /* Forward Declarations */
96848: static void substExprList(sqlite3*, ExprList*, int, ExprList*);
96849: static void substSelect(sqlite3*, Select *, int, ExprList *);
96850:
96851: /*
96852: ** Scan through the expression pExpr. Replace every reference to
96853: ** a column in table number iTable with a copy of the iColumn-th
96854: ** entry in pEList. (But leave references to the ROWID column
96855: ** unchanged.)
96856: **
96857: ** This routine is part of the flattening procedure. A subquery
96858: ** whose result set is defined by pEList appears as entry in the
96859: ** FROM clause of a SELECT such that the VDBE cursor assigned to that
96860: ** FORM clause entry is iTable. This routine make the necessary
96861: ** changes to pExpr so that it refers directly to the source table
96862: ** of the subquery rather the result set of the subquery.
96863: */
96864: static Expr *substExpr(
96865: sqlite3 *db, /* Report malloc errors to this connection */
96866: Expr *pExpr, /* Expr in which substitution occurs */
96867: int iTable, /* Table to be substituted */
96868: ExprList *pEList /* Substitute expressions */
96869: ){
96870: if( pExpr==0 ) return 0;
96871: if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
96872: if( pExpr->iColumn<0 ){
96873: pExpr->op = TK_NULL;
96874: }else{
96875: Expr *pNew;
96876: assert( pEList!=0 && pExpr->iColumn<pEList->nExpr );
96877: assert( pExpr->pLeft==0 && pExpr->pRight==0 );
96878: pNew = sqlite3ExprDup(db, pEList->a[pExpr->iColumn].pExpr, 0);
96879: if( pNew && pExpr->pColl ){
96880: pNew->pColl = pExpr->pColl;
96881: }
96882: sqlite3ExprDelete(db, pExpr);
96883: pExpr = pNew;
96884: }
96885: }else{
96886: pExpr->pLeft = substExpr(db, pExpr->pLeft, iTable, pEList);
96887: pExpr->pRight = substExpr(db, pExpr->pRight, iTable, pEList);
96888: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
96889: substSelect(db, pExpr->x.pSelect, iTable, pEList);
96890: }else{
96891: substExprList(db, pExpr->x.pList, iTable, pEList);
96892: }
96893: }
96894: return pExpr;
96895: }
96896: static void substExprList(
96897: sqlite3 *db, /* Report malloc errors here */
96898: ExprList *pList, /* List to scan and in which to make substitutes */
96899: int iTable, /* Table to be substituted */
96900: ExprList *pEList /* Substitute values */
96901: ){
96902: int i;
96903: if( pList==0 ) return;
96904: for(i=0; i<pList->nExpr; i++){
96905: pList->a[i].pExpr = substExpr(db, pList->a[i].pExpr, iTable, pEList);
96906: }
96907: }
96908: static void substSelect(
96909: sqlite3 *db, /* Report malloc errors here */
96910: Select *p, /* SELECT statement in which to make substitutions */
96911: int iTable, /* Table to be replaced */
96912: ExprList *pEList /* Substitute values */
96913: ){
96914: SrcList *pSrc;
96915: struct SrcList_item *pItem;
96916: int i;
96917: if( !p ) return;
96918: substExprList(db, p->pEList, iTable, pEList);
96919: substExprList(db, p->pGroupBy, iTable, pEList);
96920: substExprList(db, p->pOrderBy, iTable, pEList);
96921: p->pHaving = substExpr(db, p->pHaving, iTable, pEList);
96922: p->pWhere = substExpr(db, p->pWhere, iTable, pEList);
96923: substSelect(db, p->pPrior, iTable, pEList);
96924: pSrc = p->pSrc;
96925: assert( pSrc ); /* Even for (SELECT 1) we have: pSrc!=0 but pSrc->nSrc==0 */
96926: if( ALWAYS(pSrc) ){
96927: for(i=pSrc->nSrc, pItem=pSrc->a; i>0; i--, pItem++){
96928: substSelect(db, pItem->pSelect, iTable, pEList);
96929: }
96930: }
96931: }
96932: #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
96933:
96934: #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
96935: /*
96936: ** This routine attempts to flatten subqueries as a performance optimization.
96937: ** This routine returns 1 if it makes changes and 0 if no flattening occurs.
96938: **
96939: ** To understand the concept of flattening, consider the following
96940: ** query:
96941: **
96942: ** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5
96943: **
96944: ** The default way of implementing this query is to execute the
96945: ** subquery first and store the results in a temporary table, then
96946: ** run the outer query on that temporary table. This requires two
96947: ** passes over the data. Furthermore, because the temporary table
96948: ** has no indices, the WHERE clause on the outer query cannot be
96949: ** optimized.
96950: **
96951: ** This routine attempts to rewrite queries such as the above into
96952: ** a single flat select, like this:
96953: **
96954: ** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5
96955: **
96956: ** The code generated for this simpification gives the same result
96957: ** but only has to scan the data once. And because indices might
96958: ** exist on the table t1, a complete scan of the data might be
96959: ** avoided.
96960: **
96961: ** Flattening is only attempted if all of the following are true:
96962: **
96963: ** (1) The subquery and the outer query do not both use aggregates.
96964: **
96965: ** (2) The subquery is not an aggregate or the outer query is not a join.
96966: **
96967: ** (3) The subquery is not the right operand of a left outer join
96968: ** (Originally ticket #306. Strengthened by ticket #3300)
96969: **
96970: ** (4) The subquery is not DISTINCT.
96971: **
96972: ** (**) At one point restrictions (4) and (5) defined a subset of DISTINCT
96973: ** sub-queries that were excluded from this optimization. Restriction
96974: ** (4) has since been expanded to exclude all DISTINCT subqueries.
96975: **
96976: ** (6) The subquery does not use aggregates or the outer query is not
96977: ** DISTINCT.
96978: **
96979: ** (7) The subquery has a FROM clause. TODO: For subqueries without
96980: ** A FROM clause, consider adding a FROM close with the special
96981: ** table sqlite_once that consists of a single row containing a
96982: ** single NULL.
96983: **
96984: ** (8) The subquery does not use LIMIT or the outer query is not a join.
96985: **
96986: ** (9) The subquery does not use LIMIT or the outer query does not use
96987: ** aggregates.
96988: **
96989: ** (10) The subquery does not use aggregates or the outer query does not
96990: ** use LIMIT.
96991: **
96992: ** (11) The subquery and the outer query do not both have ORDER BY clauses.
96993: **
96994: ** (**) Not implemented. Subsumed into restriction (3). Was previously
96995: ** a separate restriction deriving from ticket #350.
96996: **
96997: ** (13) The subquery and outer query do not both use LIMIT.
96998: **
96999: ** (14) The subquery does not use OFFSET.
97000: **
97001: ** (15) The outer query is not part of a compound select or the
97002: ** subquery does not have a LIMIT clause.
97003: ** (See ticket #2339 and ticket [02a8e81d44]).
97004: **
97005: ** (16) The outer query is not an aggregate or the subquery does
97006: ** not contain ORDER BY. (Ticket #2942) This used to not matter
97007: ** until we introduced the group_concat() function.
97008: **
97009: ** (17) The sub-query is not a compound select, or it is a UNION ALL
97010: ** compound clause made up entirely of non-aggregate queries, and
97011: ** the parent query:
97012: **
97013: ** * is not itself part of a compound select,
97014: ** * is not an aggregate or DISTINCT query, and
97015: ** * is not a join
97016: **
97017: ** The parent and sub-query may contain WHERE clauses. Subject to
97018: ** rules (11), (13) and (14), they may also contain ORDER BY,
97019: ** LIMIT and OFFSET clauses. The subquery cannot use any compound
97020: ** operator other than UNION ALL because all the other compound
97021: ** operators have an implied DISTINCT which is disallowed by
97022: ** restriction (4).
97023: **
97024: ** (18) If the sub-query is a compound select, then all terms of the
97025: ** ORDER by clause of the parent must be simple references to
97026: ** columns of the sub-query.
97027: **
97028: ** (19) The subquery does not use LIMIT or the outer query does not
97029: ** have a WHERE clause.
97030: **
97031: ** (20) If the sub-query is a compound select, then it must not use
97032: ** an ORDER BY clause. Ticket #3773. We could relax this constraint
97033: ** somewhat by saying that the terms of the ORDER BY clause must
97034: ** appear as unmodified result columns in the outer query. But we
97035: ** have other optimizations in mind to deal with that case.
97036: **
97037: ** (21) The subquery does not use LIMIT or the outer query is not
97038: ** DISTINCT. (See ticket [752e1646fc]).
97039: **
97040: ** In this routine, the "p" parameter is a pointer to the outer query.
97041: ** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query
97042: ** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
97043: **
97044: ** If flattening is not attempted, this routine is a no-op and returns 0.
97045: ** If flattening is attempted this routine returns 1.
97046: **
97047: ** All of the expression analysis must occur on both the outer query and
97048: ** the subquery before this routine runs.
97049: */
97050: static int flattenSubquery(
97051: Parse *pParse, /* Parsing context */
97052: Select *p, /* The parent or outer SELECT statement */
97053: int iFrom, /* Index in p->pSrc->a[] of the inner subquery */
97054: int isAgg, /* True if outer SELECT uses aggregate functions */
97055: int subqueryIsAgg /* True if the subquery uses aggregate functions */
97056: ){
97057: const char *zSavedAuthContext = pParse->zAuthContext;
97058: Select *pParent;
97059: Select *pSub; /* The inner query or "subquery" */
97060: Select *pSub1; /* Pointer to the rightmost select in sub-query */
97061: SrcList *pSrc; /* The FROM clause of the outer query */
97062: SrcList *pSubSrc; /* The FROM clause of the subquery */
97063: ExprList *pList; /* The result set of the outer query */
97064: int iParent; /* VDBE cursor number of the pSub result set temp table */
97065: int i; /* Loop counter */
97066: Expr *pWhere; /* The WHERE clause */
97067: struct SrcList_item *pSubitem; /* The subquery */
97068: sqlite3 *db = pParse->db;
97069:
97070: /* Check to see if flattening is permitted. Return 0 if not.
97071: */
97072: assert( p!=0 );
97073: assert( p->pPrior==0 ); /* Unable to flatten compound queries */
97074: if( db->flags & SQLITE_QueryFlattener ) return 0;
97075: pSrc = p->pSrc;
97076: assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc );
97077: pSubitem = &pSrc->a[iFrom];
97078: iParent = pSubitem->iCursor;
97079: pSub = pSubitem->pSelect;
97080: assert( pSub!=0 );
97081: if( isAgg && subqueryIsAgg ) return 0; /* Restriction (1) */
97082: if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; /* Restriction (2) */
97083: pSubSrc = pSub->pSrc;
97084: assert( pSubSrc );
97085: /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
97086: ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
97087: ** because they could be computed at compile-time. But when LIMIT and OFFSET
97088: ** became arbitrary expressions, we were forced to add restrictions (13)
97089: ** and (14). */
97090: if( pSub->pLimit && p->pLimit ) return 0; /* Restriction (13) */
97091: if( pSub->pOffset ) return 0; /* Restriction (14) */
97092: if( p->pRightmost && pSub->pLimit ){
97093: return 0; /* Restriction (15) */
97094: }
97095: if( pSubSrc->nSrc==0 ) return 0; /* Restriction (7) */
97096: if( pSub->selFlags & SF_Distinct ) return 0; /* Restriction (5) */
97097: if( pSub->pLimit && (pSrc->nSrc>1 || isAgg) ){
97098: return 0; /* Restrictions (8)(9) */
97099: }
97100: if( (p->selFlags & SF_Distinct)!=0 && subqueryIsAgg ){
97101: return 0; /* Restriction (6) */
97102: }
97103: if( p->pOrderBy && pSub->pOrderBy ){
97104: return 0; /* Restriction (11) */
97105: }
97106: if( isAgg && pSub->pOrderBy ) return 0; /* Restriction (16) */
97107: if( pSub->pLimit && p->pWhere ) return 0; /* Restriction (19) */
97108: if( pSub->pLimit && (p->selFlags & SF_Distinct)!=0 ){
97109: return 0; /* Restriction (21) */
97110: }
97111:
97112: /* OBSOLETE COMMENT 1:
97113: ** Restriction 3: If the subquery is a join, make sure the subquery is
97114: ** not used as the right operand of an outer join. Examples of why this
97115: ** is not allowed:
97116: **
97117: ** t1 LEFT OUTER JOIN (t2 JOIN t3)
97118: **
97119: ** If we flatten the above, we would get
97120: **
97121: ** (t1 LEFT OUTER JOIN t2) JOIN t3
97122: **
97123: ** which is not at all the same thing.
97124: **
97125: ** OBSOLETE COMMENT 2:
97126: ** Restriction 12: If the subquery is the right operand of a left outer
97127: ** join, make sure the subquery has no WHERE clause.
97128: ** An examples of why this is not allowed:
97129: **
97130: ** t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0)
97131: **
97132: ** If we flatten the above, we would get
97133: **
97134: ** (t1 LEFT OUTER JOIN t2) WHERE t2.x>0
97135: **
97136: ** But the t2.x>0 test will always fail on a NULL row of t2, which
97137: ** effectively converts the OUTER JOIN into an INNER JOIN.
97138: **
97139: ** THIS OVERRIDES OBSOLETE COMMENTS 1 AND 2 ABOVE:
97140: ** Ticket #3300 shows that flattening the right term of a LEFT JOIN
97141: ** is fraught with danger. Best to avoid the whole thing. If the
97142: ** subquery is the right term of a LEFT JOIN, then do not flatten.
97143: */
97144: if( (pSubitem->jointype & JT_OUTER)!=0 ){
97145: return 0;
97146: }
97147:
97148: /* Restriction 17: If the sub-query is a compound SELECT, then it must
97149: ** use only the UNION ALL operator. And none of the simple select queries
97150: ** that make up the compound SELECT are allowed to be aggregate or distinct
97151: ** queries.
97152: */
97153: if( pSub->pPrior ){
97154: if( pSub->pOrderBy ){
97155: return 0; /* Restriction 20 */
97156: }
97157: if( isAgg || (p->selFlags & SF_Distinct)!=0 || pSrc->nSrc!=1 ){
97158: return 0;
97159: }
97160: for(pSub1=pSub; pSub1; pSub1=pSub1->pPrior){
97161: testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct );
97162: testcase( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))==SF_Aggregate );
97163: assert( pSub->pSrc!=0 );
97164: if( (pSub1->selFlags & (SF_Distinct|SF_Aggregate))!=0
97165: || (pSub1->pPrior && pSub1->op!=TK_ALL)
97166: || pSub1->pSrc->nSrc<1
97167: ){
97168: return 0;
97169: }
97170: testcase( pSub1->pSrc->nSrc>1 );
97171: }
97172:
97173: /* Restriction 18. */
97174: if( p->pOrderBy ){
97175: int ii;
97176: for(ii=0; ii<p->pOrderBy->nExpr; ii++){
97177: if( p->pOrderBy->a[ii].iOrderByCol==0 ) return 0;
97178: }
97179: }
97180: }
97181:
97182: /***** If we reach this point, flattening is permitted. *****/
97183:
97184: /* Authorize the subquery */
97185: pParse->zAuthContext = pSubitem->zName;
97186: sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0);
97187: pParse->zAuthContext = zSavedAuthContext;
97188:
97189: /* If the sub-query is a compound SELECT statement, then (by restrictions
97190: ** 17 and 18 above) it must be a UNION ALL and the parent query must
97191: ** be of the form:
97192: **
97193: ** SELECT <expr-list> FROM (<sub-query>) <where-clause>
97194: **
97195: ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
97196: ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
97197: ** OFFSET clauses and joins them to the left-hand-side of the original
97198: ** using UNION ALL operators. In this case N is the number of simple
97199: ** select statements in the compound sub-query.
97200: **
97201: ** Example:
97202: **
97203: ** SELECT a+1 FROM (
97204: ** SELECT x FROM tab
97205: ** UNION ALL
97206: ** SELECT y FROM tab
97207: ** UNION ALL
97208: ** SELECT abs(z*2) FROM tab2
97209: ** ) WHERE a!=5 ORDER BY 1
97210: **
97211: ** Transformed into:
97212: **
97213: ** SELECT x+1 FROM tab WHERE x+1!=5
97214: ** UNION ALL
97215: ** SELECT y+1 FROM tab WHERE y+1!=5
97216: ** UNION ALL
97217: ** SELECT abs(z*2)+1 FROM tab2 WHERE abs(z*2)+1!=5
97218: ** ORDER BY 1
97219: **
97220: ** We call this the "compound-subquery flattening".
97221: */
97222: for(pSub=pSub->pPrior; pSub; pSub=pSub->pPrior){
97223: Select *pNew;
97224: ExprList *pOrderBy = p->pOrderBy;
97225: Expr *pLimit = p->pLimit;
97226: Select *pPrior = p->pPrior;
97227: p->pOrderBy = 0;
97228: p->pSrc = 0;
97229: p->pPrior = 0;
97230: p->pLimit = 0;
97231: pNew = sqlite3SelectDup(db, p, 0);
97232: p->pLimit = pLimit;
97233: p->pOrderBy = pOrderBy;
97234: p->pSrc = pSrc;
97235: p->op = TK_ALL;
97236: p->pRightmost = 0;
97237: if( pNew==0 ){
97238: pNew = pPrior;
97239: }else{
97240: pNew->pPrior = pPrior;
97241: pNew->pRightmost = 0;
97242: }
97243: p->pPrior = pNew;
97244: if( db->mallocFailed ) return 1;
97245: }
97246:
97247: /* Begin flattening the iFrom-th entry of the FROM clause
97248: ** in the outer query.
97249: */
97250: pSub = pSub1 = pSubitem->pSelect;
97251:
97252: /* Delete the transient table structure associated with the
97253: ** subquery
97254: */
97255: sqlite3DbFree(db, pSubitem->zDatabase);
97256: sqlite3DbFree(db, pSubitem->zName);
97257: sqlite3DbFree(db, pSubitem->zAlias);
97258: pSubitem->zDatabase = 0;
97259: pSubitem->zName = 0;
97260: pSubitem->zAlias = 0;
97261: pSubitem->pSelect = 0;
97262:
97263: /* Defer deleting the Table object associated with the
97264: ** subquery until code generation is
97265: ** complete, since there may still exist Expr.pTab entries that
97266: ** refer to the subquery even after flattening. Ticket #3346.
97267: **
97268: ** pSubitem->pTab is always non-NULL by test restrictions and tests above.
97269: */
97270: if( ALWAYS(pSubitem->pTab!=0) ){
97271: Table *pTabToDel = pSubitem->pTab;
97272: if( pTabToDel->nRef==1 ){
97273: Parse *pToplevel = sqlite3ParseToplevel(pParse);
97274: pTabToDel->pNextZombie = pToplevel->pZombieTab;
97275: pToplevel->pZombieTab = pTabToDel;
97276: }else{
97277: pTabToDel->nRef--;
97278: }
97279: pSubitem->pTab = 0;
97280: }
97281:
97282: /* The following loop runs once for each term in a compound-subquery
97283: ** flattening (as described above). If we are doing a different kind
97284: ** of flattening - a flattening other than a compound-subquery flattening -
97285: ** then this loop only runs once.
97286: **
97287: ** This loop moves all of the FROM elements of the subquery into the
97288: ** the FROM clause of the outer query. Before doing this, remember
97289: ** the cursor number for the original outer query FROM element in
97290: ** iParent. The iParent cursor will never be used. Subsequent code
97291: ** will scan expressions looking for iParent references and replace
97292: ** those references with expressions that resolve to the subquery FROM
97293: ** elements we are now copying in.
97294: */
97295: for(pParent=p; pParent; pParent=pParent->pPrior, pSub=pSub->pPrior){
97296: int nSubSrc;
97297: u8 jointype = 0;
97298: pSubSrc = pSub->pSrc; /* FROM clause of subquery */
97299: nSubSrc = pSubSrc->nSrc; /* Number of terms in subquery FROM clause */
97300: pSrc = pParent->pSrc; /* FROM clause of the outer query */
97301:
97302: if( pSrc ){
97303: assert( pParent==p ); /* First time through the loop */
97304: jointype = pSubitem->jointype;
97305: }else{
97306: assert( pParent!=p ); /* 2nd and subsequent times through the loop */
97307: pSrc = pParent->pSrc = sqlite3SrcListAppend(db, 0, 0, 0);
97308: if( pSrc==0 ){
97309: assert( db->mallocFailed );
97310: break;
97311: }
97312: }
97313:
97314: /* The subquery uses a single slot of the FROM clause of the outer
97315: ** query. If the subquery has more than one element in its FROM clause,
97316: ** then expand the outer query to make space for it to hold all elements
97317: ** of the subquery.
97318: **
97319: ** Example:
97320: **
97321: ** SELECT * FROM tabA, (SELECT * FROM sub1, sub2), tabB;
97322: **
97323: ** The outer query has 3 slots in its FROM clause. One slot of the
97324: ** outer query (the middle slot) is used by the subquery. The next
97325: ** block of code will expand the out query to 4 slots. The middle
97326: ** slot is expanded to two slots in order to make space for the
97327: ** two elements in the FROM clause of the subquery.
97328: */
97329: if( nSubSrc>1 ){
97330: pParent->pSrc = pSrc = sqlite3SrcListEnlarge(db, pSrc, nSubSrc-1,iFrom+1);
97331: if( db->mallocFailed ){
97332: break;
97333: }
97334: }
97335:
97336: /* Transfer the FROM clause terms from the subquery into the
97337: ** outer query.
97338: */
97339: for(i=0; i<nSubSrc; i++){
97340: sqlite3IdListDelete(db, pSrc->a[i+iFrom].pUsing);
97341: pSrc->a[i+iFrom] = pSubSrc->a[i];
97342: memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i]));
97343: }
97344: pSrc->a[iFrom].jointype = jointype;
97345:
97346: /* Now begin substituting subquery result set expressions for
97347: ** references to the iParent in the outer query.
97348: **
97349: ** Example:
97350: **
97351: ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b;
97352: ** \ \_____________ subquery __________/ /
97353: ** \_____________________ outer query ______________________________/
97354: **
97355: ** We look at every expression in the outer query and every place we see
97356: ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10".
97357: */
97358: pList = pParent->pEList;
97359: for(i=0; i<pList->nExpr; i++){
97360: if( pList->a[i].zName==0 ){
97361: const char *zSpan = pList->a[i].zSpan;
97362: if( ALWAYS(zSpan) ){
97363: pList->a[i].zName = sqlite3DbStrDup(db, zSpan);
97364: }
97365: }
97366: }
97367: substExprList(db, pParent->pEList, iParent, pSub->pEList);
97368: if( isAgg ){
97369: substExprList(db, pParent->pGroupBy, iParent, pSub->pEList);
97370: pParent->pHaving = substExpr(db, pParent->pHaving, iParent, pSub->pEList);
97371: }
97372: if( pSub->pOrderBy ){
97373: assert( pParent->pOrderBy==0 );
97374: pParent->pOrderBy = pSub->pOrderBy;
97375: pSub->pOrderBy = 0;
97376: }else if( pParent->pOrderBy ){
97377: substExprList(db, pParent->pOrderBy, iParent, pSub->pEList);
97378: }
97379: if( pSub->pWhere ){
97380: pWhere = sqlite3ExprDup(db, pSub->pWhere, 0);
97381: }else{
97382: pWhere = 0;
97383: }
97384: if( subqueryIsAgg ){
97385: assert( pParent->pHaving==0 );
97386: pParent->pHaving = pParent->pWhere;
97387: pParent->pWhere = pWhere;
97388: pParent->pHaving = substExpr(db, pParent->pHaving, iParent, pSub->pEList);
97389: pParent->pHaving = sqlite3ExprAnd(db, pParent->pHaving,
97390: sqlite3ExprDup(db, pSub->pHaving, 0));
97391: assert( pParent->pGroupBy==0 );
97392: pParent->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy, 0);
97393: }else{
97394: pParent->pWhere = substExpr(db, pParent->pWhere, iParent, pSub->pEList);
97395: pParent->pWhere = sqlite3ExprAnd(db, pParent->pWhere, pWhere);
97396: }
97397:
97398: /* The flattened query is distinct if either the inner or the
97399: ** outer query is distinct.
97400: */
97401: pParent->selFlags |= pSub->selFlags & SF_Distinct;
97402:
97403: /*
97404: ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
97405: **
97406: ** One is tempted to try to add a and b to combine the limits. But this
97407: ** does not work if either limit is negative.
97408: */
97409: if( pSub->pLimit ){
97410: pParent->pLimit = pSub->pLimit;
97411: pSub->pLimit = 0;
97412: }
97413: }
97414:
97415: /* Finially, delete what is left of the subquery and return
97416: ** success.
97417: */
97418: sqlite3SelectDelete(db, pSub1);
97419:
97420: return 1;
97421: }
97422: #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
97423:
97424: /*
97425: ** Analyze the SELECT statement passed as an argument to see if it
97426: ** is a min() or max() query. Return WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX if
97427: ** it is, or 0 otherwise. At present, a query is considered to be
97428: ** a min()/max() query if:
97429: **
97430: ** 1. There is a single object in the FROM clause.
97431: **
97432: ** 2. There is a single expression in the result set, and it is
97433: ** either min(x) or max(x), where x is a column reference.
97434: */
97435: static u8 minMaxQuery(Select *p){
97436: Expr *pExpr;
97437: ExprList *pEList = p->pEList;
97438:
97439: if( pEList->nExpr!=1 ) return WHERE_ORDERBY_NORMAL;
97440: pExpr = pEList->a[0].pExpr;
97441: if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
97442: if( NEVER(ExprHasProperty(pExpr, EP_xIsSelect)) ) return 0;
97443: pEList = pExpr->x.pList;
97444: if( pEList==0 || pEList->nExpr!=1 ) return 0;
97445: if( pEList->a[0].pExpr->op!=TK_AGG_COLUMN ) return WHERE_ORDERBY_NORMAL;
97446: assert( !ExprHasProperty(pExpr, EP_IntValue) );
97447: if( sqlite3StrICmp(pExpr->u.zToken,"min")==0 ){
97448: return WHERE_ORDERBY_MIN;
97449: }else if( sqlite3StrICmp(pExpr->u.zToken,"max")==0 ){
97450: return WHERE_ORDERBY_MAX;
97451: }
97452: return WHERE_ORDERBY_NORMAL;
97453: }
97454:
97455: /*
97456: ** The select statement passed as the first argument is an aggregate query.
97457: ** The second argment is the associated aggregate-info object. This
97458: ** function tests if the SELECT is of the form:
97459: **
97460: ** SELECT count(*) FROM <tbl>
97461: **
97462: ** where table is a database table, not a sub-select or view. If the query
97463: ** does match this pattern, then a pointer to the Table object representing
97464: ** <tbl> is returned. Otherwise, 0 is returned.
97465: */
97466: static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
97467: Table *pTab;
97468: Expr *pExpr;
97469:
97470: assert( !p->pGroupBy );
97471:
97472: if( p->pWhere || p->pEList->nExpr!=1
97473: || p->pSrc->nSrc!=1 || p->pSrc->a[0].pSelect
97474: ){
97475: return 0;
97476: }
97477: pTab = p->pSrc->a[0].pTab;
97478: pExpr = p->pEList->a[0].pExpr;
97479: assert( pTab && !pTab->pSelect && pExpr );
97480:
97481: if( IsVirtual(pTab) ) return 0;
97482: if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
97483: if( (pAggInfo->aFunc[0].pFunc->flags&SQLITE_FUNC_COUNT)==0 ) return 0;
97484: if( pExpr->flags&EP_Distinct ) return 0;
97485:
97486: return pTab;
97487: }
97488:
97489: /*
97490: ** If the source-list item passed as an argument was augmented with an
97491: ** INDEXED BY clause, then try to locate the specified index. If there
97492: ** was such a clause and the named index cannot be found, return
97493: ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
97494: ** pFrom->pIndex and return SQLITE_OK.
97495: */
97496: SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
97497: if( pFrom->pTab && pFrom->zIndex ){
97498: Table *pTab = pFrom->pTab;
97499: char *zIndex = pFrom->zIndex;
97500: Index *pIdx;
97501: for(pIdx=pTab->pIndex;
97502: pIdx && sqlite3StrICmp(pIdx->zName, zIndex);
97503: pIdx=pIdx->pNext
97504: );
97505: if( !pIdx ){
97506: sqlite3ErrorMsg(pParse, "no such index: %s", zIndex, 0);
97507: pParse->checkSchema = 1;
97508: return SQLITE_ERROR;
97509: }
97510: pFrom->pIndex = pIdx;
97511: }
97512: return SQLITE_OK;
97513: }
97514:
97515: /*
97516: ** This routine is a Walker callback for "expanding" a SELECT statement.
97517: ** "Expanding" means to do the following:
97518: **
97519: ** (1) Make sure VDBE cursor numbers have been assigned to every
97520: ** element of the FROM clause.
97521: **
97522: ** (2) Fill in the pTabList->a[].pTab fields in the SrcList that
97523: ** defines FROM clause. When views appear in the FROM clause,
97524: ** fill pTabList->a[].pSelect with a copy of the SELECT statement
97525: ** that implements the view. A copy is made of the view's SELECT
97526: ** statement so that we can freely modify or delete that statement
97527: ** without worrying about messing up the presistent representation
97528: ** of the view.
97529: **
97530: ** (3) Add terms to the WHERE clause to accomodate the NATURAL keyword
97531: ** on joins and the ON and USING clause of joins.
97532: **
97533: ** (4) Scan the list of columns in the result set (pEList) looking
97534: ** for instances of the "*" operator or the TABLE.* operator.
97535: ** If found, expand each "*" to be every column in every table
97536: ** and TABLE.* to be every column in TABLE.
97537: **
97538: */
97539: static int selectExpander(Walker *pWalker, Select *p){
97540: Parse *pParse = pWalker->pParse;
97541: int i, j, k;
97542: SrcList *pTabList;
97543: ExprList *pEList;
97544: struct SrcList_item *pFrom;
97545: sqlite3 *db = pParse->db;
97546:
97547: if( db->mallocFailed ){
97548: return WRC_Abort;
97549: }
97550: if( NEVER(p->pSrc==0) || (p->selFlags & SF_Expanded)!=0 ){
97551: return WRC_Prune;
97552: }
97553: p->selFlags |= SF_Expanded;
97554: pTabList = p->pSrc;
97555: pEList = p->pEList;
97556:
97557: /* Make sure cursor numbers have been assigned to all entries in
97558: ** the FROM clause of the SELECT statement.
97559: */
97560: sqlite3SrcListAssignCursors(pParse, pTabList);
97561:
97562: /* Look up every table named in the FROM clause of the select. If
97563: ** an entry of the FROM clause is a subquery instead of a table or view,
97564: ** then create a transient table structure to describe the subquery.
97565: */
97566: for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
97567: Table *pTab;
97568: if( pFrom->pTab!=0 ){
97569: /* This statement has already been prepared. There is no need
97570: ** to go further. */
97571: assert( i==0 );
97572: return WRC_Prune;
97573: }
97574: if( pFrom->zName==0 ){
97575: #ifndef SQLITE_OMIT_SUBQUERY
97576: Select *pSel = pFrom->pSelect;
97577: /* A sub-query in the FROM clause of a SELECT */
97578: assert( pSel!=0 );
97579: assert( pFrom->pTab==0 );
97580: sqlite3WalkSelect(pWalker, pSel);
97581: pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
97582: if( pTab==0 ) return WRC_Abort;
97583: pTab->nRef = 1;
97584: pTab->zName = sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pTab);
97585: while( pSel->pPrior ){ pSel = pSel->pPrior; }
97586: selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
97587: pTab->iPKey = -1;
97588: pTab->nRowEst = 1000000;
97589: pTab->tabFlags |= TF_Ephemeral;
97590: #endif
97591: }else{
97592: /* An ordinary table or view name in the FROM clause */
97593: assert( pFrom->pTab==0 );
97594: pFrom->pTab = pTab =
97595: sqlite3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase);
97596: if( pTab==0 ) return WRC_Abort;
97597: pTab->nRef++;
97598: #if !defined(SQLITE_OMIT_VIEW) || !defined (SQLITE_OMIT_VIRTUALTABLE)
97599: if( pTab->pSelect || IsVirtual(pTab) ){
97600: /* We reach here if the named table is a really a view */
97601: if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
97602: assert( pFrom->pSelect==0 );
97603: pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
97604: sqlite3WalkSelect(pWalker, pFrom->pSelect);
97605: }
97606: #endif
97607: }
97608:
97609: /* Locate the index named by the INDEXED BY clause, if any. */
97610: if( sqlite3IndexedByLookup(pParse, pFrom) ){
97611: return WRC_Abort;
97612: }
97613: }
97614:
97615: /* Process NATURAL keywords, and ON and USING clauses of joins.
97616: */
97617: if( db->mallocFailed || sqliteProcessJoin(pParse, p) ){
97618: return WRC_Abort;
97619: }
97620:
97621: /* For every "*" that occurs in the column list, insert the names of
97622: ** all columns in all tables. And for every TABLE.* insert the names
97623: ** of all columns in TABLE. The parser inserted a special expression
97624: ** with the TK_ALL operator for each "*" that it found in the column list.
97625: ** The following code just has to locate the TK_ALL expressions and expand
97626: ** each one to the list of all columns in all tables.
97627: **
97628: ** The first loop just checks to see if there are any "*" operators
97629: ** that need expanding.
97630: */
97631: for(k=0; k<pEList->nExpr; k++){
97632: Expr *pE = pEList->a[k].pExpr;
97633: if( pE->op==TK_ALL ) break;
97634: assert( pE->op!=TK_DOT || pE->pRight!=0 );
97635: assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
97636: if( pE->op==TK_DOT && pE->pRight->op==TK_ALL ) break;
97637: }
97638: if( k<pEList->nExpr ){
97639: /*
97640: ** If we get here it means the result set contains one or more "*"
97641: ** operators that need to be expanded. Loop through each expression
97642: ** in the result set and expand them one by one.
97643: */
97644: struct ExprList_item *a = pEList->a;
97645: ExprList *pNew = 0;
97646: int flags = pParse->db->flags;
97647: int longNames = (flags & SQLITE_FullColNames)!=0
97648: && (flags & SQLITE_ShortColNames)==0;
97649:
97650: for(k=0; k<pEList->nExpr; k++){
97651: Expr *pE = a[k].pExpr;
97652: assert( pE->op!=TK_DOT || pE->pRight!=0 );
97653: if( pE->op!=TK_ALL && (pE->op!=TK_DOT || pE->pRight->op!=TK_ALL) ){
97654: /* This particular expression does not need to be expanded.
97655: */
97656: pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
97657: if( pNew ){
97658: pNew->a[pNew->nExpr-1].zName = a[k].zName;
97659: pNew->a[pNew->nExpr-1].zSpan = a[k].zSpan;
97660: a[k].zName = 0;
97661: a[k].zSpan = 0;
97662: }
97663: a[k].pExpr = 0;
97664: }else{
97665: /* This expression is a "*" or a "TABLE.*" and needs to be
97666: ** expanded. */
97667: int tableSeen = 0; /* Set to 1 when TABLE matches */
97668: char *zTName; /* text of name of TABLE */
97669: if( pE->op==TK_DOT ){
97670: assert( pE->pLeft!=0 );
97671: assert( !ExprHasProperty(pE->pLeft, EP_IntValue) );
97672: zTName = pE->pLeft->u.zToken;
97673: }else{
97674: zTName = 0;
97675: }
97676: for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
97677: Table *pTab = pFrom->pTab;
97678: char *zTabName = pFrom->zAlias;
97679: if( zTabName==0 ){
97680: zTabName = pTab->zName;
97681: }
97682: if( db->mallocFailed ) break;
97683: if( zTName && sqlite3StrICmp(zTName, zTabName)!=0 ){
97684: continue;
97685: }
97686: tableSeen = 1;
97687: for(j=0; j<pTab->nCol; j++){
97688: Expr *pExpr, *pRight;
97689: char *zName = pTab->aCol[j].zName;
97690: char *zColname; /* The computed column name */
97691: char *zToFree; /* Malloced string that needs to be freed */
97692: Token sColname; /* Computed column name as a token */
97693:
97694: /* If a column is marked as 'hidden' (currently only possible
97695: ** for virtual tables), do not include it in the expanded
97696: ** result-set list.
97697: */
97698: if( IsHiddenColumn(&pTab->aCol[j]) ){
97699: assert(IsVirtual(pTab));
97700: continue;
97701: }
97702:
97703: if( i>0 && zTName==0 ){
97704: if( (pFrom->jointype & JT_NATURAL)!=0
97705: && tableAndColumnIndex(pTabList, i, zName, 0, 0)
97706: ){
97707: /* In a NATURAL join, omit the join columns from the
97708: ** table to the right of the join */
97709: continue;
97710: }
97711: if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
97712: /* In a join with a USING clause, omit columns in the
97713: ** using clause from the table on the right. */
97714: continue;
97715: }
97716: }
97717: pRight = sqlite3Expr(db, TK_ID, zName);
97718: zColname = zName;
97719: zToFree = 0;
97720: if( longNames || pTabList->nSrc>1 ){
97721: Expr *pLeft;
97722: pLeft = sqlite3Expr(db, TK_ID, zTabName);
97723: pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
97724: if( longNames ){
97725: zColname = sqlite3MPrintf(db, "%s.%s", zTabName, zName);
97726: zToFree = zColname;
97727: }
97728: }else{
97729: pExpr = pRight;
97730: }
97731: pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
97732: sColname.z = zColname;
97733: sColname.n = sqlite3Strlen30(zColname);
97734: sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
97735: sqlite3DbFree(db, zToFree);
97736: }
97737: }
97738: if( !tableSeen ){
97739: if( zTName ){
97740: sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
97741: }else{
97742: sqlite3ErrorMsg(pParse, "no tables specified");
97743: }
97744: }
97745: }
97746: }
97747: sqlite3ExprListDelete(db, pEList);
97748: p->pEList = pNew;
97749: }
97750: #if SQLITE_MAX_COLUMN
97751: if( p->pEList && p->pEList->nExpr>db->aLimit[SQLITE_LIMIT_COLUMN] ){
97752: sqlite3ErrorMsg(pParse, "too many columns in result set");
97753: }
97754: #endif
97755: return WRC_Continue;
97756: }
97757:
97758: /*
97759: ** No-op routine for the parse-tree walker.
97760: **
97761: ** When this routine is the Walker.xExprCallback then expression trees
97762: ** are walked without any actions being taken at each node. Presumably,
97763: ** when this routine is used for Walker.xExprCallback then
97764: ** Walker.xSelectCallback is set to do something useful for every
97765: ** subquery in the parser tree.
97766: */
97767: static int exprWalkNoop(Walker *NotUsed, Expr *NotUsed2){
97768: UNUSED_PARAMETER2(NotUsed, NotUsed2);
97769: return WRC_Continue;
97770: }
97771:
97772: /*
97773: ** This routine "expands" a SELECT statement and all of its subqueries.
97774: ** For additional information on what it means to "expand" a SELECT
97775: ** statement, see the comment on the selectExpand worker callback above.
97776: **
97777: ** Expanding a SELECT statement is the first step in processing a
97778: ** SELECT statement. The SELECT statement must be expanded before
97779: ** name resolution is performed.
97780: **
97781: ** If anything goes wrong, an error message is written into pParse.
97782: ** The calling function can detect the problem by looking at pParse->nErr
97783: ** and/or pParse->db->mallocFailed.
97784: */
97785: static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
97786: Walker w;
97787: w.xSelectCallback = selectExpander;
97788: w.xExprCallback = exprWalkNoop;
97789: w.pParse = pParse;
97790: sqlite3WalkSelect(&w, pSelect);
97791: }
97792:
97793:
97794: #ifndef SQLITE_OMIT_SUBQUERY
97795: /*
97796: ** This is a Walker.xSelectCallback callback for the sqlite3SelectTypeInfo()
97797: ** interface.
97798: **
97799: ** For each FROM-clause subquery, add Column.zType and Column.zColl
97800: ** information to the Table structure that represents the result set
97801: ** of that subquery.
97802: **
97803: ** The Table structure that represents the result set was constructed
97804: ** by selectExpander() but the type and collation information was omitted
97805: ** at that point because identifiers had not yet been resolved. This
97806: ** routine is called after identifier resolution.
97807: */
97808: static int selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
97809: Parse *pParse;
97810: int i;
97811: SrcList *pTabList;
97812: struct SrcList_item *pFrom;
97813:
97814: assert( p->selFlags & SF_Resolved );
97815: if( (p->selFlags & SF_HasTypeInfo)==0 ){
97816: p->selFlags |= SF_HasTypeInfo;
97817: pParse = pWalker->pParse;
97818: pTabList = p->pSrc;
97819: for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
97820: Table *pTab = pFrom->pTab;
97821: if( ALWAYS(pTab!=0) && (pTab->tabFlags & TF_Ephemeral)!=0 ){
97822: /* A sub-query in the FROM clause of a SELECT */
97823: Select *pSel = pFrom->pSelect;
97824: assert( pSel );
97825: while( pSel->pPrior ) pSel = pSel->pPrior;
97826: selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSel);
97827: }
97828: }
97829: }
97830: return WRC_Continue;
97831: }
97832: #endif
97833:
97834:
97835: /*
97836: ** This routine adds datatype and collating sequence information to
97837: ** the Table structures of all FROM-clause subqueries in a
97838: ** SELECT statement.
97839: **
97840: ** Use this routine after name resolution.
97841: */
97842: static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
97843: #ifndef SQLITE_OMIT_SUBQUERY
97844: Walker w;
97845: w.xSelectCallback = selectAddSubqueryTypeInfo;
97846: w.xExprCallback = exprWalkNoop;
97847: w.pParse = pParse;
97848: sqlite3WalkSelect(&w, pSelect);
97849: #endif
97850: }
97851:
97852:
97853: /*
97854: ** This routine sets of a SELECT statement for processing. The
97855: ** following is accomplished:
97856: **
97857: ** * VDBE Cursor numbers are assigned to all FROM-clause terms.
97858: ** * Ephemeral Table objects are created for all FROM-clause subqueries.
97859: ** * ON and USING clauses are shifted into WHERE statements
97860: ** * Wildcards "*" and "TABLE.*" in result sets are expanded.
97861: ** * Identifiers in expression are matched to tables.
97862: **
97863: ** This routine acts recursively on all subqueries within the SELECT.
97864: */
97865: SQLITE_PRIVATE void sqlite3SelectPrep(
97866: Parse *pParse, /* The parser context */
97867: Select *p, /* The SELECT statement being coded. */
97868: NameContext *pOuterNC /* Name context for container */
97869: ){
97870: sqlite3 *db;
97871: if( NEVER(p==0) ) return;
97872: db = pParse->db;
97873: if( p->selFlags & SF_HasTypeInfo ) return;
97874: sqlite3SelectExpand(pParse, p);
97875: if( pParse->nErr || db->mallocFailed ) return;
97876: sqlite3ResolveSelectNames(pParse, p, pOuterNC);
97877: if( pParse->nErr || db->mallocFailed ) return;
97878: sqlite3SelectAddTypeInfo(pParse, p);
97879: }
97880:
97881: /*
97882: ** Reset the aggregate accumulator.
97883: **
97884: ** The aggregate accumulator is a set of memory cells that hold
97885: ** intermediate results while calculating an aggregate. This
97886: ** routine simply stores NULLs in all of those memory cells.
97887: */
97888: static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
97889: Vdbe *v = pParse->pVdbe;
97890: int i;
97891: struct AggInfo_func *pFunc;
97892: if( pAggInfo->nFunc+pAggInfo->nColumn==0 ){
97893: return;
97894: }
97895: for(i=0; i<pAggInfo->nColumn; i++){
97896: sqlite3VdbeAddOp2(v, OP_Null, 0, pAggInfo->aCol[i].iMem);
97897: }
97898: for(pFunc=pAggInfo->aFunc, i=0; i<pAggInfo->nFunc; i++, pFunc++){
97899: sqlite3VdbeAddOp2(v, OP_Null, 0, pFunc->iMem);
97900: if( pFunc->iDistinct>=0 ){
97901: Expr *pE = pFunc->pExpr;
97902: assert( !ExprHasProperty(pE, EP_xIsSelect) );
97903: if( pE->x.pList==0 || pE->x.pList->nExpr!=1 ){
97904: sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
97905: "argument");
97906: pFunc->iDistinct = -1;
97907: }else{
97908: KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->x.pList);
97909: sqlite3VdbeAddOp4(v, OP_OpenEphemeral, pFunc->iDistinct, 0, 0,
97910: (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
97911: }
97912: }
97913: }
97914: }
97915:
97916: /*
97917: ** Invoke the OP_AggFinalize opcode for every aggregate function
97918: ** in the AggInfo structure.
97919: */
97920: static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
97921: Vdbe *v = pParse->pVdbe;
97922: int i;
97923: struct AggInfo_func *pF;
97924: for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
97925: ExprList *pList = pF->pExpr->x.pList;
97926: assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
97927: sqlite3VdbeAddOp4(v, OP_AggFinal, pF->iMem, pList ? pList->nExpr : 0, 0,
97928: (void*)pF->pFunc, P4_FUNCDEF);
97929: }
97930: }
97931:
97932: /*
97933: ** Update the accumulator memory cells for an aggregate based on
97934: ** the current cursor position.
97935: */
97936: static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
97937: Vdbe *v = pParse->pVdbe;
97938: int i;
97939: struct AggInfo_func *pF;
97940: struct AggInfo_col *pC;
97941:
97942: pAggInfo->directMode = 1;
97943: sqlite3ExprCacheClear(pParse);
97944: for(i=0, pF=pAggInfo->aFunc; i<pAggInfo->nFunc; i++, pF++){
97945: int nArg;
97946: int addrNext = 0;
97947: int regAgg;
97948: ExprList *pList = pF->pExpr->x.pList;
97949: assert( !ExprHasProperty(pF->pExpr, EP_xIsSelect) );
97950: if( pList ){
97951: nArg = pList->nExpr;
97952: regAgg = sqlite3GetTempRange(pParse, nArg);
97953: sqlite3ExprCodeExprList(pParse, pList, regAgg, 1);
97954: }else{
97955: nArg = 0;
97956: regAgg = 0;
97957: }
97958: if( pF->iDistinct>=0 ){
97959: addrNext = sqlite3VdbeMakeLabel(v);
97960: assert( nArg==1 );
97961: codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
97962: }
97963: if( pF->pFunc->flags & SQLITE_FUNC_NEEDCOLL ){
97964: CollSeq *pColl = 0;
97965: struct ExprList_item *pItem;
97966: int j;
97967: assert( pList!=0 ); /* pList!=0 if pF->pFunc has NEEDCOLL */
97968: for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
97969: pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
97970: }
97971: if( !pColl ){
97972: pColl = pParse->db->pDfltColl;
97973: }
97974: sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
97975: }
97976: sqlite3VdbeAddOp4(v, OP_AggStep, 0, regAgg, pF->iMem,
97977: (void*)pF->pFunc, P4_FUNCDEF);
97978: sqlite3VdbeChangeP5(v, (u8)nArg);
97979: sqlite3ExprCacheAffinityChange(pParse, regAgg, nArg);
97980: sqlite3ReleaseTempRange(pParse, regAgg, nArg);
97981: if( addrNext ){
97982: sqlite3VdbeResolveLabel(v, addrNext);
97983: sqlite3ExprCacheClear(pParse);
97984: }
97985: }
97986:
97987: /* Before populating the accumulator registers, clear the column cache.
97988: ** Otherwise, if any of the required column values are already present
97989: ** in registers, sqlite3ExprCode() may use OP_SCopy to copy the value
97990: ** to pC->iMem. But by the time the value is used, the original register
97991: ** may have been used, invalidating the underlying buffer holding the
97992: ** text or blob value. See ticket [883034dcb5].
97993: **
97994: ** Another solution would be to change the OP_SCopy used to copy cached
97995: ** values to an OP_Copy.
97996: */
97997: sqlite3ExprCacheClear(pParse);
97998: for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
97999: sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
98000: }
98001: pAggInfo->directMode = 0;
98002: sqlite3ExprCacheClear(pParse);
98003: }
98004:
98005: /*
98006: ** Add a single OP_Explain instruction to the VDBE to explain a simple
98007: ** count(*) query ("SELECT count(*) FROM pTab").
98008: */
98009: #ifndef SQLITE_OMIT_EXPLAIN
98010: static void explainSimpleCount(
98011: Parse *pParse, /* Parse context */
98012: Table *pTab, /* Table being queried */
98013: Index *pIdx /* Index used to optimize scan, or NULL */
98014: ){
98015: if( pParse->explain==2 ){
98016: char *zEqp = sqlite3MPrintf(pParse->db, "SCAN TABLE %s %s%s(~%d rows)",
98017: pTab->zName,
98018: pIdx ? "USING COVERING INDEX " : "",
98019: pIdx ? pIdx->zName : "",
98020: pTab->nRowEst
98021: );
98022: sqlite3VdbeAddOp4(
98023: pParse->pVdbe, OP_Explain, pParse->iSelectId, 0, 0, zEqp, P4_DYNAMIC
98024: );
98025: }
98026: }
98027: #else
98028: # define explainSimpleCount(a,b,c)
98029: #endif
98030:
98031: /*
98032: ** Generate code for the SELECT statement given in the p argument.
98033: **
98034: ** The results are distributed in various ways depending on the
98035: ** contents of the SelectDest structure pointed to by argument pDest
98036: ** as follows:
98037: **
98038: ** pDest->eDest Result
98039: ** ------------ -------------------------------------------
98040: ** SRT_Output Generate a row of output (using the OP_ResultRow
98041: ** opcode) for each row in the result set.
98042: **
98043: ** SRT_Mem Only valid if the result is a single column.
98044: ** Store the first column of the first result row
98045: ** in register pDest->iParm then abandon the rest
98046: ** of the query. This destination implies "LIMIT 1".
98047: **
98048: ** SRT_Set The result must be a single column. Store each
98049: ** row of result as the key in table pDest->iParm.
98050: ** Apply the affinity pDest->affinity before storing
98051: ** results. Used to implement "IN (SELECT ...)".
98052: **
98053: ** SRT_Union Store results as a key in a temporary table pDest->iParm.
98054: **
98055: ** SRT_Except Remove results from the temporary table pDest->iParm.
98056: **
98057: ** SRT_Table Store results in temporary table pDest->iParm.
98058: ** This is like SRT_EphemTab except that the table
98059: ** is assumed to already be open.
98060: **
98061: ** SRT_EphemTab Create an temporary table pDest->iParm and store
98062: ** the result there. The cursor is left open after
98063: ** returning. This is like SRT_Table except that
98064: ** this destination uses OP_OpenEphemeral to create
98065: ** the table first.
98066: **
98067: ** SRT_Coroutine Generate a co-routine that returns a new row of
98068: ** results each time it is invoked. The entry point
98069: ** of the co-routine is stored in register pDest->iParm.
98070: **
98071: ** SRT_Exists Store a 1 in memory cell pDest->iParm if the result
98072: ** set is not empty.
98073: **
98074: ** SRT_Discard Throw the results away. This is used by SELECT
98075: ** statements within triggers whose only purpose is
98076: ** the side-effects of functions.
98077: **
98078: ** This routine returns the number of errors. If any errors are
98079: ** encountered, then an appropriate error message is left in
98080: ** pParse->zErrMsg.
98081: **
98082: ** This routine does NOT free the Select structure passed in. The
98083: ** calling function needs to do that.
98084: */
98085: SQLITE_PRIVATE int sqlite3Select(
98086: Parse *pParse, /* The parser context */
98087: Select *p, /* The SELECT statement being coded. */
98088: SelectDest *pDest /* What to do with the query results */
98089: ){
98090: int i, j; /* Loop counters */
98091: WhereInfo *pWInfo; /* Return from sqlite3WhereBegin() */
98092: Vdbe *v; /* The virtual machine under construction */
98093: int isAgg; /* True for select lists like "count(*)" */
98094: ExprList *pEList; /* List of columns to extract. */
98095: SrcList *pTabList; /* List of tables to select from */
98096: Expr *pWhere; /* The WHERE clause. May be NULL */
98097: ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */
98098: ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */
98099: Expr *pHaving; /* The HAVING clause. May be NULL */
98100: int isDistinct; /* True if the DISTINCT keyword is present */
98101: int distinct; /* Table to use for the distinct set */
98102: int rc = 1; /* Value to return from this function */
98103: int addrSortIndex; /* Address of an OP_OpenEphemeral instruction */
98104: int addrDistinctIndex; /* Address of an OP_OpenEphemeral instruction */
98105: AggInfo sAggInfo; /* Information used by aggregate queries */
98106: int iEnd; /* Address of the end of the query */
98107: sqlite3 *db; /* The database connection */
98108:
98109: #ifndef SQLITE_OMIT_EXPLAIN
98110: int iRestoreSelectId = pParse->iSelectId;
98111: pParse->iSelectId = pParse->iNextSelectId++;
98112: #endif
98113:
98114: db = pParse->db;
98115: if( p==0 || db->mallocFailed || pParse->nErr ){
98116: return 1;
98117: }
98118: if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
98119: memset(&sAggInfo, 0, sizeof(sAggInfo));
98120:
98121: if( IgnorableOrderby(pDest) ){
98122: assert(pDest->eDest==SRT_Exists || pDest->eDest==SRT_Union ||
98123: pDest->eDest==SRT_Except || pDest->eDest==SRT_Discard);
98124: /* If ORDER BY makes no difference in the output then neither does
98125: ** DISTINCT so it can be removed too. */
98126: sqlite3ExprListDelete(db, p->pOrderBy);
98127: p->pOrderBy = 0;
98128: p->selFlags &= ~SF_Distinct;
98129: }
98130: sqlite3SelectPrep(pParse, p, 0);
98131: pOrderBy = p->pOrderBy;
98132: pTabList = p->pSrc;
98133: pEList = p->pEList;
98134: if( pParse->nErr || db->mallocFailed ){
98135: goto select_end;
98136: }
98137: isAgg = (p->selFlags & SF_Aggregate)!=0;
98138: assert( pEList!=0 );
98139:
98140: /* Begin generating code.
98141: */
98142: v = sqlite3GetVdbe(pParse);
98143: if( v==0 ) goto select_end;
98144:
98145: /* If writing to memory or generating a set
98146: ** only a single column may be output.
98147: */
98148: #ifndef SQLITE_OMIT_SUBQUERY
98149: if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
98150: goto select_end;
98151: }
98152: #endif
98153:
98154: /* Generate code for all sub-queries in the FROM clause
98155: */
98156: #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
98157: for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
98158: struct SrcList_item *pItem = &pTabList->a[i];
98159: SelectDest dest;
98160: Select *pSub = pItem->pSelect;
98161: int isAggSub;
98162:
98163: if( pSub==0 ) continue;
98164: if( pItem->addrFillSub ){
98165: sqlite3VdbeAddOp2(v, OP_Gosub, pItem->regReturn, pItem->addrFillSub);
98166: continue;
98167: }
98168:
98169: /* Increment Parse.nHeight by the height of the largest expression
98170: ** tree refered to by this, the parent select. The child select
98171: ** may contain expression trees of at most
98172: ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
98173: ** more conservative than necessary, but much easier than enforcing
98174: ** an exact limit.
98175: */
98176: pParse->nHeight += sqlite3SelectExprHeight(p);
98177:
98178: isAggSub = (pSub->selFlags & SF_Aggregate)!=0;
98179: if( flattenSubquery(pParse, p, i, isAgg, isAggSub) ){
98180: /* This subquery can be absorbed into its parent. */
98181: if( isAggSub ){
98182: isAgg = 1;
98183: p->selFlags |= SF_Aggregate;
98184: }
98185: i = -1;
98186: }else{
98187: /* Generate a subroutine that will fill an ephemeral table with
98188: ** the content of this subquery. pItem->addrFillSub will point
98189: ** to the address of the generated subroutine. pItem->regReturn
98190: ** is a register allocated to hold the subroutine return address
98191: */
98192: int topAddr;
98193: int onceAddr = 0;
98194: int retAddr;
98195: assert( pItem->addrFillSub==0 );
98196: pItem->regReturn = ++pParse->nMem;
98197: topAddr = sqlite3VdbeAddOp2(v, OP_Integer, 0, pItem->regReturn);
98198: pItem->addrFillSub = topAddr+1;
98199: VdbeNoopComment((v, "materialize %s", pItem->pTab->zName));
98200: if( pItem->isCorrelated==0 ){
98201: /* If the subquery is no correlated and if we are not inside of
98202: ** a trigger, then we only need to compute the value of the subquery
98203: ** once. */
98204: onceAddr = sqlite3CodeOnce(pParse);
98205: }
98206: sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
98207: explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);
98208: sqlite3Select(pParse, pSub, &dest);
98209: pItem->pTab->nRowEst = (unsigned)pSub->nSelectRow;
98210: if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
98211: retAddr = sqlite3VdbeAddOp1(v, OP_Return, pItem->regReturn);
98212: VdbeComment((v, "end %s", pItem->pTab->zName));
98213: sqlite3VdbeChangeP1(v, topAddr, retAddr);
98214: sqlite3ClearTempRegCache(pParse);
98215: }
98216: if( /*pParse->nErr ||*/ db->mallocFailed ){
98217: goto select_end;
98218: }
98219: pParse->nHeight -= sqlite3SelectExprHeight(p);
98220: pTabList = p->pSrc;
98221: if( !IgnorableOrderby(pDest) ){
98222: pOrderBy = p->pOrderBy;
98223: }
98224: }
98225: pEList = p->pEList;
98226: #endif
98227: pWhere = p->pWhere;
98228: pGroupBy = p->pGroupBy;
98229: pHaving = p->pHaving;
98230: isDistinct = (p->selFlags & SF_Distinct)!=0;
98231:
98232: #ifndef SQLITE_OMIT_COMPOUND_SELECT
98233: /* If there is are a sequence of queries, do the earlier ones first.
98234: */
98235: if( p->pPrior ){
98236: if( p->pRightmost==0 ){
98237: Select *pLoop, *pRight = 0;
98238: int cnt = 0;
98239: int mxSelect;
98240: for(pLoop=p; pLoop; pLoop=pLoop->pPrior, cnt++){
98241: pLoop->pRightmost = p;
98242: pLoop->pNext = pRight;
98243: pRight = pLoop;
98244: }
98245: mxSelect = db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT];
98246: if( mxSelect && cnt>mxSelect ){
98247: sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
98248: goto select_end;
98249: }
98250: }
98251: rc = multiSelect(pParse, p, pDest);
98252: explainSetInteger(pParse->iSelectId, iRestoreSelectId);
98253: return rc;
98254: }
98255: #endif
98256:
98257: /* If there is both a GROUP BY and an ORDER BY clause and they are
98258: ** identical, then disable the ORDER BY clause since the GROUP BY
98259: ** will cause elements to come out in the correct order. This is
98260: ** an optimization - the correct answer should result regardless.
98261: ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER
98262: ** to disable this optimization for testing purposes.
98263: */
98264: if( sqlite3ExprListCompare(p->pGroupBy, pOrderBy)==0
98265: && (db->flags & SQLITE_GroupByOrder)==0 ){
98266: pOrderBy = 0;
98267: }
98268:
98269: /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
98270: ** if the select-list is the same as the ORDER BY list, then this query
98271: ** can be rewritten as a GROUP BY. In other words, this:
98272: **
98273: ** SELECT DISTINCT xyz FROM ... ORDER BY xyz
98274: **
98275: ** is transformed to:
98276: **
98277: ** SELECT xyz FROM ... GROUP BY xyz
98278: **
98279: ** The second form is preferred as a single index (or temp-table) may be
98280: ** used for both the ORDER BY and DISTINCT processing. As originally
98281: ** written the query must use a temp-table for at least one of the ORDER
98282: ** BY and DISTINCT, and an index or separate temp-table for the other.
98283: */
98284: if( (p->selFlags & (SF_Distinct|SF_Aggregate))==SF_Distinct
98285: && sqlite3ExprListCompare(pOrderBy, p->pEList)==0
98286: ){
98287: p->selFlags &= ~SF_Distinct;
98288: p->pGroupBy = sqlite3ExprListDup(db, p->pEList, 0);
98289: pGroupBy = p->pGroupBy;
98290: pOrderBy = 0;
98291: }
98292:
98293: /* If there is an ORDER BY clause, then this sorting
98294: ** index might end up being unused if the data can be
98295: ** extracted in pre-sorted order. If that is the case, then the
98296: ** OP_OpenEphemeral instruction will be changed to an OP_Noop once
98297: ** we figure out that the sorting index is not needed. The addrSortIndex
98298: ** variable is used to facilitate that change.
98299: */
98300: if( pOrderBy ){
98301: KeyInfo *pKeyInfo;
98302: pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
98303: pOrderBy->iECursor = pParse->nTab++;
98304: p->addrOpenEphm[2] = addrSortIndex =
98305: sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
98306: pOrderBy->iECursor, pOrderBy->nExpr+2, 0,
98307: (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
98308: }else{
98309: addrSortIndex = -1;
98310: }
98311:
98312: /* If the output is destined for a temporary table, open that table.
98313: */
98314: if( pDest->eDest==SRT_EphemTab ){
98315: sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iParm, pEList->nExpr);
98316: }
98317:
98318: /* Set the limiter.
98319: */
98320: iEnd = sqlite3VdbeMakeLabel(v);
98321: p->nSelectRow = (double)LARGEST_INT64;
98322: computeLimitRegisters(pParse, p, iEnd);
98323: if( p->iLimit==0 && addrSortIndex>=0 ){
98324: sqlite3VdbeGetOp(v, addrSortIndex)->opcode = OP_SorterOpen;
98325: p->selFlags |= SF_UseSorter;
98326: }
98327:
98328: /* Open a virtual index to use for the distinct set.
98329: */
98330: if( p->selFlags & SF_Distinct ){
98331: KeyInfo *pKeyInfo;
98332: distinct = pParse->nTab++;
98333: pKeyInfo = keyInfoFromExprList(pParse, p->pEList);
98334: addrDistinctIndex = sqlite3VdbeAddOp4(v, OP_OpenEphemeral, distinct, 0, 0,
98335: (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
98336: sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
98337: }else{
98338: distinct = addrDistinctIndex = -1;
98339: }
98340:
98341: /* Aggregate and non-aggregate queries are handled differently */
98342: if( !isAgg && pGroupBy==0 ){
98343: ExprList *pDist = (isDistinct ? p->pEList : 0);
98344:
98345: /* Begin the database scan. */
98346: pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy, pDist, 0);
98347: if( pWInfo==0 ) goto select_end;
98348: if( pWInfo->nRowOut < p->nSelectRow ) p->nSelectRow = pWInfo->nRowOut;
98349:
98350: /* If sorting index that was created by a prior OP_OpenEphemeral
98351: ** instruction ended up not being needed, then change the OP_OpenEphemeral
98352: ** into an OP_Noop.
98353: */
98354: if( addrSortIndex>=0 && pOrderBy==0 ){
98355: sqlite3VdbeChangeToNoop(v, addrSortIndex);
98356: p->addrOpenEphm[2] = -1;
98357: }
98358:
98359: if( pWInfo->eDistinct ){
98360: VdbeOp *pOp; /* No longer required OpenEphemeral instr. */
98361:
98362: assert( addrDistinctIndex>=0 );
98363: pOp = sqlite3VdbeGetOp(v, addrDistinctIndex);
98364:
98365: assert( isDistinct );
98366: assert( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED
98367: || pWInfo->eDistinct==WHERE_DISTINCT_UNIQUE
98368: );
98369: distinct = -1;
98370: if( pWInfo->eDistinct==WHERE_DISTINCT_ORDERED ){
98371: int iJump;
98372: int iExpr;
98373: int iFlag = ++pParse->nMem;
98374: int iBase = pParse->nMem+1;
98375: int iBase2 = iBase + pEList->nExpr;
98376: pParse->nMem += (pEList->nExpr*2);
98377:
98378: /* Change the OP_OpenEphemeral coded earlier to an OP_Integer. The
98379: ** OP_Integer initializes the "first row" flag. */
98380: pOp->opcode = OP_Integer;
98381: pOp->p1 = 1;
98382: pOp->p2 = iFlag;
98383:
98384: sqlite3ExprCodeExprList(pParse, pEList, iBase, 1);
98385: iJump = sqlite3VdbeCurrentAddr(v) + 1 + pEList->nExpr + 1 + 1;
98386: sqlite3VdbeAddOp2(v, OP_If, iFlag, iJump-1);
98387: for(iExpr=0; iExpr<pEList->nExpr; iExpr++){
98388: CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[iExpr].pExpr);
98389: sqlite3VdbeAddOp3(v, OP_Ne, iBase+iExpr, iJump, iBase2+iExpr);
98390: sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
98391: sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
98392: }
98393: sqlite3VdbeAddOp2(v, OP_Goto, 0, pWInfo->iContinue);
98394:
98395: sqlite3VdbeAddOp2(v, OP_Integer, 0, iFlag);
98396: assert( sqlite3VdbeCurrentAddr(v)==iJump );
98397: sqlite3VdbeAddOp3(v, OP_Move, iBase, iBase2, pEList->nExpr);
98398: }else{
98399: pOp->opcode = OP_Noop;
98400: }
98401: }
98402:
98403: /* Use the standard inner loop. */
98404: selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, distinct, pDest,
98405: pWInfo->iContinue, pWInfo->iBreak);
98406:
98407: /* End the database scan loop.
98408: */
98409: sqlite3WhereEnd(pWInfo);
98410: }else{
98411: /* This is the processing for aggregate queries */
98412: NameContext sNC; /* Name context for processing aggregate information */
98413: int iAMem; /* First Mem address for storing current GROUP BY */
98414: int iBMem; /* First Mem address for previous GROUP BY */
98415: int iUseFlag; /* Mem address holding flag indicating that at least
98416: ** one row of the input to the aggregator has been
98417: ** processed */
98418: int iAbortFlag; /* Mem address which causes query abort if positive */
98419: int groupBySort; /* Rows come from source in GROUP BY order */
98420: int addrEnd; /* End of processing for this SELECT */
98421: int sortPTab = 0; /* Pseudotable used to decode sorting results */
98422: int sortOut = 0; /* Output register from the sorter */
98423:
98424: /* Remove any and all aliases between the result set and the
98425: ** GROUP BY clause.
98426: */
98427: if( pGroupBy ){
98428: int k; /* Loop counter */
98429: struct ExprList_item *pItem; /* For looping over expression in a list */
98430:
98431: for(k=p->pEList->nExpr, pItem=p->pEList->a; k>0; k--, pItem++){
98432: pItem->iAlias = 0;
98433: }
98434: for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
98435: pItem->iAlias = 0;
98436: }
98437: if( p->nSelectRow>(double)100 ) p->nSelectRow = (double)100;
98438: }else{
98439: p->nSelectRow = (double)1;
98440: }
98441:
98442:
98443: /* Create a label to jump to when we want to abort the query */
98444: addrEnd = sqlite3VdbeMakeLabel(v);
98445:
98446: /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
98447: ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
98448: ** SELECT statement.
98449: */
98450: memset(&sNC, 0, sizeof(sNC));
98451: sNC.pParse = pParse;
98452: sNC.pSrcList = pTabList;
98453: sNC.pAggInfo = &sAggInfo;
98454: sAggInfo.nSortingColumn = pGroupBy ? pGroupBy->nExpr+1 : 0;
98455: sAggInfo.pGroupBy = pGroupBy;
98456: sqlite3ExprAnalyzeAggList(&sNC, pEList);
98457: sqlite3ExprAnalyzeAggList(&sNC, pOrderBy);
98458: if( pHaving ){
98459: sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
98460: }
98461: sAggInfo.nAccumulator = sAggInfo.nColumn;
98462: for(i=0; i<sAggInfo.nFunc; i++){
98463: assert( !ExprHasProperty(sAggInfo.aFunc[i].pExpr, EP_xIsSelect) );
98464: sqlite3ExprAnalyzeAggList(&sNC, sAggInfo.aFunc[i].pExpr->x.pList);
98465: }
98466: if( db->mallocFailed ) goto select_end;
98467:
98468: /* Processing for aggregates with GROUP BY is very different and
98469: ** much more complex than aggregates without a GROUP BY.
98470: */
98471: if( pGroupBy ){
98472: KeyInfo *pKeyInfo; /* Keying information for the group by clause */
98473: int j1; /* A-vs-B comparision jump */
98474: int addrOutputRow; /* Start of subroutine that outputs a result row */
98475: int regOutputRow; /* Return address register for output subroutine */
98476: int addrSetAbort; /* Set the abort flag and return */
98477: int addrTopOfLoop; /* Top of the input loop */
98478: int addrSortingIdx; /* The OP_OpenEphemeral for the sorting index */
98479: int addrReset; /* Subroutine for resetting the accumulator */
98480: int regReset; /* Return address register for reset subroutine */
98481:
98482: /* If there is a GROUP BY clause we might need a sorting index to
98483: ** implement it. Allocate that sorting index now. If it turns out
98484: ** that we do not need it after all, the OP_SorterOpen instruction
98485: ** will be converted into a Noop.
98486: */
98487: sAggInfo.sortingIdx = pParse->nTab++;
98488: pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
98489: addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen,
98490: sAggInfo.sortingIdx, sAggInfo.nSortingColumn,
98491: 0, (char*)pKeyInfo, P4_KEYINFO_HANDOFF);
98492:
98493: /* Initialize memory locations used by GROUP BY aggregate processing
98494: */
98495: iUseFlag = ++pParse->nMem;
98496: iAbortFlag = ++pParse->nMem;
98497: regOutputRow = ++pParse->nMem;
98498: addrOutputRow = sqlite3VdbeMakeLabel(v);
98499: regReset = ++pParse->nMem;
98500: addrReset = sqlite3VdbeMakeLabel(v);
98501: iAMem = pParse->nMem + 1;
98502: pParse->nMem += pGroupBy->nExpr;
98503: iBMem = pParse->nMem + 1;
98504: pParse->nMem += pGroupBy->nExpr;
98505: sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
98506: VdbeComment((v, "clear abort flag"));
98507: sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
98508: VdbeComment((v, "indicate accumulator empty"));
98509: sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);
98510:
98511: /* Begin a loop that will extract all source rows in GROUP BY order.
98512: ** This might involve two separate loops with an OP_Sort in between, or
98513: ** it might be a single loop that uses an index to extract information
98514: ** in the right order to begin with.
98515: */
98516: sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
98517: pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy, 0, 0);
98518: if( pWInfo==0 ) goto select_end;
98519: if( pGroupBy==0 ){
98520: /* The optimizer is able to deliver rows in group by order so
98521: ** we do not have to sort. The OP_OpenEphemeral table will be
98522: ** cancelled later because we still need to use the pKeyInfo
98523: */
98524: pGroupBy = p->pGroupBy;
98525: groupBySort = 0;
98526: }else{
98527: /* Rows are coming out in undetermined order. We have to push
98528: ** each row into a sorting index, terminate the first loop,
98529: ** then loop over the sorting index in order to get the output
98530: ** in sorted order
98531: */
98532: int regBase;
98533: int regRecord;
98534: int nCol;
98535: int nGroupBy;
98536:
98537: explainTempTable(pParse,
98538: isDistinct && !(p->selFlags&SF_Distinct)?"DISTINCT":"GROUP BY");
98539:
98540: groupBySort = 1;
98541: nGroupBy = pGroupBy->nExpr;
98542: nCol = nGroupBy + 1;
98543: j = nGroupBy+1;
98544: for(i=0; i<sAggInfo.nColumn; i++){
98545: if( sAggInfo.aCol[i].iSorterColumn>=j ){
98546: nCol++;
98547: j++;
98548: }
98549: }
98550: regBase = sqlite3GetTempRange(pParse, nCol);
98551: sqlite3ExprCacheClear(pParse);
98552: sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0);
98553: sqlite3VdbeAddOp2(v, OP_Sequence, sAggInfo.sortingIdx,regBase+nGroupBy);
98554: j = nGroupBy+1;
98555: for(i=0; i<sAggInfo.nColumn; i++){
98556: struct AggInfo_col *pCol = &sAggInfo.aCol[i];
98557: if( pCol->iSorterColumn>=j ){
98558: int r1 = j + regBase;
98559: int r2;
98560:
98561: r2 = sqlite3ExprCodeGetColumn(pParse,
98562: pCol->pTab, pCol->iColumn, pCol->iTable, r1);
98563: if( r1!=r2 ){
98564: sqlite3VdbeAddOp2(v, OP_SCopy, r2, r1);
98565: }
98566: j++;
98567: }
98568: }
98569: regRecord = sqlite3GetTempReg(pParse);
98570: sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
98571: sqlite3VdbeAddOp2(v, OP_SorterInsert, sAggInfo.sortingIdx, regRecord);
98572: sqlite3ReleaseTempReg(pParse, regRecord);
98573: sqlite3ReleaseTempRange(pParse, regBase, nCol);
98574: sqlite3WhereEnd(pWInfo);
98575: sAggInfo.sortingIdxPTab = sortPTab = pParse->nTab++;
98576: sortOut = sqlite3GetTempReg(pParse);
98577: sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
98578: sqlite3VdbeAddOp2(v, OP_SorterSort, sAggInfo.sortingIdx, addrEnd);
98579: VdbeComment((v, "GROUP BY sort"));
98580: sAggInfo.useSortingIdx = 1;
98581: sqlite3ExprCacheClear(pParse);
98582: }
98583:
98584: /* Evaluate the current GROUP BY terms and store in b0, b1, b2...
98585: ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
98586: ** Then compare the current GROUP BY terms against the GROUP BY terms
98587: ** from the previous row currently stored in a0, a1, a2...
98588: */
98589: addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
98590: sqlite3ExprCacheClear(pParse);
98591: if( groupBySort ){
98592: sqlite3VdbeAddOp2(v, OP_SorterData, sAggInfo.sortingIdx, sortOut);
98593: }
98594: for(j=0; j<pGroupBy->nExpr; j++){
98595: if( groupBySort ){
98596: sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
98597: if( j==0 ) sqlite3VdbeChangeP5(v, OPFLAG_CLEARCACHE);
98598: }else{
98599: sAggInfo.directMode = 1;
98600: sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
98601: }
98602: }
98603: sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
98604: (char*)pKeyInfo, P4_KEYINFO);
98605: j1 = sqlite3VdbeCurrentAddr(v);
98606: sqlite3VdbeAddOp3(v, OP_Jump, j1+1, 0, j1+1);
98607:
98608: /* Generate code that runs whenever the GROUP BY changes.
98609: ** Changes in the GROUP BY are detected by the previous code
98610: ** block. If there were no changes, this block is skipped.
98611: **
98612: ** This code copies current group by terms in b0,b1,b2,...
98613: ** over to a0,a1,a2. It then calls the output subroutine
98614: ** and resets the aggregate accumulator registers in preparation
98615: ** for the next GROUP BY batch.
98616: */
98617: sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
98618: sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
98619: VdbeComment((v, "output one row"));
98620: sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd);
98621: VdbeComment((v, "check abort flag"));
98622: sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
98623: VdbeComment((v, "reset accumulator"));
98624:
98625: /* Update the aggregate accumulators based on the content of
98626: ** the current row
98627: */
98628: sqlite3VdbeJumpHere(v, j1);
98629: updateAccumulator(pParse, &sAggInfo);
98630: sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
98631: VdbeComment((v, "indicate data in accumulator"));
98632:
98633: /* End of the loop
98634: */
98635: if( groupBySort ){
98636: sqlite3VdbeAddOp2(v, OP_SorterNext, sAggInfo.sortingIdx, addrTopOfLoop);
98637: }else{
98638: sqlite3WhereEnd(pWInfo);
98639: sqlite3VdbeChangeToNoop(v, addrSortingIdx);
98640: }
98641:
98642: /* Output the final row of result
98643: */
98644: sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
98645: VdbeComment((v, "output final row"));
98646:
98647: /* Jump over the subroutines
98648: */
98649: sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEnd);
98650:
98651: /* Generate a subroutine that outputs a single row of the result
98652: ** set. This subroutine first looks at the iUseFlag. If iUseFlag
98653: ** is less than or equal to zero, the subroutine is a no-op. If
98654: ** the processing calls for the query to abort, this subroutine
98655: ** increments the iAbortFlag memory location before returning in
98656: ** order to signal the caller to abort.
98657: */
98658: addrSetAbort = sqlite3VdbeCurrentAddr(v);
98659: sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
98660: VdbeComment((v, "set abort flag"));
98661: sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
98662: sqlite3VdbeResolveLabel(v, addrOutputRow);
98663: addrOutputRow = sqlite3VdbeCurrentAddr(v);
98664: sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
98665: VdbeComment((v, "Groupby result generator entry point"));
98666: sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
98667: finalizeAggFunctions(pParse, &sAggInfo);
98668: sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
98669: selectInnerLoop(pParse, p, p->pEList, 0, 0, pOrderBy,
98670: distinct, pDest,
98671: addrOutputRow+1, addrSetAbort);
98672: sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
98673: VdbeComment((v, "end groupby result generator"));
98674:
98675: /* Generate a subroutine that will reset the group-by accumulator
98676: */
98677: sqlite3VdbeResolveLabel(v, addrReset);
98678: resetAccumulator(pParse, &sAggInfo);
98679: sqlite3VdbeAddOp1(v, OP_Return, regReset);
98680:
98681: } /* endif pGroupBy. Begin aggregate queries without GROUP BY: */
98682: else {
98683: ExprList *pDel = 0;
98684: #ifndef SQLITE_OMIT_BTREECOUNT
98685: Table *pTab;
98686: if( (pTab = isSimpleCount(p, &sAggInfo))!=0 ){
98687: /* If isSimpleCount() returns a pointer to a Table structure, then
98688: ** the SQL statement is of the form:
98689: **
98690: ** SELECT count(*) FROM <tbl>
98691: **
98692: ** where the Table structure returned represents table <tbl>.
98693: **
98694: ** This statement is so common that it is optimized specially. The
98695: ** OP_Count instruction is executed either on the intkey table that
98696: ** contains the data for table <tbl> or on one of its indexes. It
98697: ** is better to execute the op on an index, as indexes are almost
98698: ** always spread across less pages than their corresponding tables.
98699: */
98700: const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
98701: const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */
98702: Index *pIdx; /* Iterator variable */
98703: KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */
98704: Index *pBest = 0; /* Best index found so far */
98705: int iRoot = pTab->tnum; /* Root page of scanned b-tree */
98706:
98707: sqlite3CodeVerifySchema(pParse, iDb);
98708: sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
98709:
98710: /* Search for the index that has the least amount of columns. If
98711: ** there is such an index, and it has less columns than the table
98712: ** does, then we can assume that it consumes less space on disk and
98713: ** will therefore be cheaper to scan to determine the query result.
98714: ** In this case set iRoot to the root page number of the index b-tree
98715: ** and pKeyInfo to the KeyInfo structure required to navigate the
98716: ** index.
98717: **
98718: ** (2011-04-15) Do not do a full scan of an unordered index.
98719: **
98720: ** In practice the KeyInfo structure will not be used. It is only
98721: ** passed to keep OP_OpenRead happy.
98722: */
98723: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
98724: if( pIdx->bUnordered==0 && (!pBest || pIdx->nColumn<pBest->nColumn) ){
98725: pBest = pIdx;
98726: }
98727: }
98728: if( pBest && pBest->nColumn<pTab->nCol ){
98729: iRoot = pBest->tnum;
98730: pKeyInfo = sqlite3IndexKeyinfo(pParse, pBest);
98731: }
98732:
98733: /* Open a read-only cursor, execute the OP_Count, close the cursor. */
98734: sqlite3VdbeAddOp3(v, OP_OpenRead, iCsr, iRoot, iDb);
98735: if( pKeyInfo ){
98736: sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO_HANDOFF);
98737: }
98738: sqlite3VdbeAddOp2(v, OP_Count, iCsr, sAggInfo.aFunc[0].iMem);
98739: sqlite3VdbeAddOp1(v, OP_Close, iCsr);
98740: explainSimpleCount(pParse, pTab, pBest);
98741: }else
98742: #endif /* SQLITE_OMIT_BTREECOUNT */
98743: {
98744: /* Check if the query is of one of the following forms:
98745: **
98746: ** SELECT min(x) FROM ...
98747: ** SELECT max(x) FROM ...
98748: **
98749: ** If it is, then ask the code in where.c to attempt to sort results
98750: ** as if there was an "ORDER ON x" or "ORDER ON x DESC" clause.
98751: ** If where.c is able to produce results sorted in this order, then
98752: ** add vdbe code to break out of the processing loop after the
98753: ** first iteration (since the first iteration of the loop is
98754: ** guaranteed to operate on the row with the minimum or maximum
98755: ** value of x, the only row required).
98756: **
98757: ** A special flag must be passed to sqlite3WhereBegin() to slightly
98758: ** modify behaviour as follows:
98759: **
98760: ** + If the query is a "SELECT min(x)", then the loop coded by
98761: ** where.c should not iterate over any values with a NULL value
98762: ** for x.
98763: **
98764: ** + The optimizer code in where.c (the thing that decides which
98765: ** index or indices to use) should place a different priority on
98766: ** satisfying the 'ORDER BY' clause than it does in other cases.
98767: ** Refer to code and comments in where.c for details.
98768: */
98769: ExprList *pMinMax = 0;
98770: u8 flag = minMaxQuery(p);
98771: if( flag ){
98772: assert( !ExprHasProperty(p->pEList->a[0].pExpr, EP_xIsSelect) );
98773: pMinMax = sqlite3ExprListDup(db, p->pEList->a[0].pExpr->x.pList,0);
98774: pDel = pMinMax;
98775: if( pMinMax && !db->mallocFailed ){
98776: pMinMax->a[0].sortOrder = flag!=WHERE_ORDERBY_MIN ?1:0;
98777: pMinMax->a[0].pExpr->op = TK_COLUMN;
98778: }
98779: }
98780:
98781: /* This case runs if the aggregate has no GROUP BY clause. The
98782: ** processing is much simpler since there is only a single row
98783: ** of output.
98784: */
98785: resetAccumulator(pParse, &sAggInfo);
98786: pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pMinMax, 0, flag);
98787: if( pWInfo==0 ){
98788: sqlite3ExprListDelete(db, pDel);
98789: goto select_end;
98790: }
98791: updateAccumulator(pParse, &sAggInfo);
98792: if( !pMinMax && flag ){
98793: sqlite3VdbeAddOp2(v, OP_Goto, 0, pWInfo->iBreak);
98794: VdbeComment((v, "%s() by index",
98795: (flag==WHERE_ORDERBY_MIN?"min":"max")));
98796: }
98797: sqlite3WhereEnd(pWInfo);
98798: finalizeAggFunctions(pParse, &sAggInfo);
98799: }
98800:
98801: pOrderBy = 0;
98802: sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
98803: selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1,
98804: pDest, addrEnd, addrEnd);
98805: sqlite3ExprListDelete(db, pDel);
98806: }
98807: sqlite3VdbeResolveLabel(v, addrEnd);
98808:
98809: } /* endif aggregate query */
98810:
98811: if( distinct>=0 ){
98812: explainTempTable(pParse, "DISTINCT");
98813: }
98814:
98815: /* If there is an ORDER BY clause, then we need to sort the results
98816: ** and send them to the callback one by one.
98817: */
98818: if( pOrderBy ){
98819: explainTempTable(pParse, "ORDER BY");
98820: generateSortTail(pParse, p, v, pEList->nExpr, pDest);
98821: }
98822:
98823: /* Jump here to skip this query
98824: */
98825: sqlite3VdbeResolveLabel(v, iEnd);
98826:
98827: /* The SELECT was successfully coded. Set the return code to 0
98828: ** to indicate no errors.
98829: */
98830: rc = 0;
98831:
98832: /* Control jumps to here if an error is encountered above, or upon
98833: ** successful coding of the SELECT.
98834: */
98835: select_end:
98836: explainSetInteger(pParse->iSelectId, iRestoreSelectId);
98837:
98838: /* Identify column names if results of the SELECT are to be output.
98839: */
98840: if( rc==SQLITE_OK && pDest->eDest==SRT_Output ){
98841: generateColumnNames(pParse, pTabList, pEList);
98842: }
98843:
98844: sqlite3DbFree(db, sAggInfo.aCol);
98845: sqlite3DbFree(db, sAggInfo.aFunc);
98846: return rc;
98847: }
98848:
98849: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
98850: /*
98851: ** Generate a human-readable description of a the Select object.
98852: */
98853: static void explainOneSelect(Vdbe *pVdbe, Select *p){
98854: sqlite3ExplainPrintf(pVdbe, "SELECT ");
98855: if( p->selFlags & (SF_Distinct|SF_Aggregate) ){
98856: if( p->selFlags & SF_Distinct ){
98857: sqlite3ExplainPrintf(pVdbe, "DISTINCT ");
98858: }
98859: if( p->selFlags & SF_Aggregate ){
98860: sqlite3ExplainPrintf(pVdbe, "agg_flag ");
98861: }
98862: sqlite3ExplainNL(pVdbe);
98863: sqlite3ExplainPrintf(pVdbe, " ");
98864: }
98865: sqlite3ExplainExprList(pVdbe, p->pEList);
98866: sqlite3ExplainNL(pVdbe);
98867: if( p->pSrc && p->pSrc->nSrc ){
98868: int i;
98869: sqlite3ExplainPrintf(pVdbe, "FROM ");
98870: sqlite3ExplainPush(pVdbe);
98871: for(i=0; i<p->pSrc->nSrc; i++){
98872: struct SrcList_item *pItem = &p->pSrc->a[i];
98873: sqlite3ExplainPrintf(pVdbe, "{%d,*} = ", pItem->iCursor);
98874: if( pItem->pSelect ){
98875: sqlite3ExplainSelect(pVdbe, pItem->pSelect);
98876: if( pItem->pTab ){
98877: sqlite3ExplainPrintf(pVdbe, " (tabname=%s)", pItem->pTab->zName);
98878: }
98879: }else if( pItem->zName ){
98880: sqlite3ExplainPrintf(pVdbe, "%s", pItem->zName);
98881: }
98882: if( pItem->zAlias ){
98883: sqlite3ExplainPrintf(pVdbe, " (AS %s)", pItem->zAlias);
98884: }
98885: if( pItem->jointype & JT_LEFT ){
98886: sqlite3ExplainPrintf(pVdbe, " LEFT-JOIN");
98887: }
98888: sqlite3ExplainNL(pVdbe);
98889: }
98890: sqlite3ExplainPop(pVdbe);
98891: }
98892: if( p->pWhere ){
98893: sqlite3ExplainPrintf(pVdbe, "WHERE ");
98894: sqlite3ExplainExpr(pVdbe, p->pWhere);
98895: sqlite3ExplainNL(pVdbe);
98896: }
98897: if( p->pGroupBy ){
98898: sqlite3ExplainPrintf(pVdbe, "GROUPBY ");
98899: sqlite3ExplainExprList(pVdbe, p->pGroupBy);
98900: sqlite3ExplainNL(pVdbe);
98901: }
98902: if( p->pHaving ){
98903: sqlite3ExplainPrintf(pVdbe, "HAVING ");
98904: sqlite3ExplainExpr(pVdbe, p->pHaving);
98905: sqlite3ExplainNL(pVdbe);
98906: }
98907: if( p->pOrderBy ){
98908: sqlite3ExplainPrintf(pVdbe, "ORDERBY ");
98909: sqlite3ExplainExprList(pVdbe, p->pOrderBy);
98910: sqlite3ExplainNL(pVdbe);
98911: }
98912: if( p->pLimit ){
98913: sqlite3ExplainPrintf(pVdbe, "LIMIT ");
98914: sqlite3ExplainExpr(pVdbe, p->pLimit);
98915: sqlite3ExplainNL(pVdbe);
98916: }
98917: if( p->pOffset ){
98918: sqlite3ExplainPrintf(pVdbe, "OFFSET ");
98919: sqlite3ExplainExpr(pVdbe, p->pOffset);
98920: sqlite3ExplainNL(pVdbe);
98921: }
98922: }
98923: SQLITE_PRIVATE void sqlite3ExplainSelect(Vdbe *pVdbe, Select *p){
98924: if( p==0 ){
98925: sqlite3ExplainPrintf(pVdbe, "(null-select)");
98926: return;
98927: }
98928: while( p->pPrior ) p = p->pPrior;
98929: sqlite3ExplainPush(pVdbe);
98930: while( p ){
98931: explainOneSelect(pVdbe, p);
98932: p = p->pNext;
98933: if( p==0 ) break;
98934: sqlite3ExplainNL(pVdbe);
98935: sqlite3ExplainPrintf(pVdbe, "%s\n", selectOpName(p->op));
98936: }
98937: sqlite3ExplainPrintf(pVdbe, "END");
98938: sqlite3ExplainPop(pVdbe);
98939: }
98940:
98941: /* End of the structure debug printing code
98942: *****************************************************************************/
98943: #endif /* defined(SQLITE_TEST) || defined(SQLITE_DEBUG) */
98944:
98945: /************** End of select.c **********************************************/
98946: /************** Begin file table.c *******************************************/
98947: /*
98948: ** 2001 September 15
98949: **
98950: ** The author disclaims copyright to this source code. In place of
98951: ** a legal notice, here is a blessing:
98952: **
98953: ** May you do good and not evil.
98954: ** May you find forgiveness for yourself and forgive others.
98955: ** May you share freely, never taking more than you give.
98956: **
98957: *************************************************************************
98958: ** This file contains the sqlite3_get_table() and sqlite3_free_table()
98959: ** interface routines. These are just wrappers around the main
98960: ** interface routine of sqlite3_exec().
98961: **
98962: ** These routines are in a separate files so that they will not be linked
98963: ** if they are not used.
98964: */
98965: /* #include <stdlib.h> */
98966: /* #include <string.h> */
98967:
98968: #ifndef SQLITE_OMIT_GET_TABLE
98969:
98970: /*
98971: ** This structure is used to pass data from sqlite3_get_table() through
98972: ** to the callback function is uses to build the result.
98973: */
98974: typedef struct TabResult {
98975: char **azResult; /* Accumulated output */
98976: char *zErrMsg; /* Error message text, if an error occurs */
98977: int nAlloc; /* Slots allocated for azResult[] */
98978: int nRow; /* Number of rows in the result */
98979: int nColumn; /* Number of columns in the result */
98980: int nData; /* Slots used in azResult[]. (nRow+1)*nColumn */
98981: int rc; /* Return code from sqlite3_exec() */
98982: } TabResult;
98983:
98984: /*
98985: ** This routine is called once for each row in the result table. Its job
98986: ** is to fill in the TabResult structure appropriately, allocating new
98987: ** memory as necessary.
98988: */
98989: static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
98990: TabResult *p = (TabResult*)pArg; /* Result accumulator */
98991: int need; /* Slots needed in p->azResult[] */
98992: int i; /* Loop counter */
98993: char *z; /* A single column of result */
98994:
98995: /* Make sure there is enough space in p->azResult to hold everything
98996: ** we need to remember from this invocation of the callback.
98997: */
98998: if( p->nRow==0 && argv!=0 ){
98999: need = nCol*2;
99000: }else{
99001: need = nCol;
99002: }
99003: if( p->nData + need > p->nAlloc ){
99004: char **azNew;
99005: p->nAlloc = p->nAlloc*2 + need;
99006: azNew = sqlite3_realloc( p->azResult, sizeof(char*)*p->nAlloc );
99007: if( azNew==0 ) goto malloc_failed;
99008: p->azResult = azNew;
99009: }
99010:
99011: /* If this is the first row, then generate an extra row containing
99012: ** the names of all columns.
99013: */
99014: if( p->nRow==0 ){
99015: p->nColumn = nCol;
99016: for(i=0; i<nCol; i++){
99017: z = sqlite3_mprintf("%s", colv[i]);
99018: if( z==0 ) goto malloc_failed;
99019: p->azResult[p->nData++] = z;
99020: }
99021: }else if( p->nColumn!=nCol ){
99022: sqlite3_free(p->zErrMsg);
99023: p->zErrMsg = sqlite3_mprintf(
99024: "sqlite3_get_table() called with two or more incompatible queries"
99025: );
99026: p->rc = SQLITE_ERROR;
99027: return 1;
99028: }
99029:
99030: /* Copy over the row data
99031: */
99032: if( argv!=0 ){
99033: for(i=0; i<nCol; i++){
99034: if( argv[i]==0 ){
99035: z = 0;
99036: }else{
99037: int n = sqlite3Strlen30(argv[i])+1;
99038: z = sqlite3_malloc( n );
99039: if( z==0 ) goto malloc_failed;
99040: memcpy(z, argv[i], n);
99041: }
99042: p->azResult[p->nData++] = z;
99043: }
99044: p->nRow++;
99045: }
99046: return 0;
99047:
99048: malloc_failed:
99049: p->rc = SQLITE_NOMEM;
99050: return 1;
99051: }
99052:
99053: /*
99054: ** Query the database. But instead of invoking a callback for each row,
99055: ** malloc() for space to hold the result and return the entire results
99056: ** at the conclusion of the call.
99057: **
99058: ** The result that is written to ***pazResult is held in memory obtained
99059: ** from malloc(). But the caller cannot free this memory directly.
99060: ** Instead, the entire table should be passed to sqlite3_free_table() when
99061: ** the calling procedure is finished using it.
99062: */
99063: SQLITE_API int sqlite3_get_table(
99064: sqlite3 *db, /* The database on which the SQL executes */
99065: const char *zSql, /* The SQL to be executed */
99066: char ***pazResult, /* Write the result table here */
99067: int *pnRow, /* Write the number of rows in the result here */
99068: int *pnColumn, /* Write the number of columns of result here */
99069: char **pzErrMsg /* Write error messages here */
99070: ){
99071: int rc;
99072: TabResult res;
99073:
99074: *pazResult = 0;
99075: if( pnColumn ) *pnColumn = 0;
99076: if( pnRow ) *pnRow = 0;
99077: if( pzErrMsg ) *pzErrMsg = 0;
99078: res.zErrMsg = 0;
99079: res.nRow = 0;
99080: res.nColumn = 0;
99081: res.nData = 1;
99082: res.nAlloc = 20;
99083: res.rc = SQLITE_OK;
99084: res.azResult = sqlite3_malloc(sizeof(char*)*res.nAlloc );
99085: if( res.azResult==0 ){
99086: db->errCode = SQLITE_NOMEM;
99087: return SQLITE_NOMEM;
99088: }
99089: res.azResult[0] = 0;
99090: rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg);
99091: assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
99092: res.azResult[0] = SQLITE_INT_TO_PTR(res.nData);
99093: if( (rc&0xff)==SQLITE_ABORT ){
99094: sqlite3_free_table(&res.azResult[1]);
99095: if( res.zErrMsg ){
99096: if( pzErrMsg ){
99097: sqlite3_free(*pzErrMsg);
99098: *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg);
99099: }
99100: sqlite3_free(res.zErrMsg);
99101: }
99102: db->errCode = res.rc; /* Assume 32-bit assignment is atomic */
99103: return res.rc;
99104: }
99105: sqlite3_free(res.zErrMsg);
99106: if( rc!=SQLITE_OK ){
99107: sqlite3_free_table(&res.azResult[1]);
99108: return rc;
99109: }
99110: if( res.nAlloc>res.nData ){
99111: char **azNew;
99112: azNew = sqlite3_realloc( res.azResult, sizeof(char*)*res.nData );
99113: if( azNew==0 ){
99114: sqlite3_free_table(&res.azResult[1]);
99115: db->errCode = SQLITE_NOMEM;
99116: return SQLITE_NOMEM;
99117: }
99118: res.azResult = azNew;
99119: }
99120: *pazResult = &res.azResult[1];
99121: if( pnColumn ) *pnColumn = res.nColumn;
99122: if( pnRow ) *pnRow = res.nRow;
99123: return rc;
99124: }
99125:
99126: /*
99127: ** This routine frees the space the sqlite3_get_table() malloced.
99128: */
99129: SQLITE_API void sqlite3_free_table(
99130: char **azResult /* Result returned from from sqlite3_get_table() */
99131: ){
99132: if( azResult ){
99133: int i, n;
99134: azResult--;
99135: assert( azResult!=0 );
99136: n = SQLITE_PTR_TO_INT(azResult[0]);
99137: for(i=1; i<n; i++){ if( azResult[i] ) sqlite3_free(azResult[i]); }
99138: sqlite3_free(azResult);
99139: }
99140: }
99141:
99142: #endif /* SQLITE_OMIT_GET_TABLE */
99143:
99144: /************** End of table.c ***********************************************/
99145: /************** Begin file trigger.c *****************************************/
99146: /*
99147: **
99148: ** The author disclaims copyright to this source code. In place of
99149: ** a legal notice, here is a blessing:
99150: **
99151: ** May you do good and not evil.
99152: ** May you find forgiveness for yourself and forgive others.
99153: ** May you share freely, never taking more than you give.
99154: **
99155: *************************************************************************
99156: ** This file contains the implementation for TRIGGERs
99157: */
99158:
99159: #ifndef SQLITE_OMIT_TRIGGER
99160: /*
99161: ** Delete a linked list of TriggerStep structures.
99162: */
99163: SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
99164: while( pTriggerStep ){
99165: TriggerStep * pTmp = pTriggerStep;
99166: pTriggerStep = pTriggerStep->pNext;
99167:
99168: sqlite3ExprDelete(db, pTmp->pWhere);
99169: sqlite3ExprListDelete(db, pTmp->pExprList);
99170: sqlite3SelectDelete(db, pTmp->pSelect);
99171: sqlite3IdListDelete(db, pTmp->pIdList);
99172:
99173: sqlite3DbFree(db, pTmp);
99174: }
99175: }
99176:
99177: /*
99178: ** Given table pTab, return a list of all the triggers attached to
99179: ** the table. The list is connected by Trigger.pNext pointers.
99180: **
99181: ** All of the triggers on pTab that are in the same database as pTab
99182: ** are already attached to pTab->pTrigger. But there might be additional
99183: ** triggers on pTab in the TEMP schema. This routine prepends all
99184: ** TEMP triggers on pTab to the beginning of the pTab->pTrigger list
99185: ** and returns the combined list.
99186: **
99187: ** To state it another way: This routine returns a list of all triggers
99188: ** that fire off of pTab. The list will include any TEMP triggers on
99189: ** pTab as well as the triggers lised in pTab->pTrigger.
99190: */
99191: SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
99192: Schema * const pTmpSchema = pParse->db->aDb[1].pSchema;
99193: Trigger *pList = 0; /* List of triggers to return */
99194:
99195: if( pParse->disableTriggers ){
99196: return 0;
99197: }
99198:
99199: if( pTmpSchema!=pTab->pSchema ){
99200: HashElem *p;
99201: assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
99202: for(p=sqliteHashFirst(&pTmpSchema->trigHash); p; p=sqliteHashNext(p)){
99203: Trigger *pTrig = (Trigger *)sqliteHashData(p);
99204: if( pTrig->pTabSchema==pTab->pSchema
99205: && 0==sqlite3StrICmp(pTrig->table, pTab->zName)
99206: ){
99207: pTrig->pNext = (pList ? pList : pTab->pTrigger);
99208: pList = pTrig;
99209: }
99210: }
99211: }
99212:
99213: return (pList ? pList : pTab->pTrigger);
99214: }
99215:
99216: /*
99217: ** This is called by the parser when it sees a CREATE TRIGGER statement
99218: ** up to the point of the BEGIN before the trigger actions. A Trigger
99219: ** structure is generated based on the information available and stored
99220: ** in pParse->pNewTrigger. After the trigger actions have been parsed, the
99221: ** sqlite3FinishTrigger() function is called to complete the trigger
99222: ** construction process.
99223: */
99224: SQLITE_PRIVATE void sqlite3BeginTrigger(
99225: Parse *pParse, /* The parse context of the CREATE TRIGGER statement */
99226: Token *pName1, /* The name of the trigger */
99227: Token *pName2, /* The name of the trigger */
99228: int tr_tm, /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */
99229: int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */
99230: IdList *pColumns, /* column list if this is an UPDATE OF trigger */
99231: SrcList *pTableName,/* The name of the table/view the trigger applies to */
99232: Expr *pWhen, /* WHEN clause */
99233: int isTemp, /* True if the TEMPORARY keyword is present */
99234: int noErr /* Suppress errors if the trigger already exists */
99235: ){
99236: Trigger *pTrigger = 0; /* The new trigger */
99237: Table *pTab; /* Table that the trigger fires off of */
99238: char *zName = 0; /* Name of the trigger */
99239: sqlite3 *db = pParse->db; /* The database connection */
99240: int iDb; /* The database to store the trigger in */
99241: Token *pName; /* The unqualified db name */
99242: DbFixer sFix; /* State vector for the DB fixer */
99243: int iTabDb; /* Index of the database holding pTab */
99244:
99245: assert( pName1!=0 ); /* pName1->z might be NULL, but not pName1 itself */
99246: assert( pName2!=0 );
99247: assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
99248: assert( op>0 && op<0xff );
99249: if( isTemp ){
99250: /* If TEMP was specified, then the trigger name may not be qualified. */
99251: if( pName2->n>0 ){
99252: sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
99253: goto trigger_cleanup;
99254: }
99255: iDb = 1;
99256: pName = pName1;
99257: }else{
99258: /* Figure out the db that the the trigger will be created in */
99259: iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
99260: if( iDb<0 ){
99261: goto trigger_cleanup;
99262: }
99263: }
99264: if( !pTableName || db->mallocFailed ){
99265: goto trigger_cleanup;
99266: }
99267:
99268: /* A long-standing parser bug is that this syntax was allowed:
99269: **
99270: ** CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab ....
99271: ** ^^^^^^^^
99272: **
99273: ** To maintain backwards compatibility, ignore the database
99274: ** name on pTableName if we are reparsing our of SQLITE_MASTER.
99275: */
99276: if( db->init.busy && iDb!=1 ){
99277: sqlite3DbFree(db, pTableName->a[0].zDatabase);
99278: pTableName->a[0].zDatabase = 0;
99279: }
99280:
99281: /* If the trigger name was unqualified, and the table is a temp table,
99282: ** then set iDb to 1 to create the trigger in the temporary database.
99283: ** If sqlite3SrcListLookup() returns 0, indicating the table does not
99284: ** exist, the error is caught by the block below.
99285: */
99286: pTab = sqlite3SrcListLookup(pParse, pTableName);
99287: if( db->init.busy==0 && pName2->n==0 && pTab
99288: && pTab->pSchema==db->aDb[1].pSchema ){
99289: iDb = 1;
99290: }
99291:
99292: /* Ensure the table name matches database name and that the table exists */
99293: if( db->mallocFailed ) goto trigger_cleanup;
99294: assert( pTableName->nSrc==1 );
99295: if( sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName) &&
99296: sqlite3FixSrcList(&sFix, pTableName) ){
99297: goto trigger_cleanup;
99298: }
99299: pTab = sqlite3SrcListLookup(pParse, pTableName);
99300: if( !pTab ){
99301: /* The table does not exist. */
99302: if( db->init.iDb==1 ){
99303: /* Ticket #3810.
99304: ** Normally, whenever a table is dropped, all associated triggers are
99305: ** dropped too. But if a TEMP trigger is created on a non-TEMP table
99306: ** and the table is dropped by a different database connection, the
99307: ** trigger is not visible to the database connection that does the
99308: ** drop so the trigger cannot be dropped. This results in an
99309: ** "orphaned trigger" - a trigger whose associated table is missing.
99310: */
99311: db->init.orphanTrigger = 1;
99312: }
99313: goto trigger_cleanup;
99314: }
99315: if( IsVirtual(pTab) ){
99316: sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");
99317: goto trigger_cleanup;
99318: }
99319:
99320: /* Check that the trigger name is not reserved and that no trigger of the
99321: ** specified name exists */
99322: zName = sqlite3NameFromToken(db, pName);
99323: if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
99324: goto trigger_cleanup;
99325: }
99326: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
99327: if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),
99328: zName, sqlite3Strlen30(zName)) ){
99329: if( !noErr ){
99330: sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
99331: }else{
99332: assert( !db->init.busy );
99333: sqlite3CodeVerifySchema(pParse, iDb);
99334: }
99335: goto trigger_cleanup;
99336: }
99337:
99338: /* Do not create a trigger on a system table */
99339: if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 ){
99340: sqlite3ErrorMsg(pParse, "cannot create trigger on system table");
99341: pParse->nErr++;
99342: goto trigger_cleanup;
99343: }
99344:
99345: /* INSTEAD of triggers are only for views and views only support INSTEAD
99346: ** of triggers.
99347: */
99348: if( pTab->pSelect && tr_tm!=TK_INSTEAD ){
99349: sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",
99350: (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0);
99351: goto trigger_cleanup;
99352: }
99353: if( !pTab->pSelect && tr_tm==TK_INSTEAD ){
99354: sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"
99355: " trigger on table: %S", pTableName, 0);
99356: goto trigger_cleanup;
99357: }
99358: iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
99359:
99360: #ifndef SQLITE_OMIT_AUTHORIZATION
99361: {
99362: int code = SQLITE_CREATE_TRIGGER;
99363: const char *zDb = db->aDb[iTabDb].zName;
99364: const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb;
99365: if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER;
99366: if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
99367: goto trigger_cleanup;
99368: }
99369: if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
99370: goto trigger_cleanup;
99371: }
99372: }
99373: #endif
99374:
99375: /* INSTEAD OF triggers can only appear on views and BEFORE triggers
99376: ** cannot appear on views. So we might as well translate every
99377: ** INSTEAD OF trigger into a BEFORE trigger. It simplifies code
99378: ** elsewhere.
99379: */
99380: if (tr_tm == TK_INSTEAD){
99381: tr_tm = TK_BEFORE;
99382: }
99383:
99384: /* Build the Trigger object */
99385: pTrigger = (Trigger*)sqlite3DbMallocZero(db, sizeof(Trigger));
99386: if( pTrigger==0 ) goto trigger_cleanup;
99387: pTrigger->zName = zName;
99388: zName = 0;
99389: pTrigger->table = sqlite3DbStrDup(db, pTableName->a[0].zName);
99390: pTrigger->pSchema = db->aDb[iDb].pSchema;
99391: pTrigger->pTabSchema = pTab->pSchema;
99392: pTrigger->op = (u8)op;
99393: pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;
99394: pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
99395: pTrigger->pColumns = sqlite3IdListDup(db, pColumns);
99396: assert( pParse->pNewTrigger==0 );
99397: pParse->pNewTrigger = pTrigger;
99398:
99399: trigger_cleanup:
99400: sqlite3DbFree(db, zName);
99401: sqlite3SrcListDelete(db, pTableName);
99402: sqlite3IdListDelete(db, pColumns);
99403: sqlite3ExprDelete(db, pWhen);
99404: if( !pParse->pNewTrigger ){
99405: sqlite3DeleteTrigger(db, pTrigger);
99406: }else{
99407: assert( pParse->pNewTrigger==pTrigger );
99408: }
99409: }
99410:
99411: /*
99412: ** This routine is called after all of the trigger actions have been parsed
99413: ** in order to complete the process of building the trigger.
99414: */
99415: SQLITE_PRIVATE void sqlite3FinishTrigger(
99416: Parse *pParse, /* Parser context */
99417: TriggerStep *pStepList, /* The triggered program */
99418: Token *pAll /* Token that describes the complete CREATE TRIGGER */
99419: ){
99420: Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */
99421: char *zName; /* Name of trigger */
99422: sqlite3 *db = pParse->db; /* The database */
99423: DbFixer sFix; /* Fixer object */
99424: int iDb; /* Database containing the trigger */
99425: Token nameToken; /* Trigger name for error reporting */
99426:
99427: pParse->pNewTrigger = 0;
99428: if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup;
99429: zName = pTrig->zName;
99430: iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
99431: pTrig->step_list = pStepList;
99432: while( pStepList ){
99433: pStepList->pTrig = pTrig;
99434: pStepList = pStepList->pNext;
99435: }
99436: nameToken.z = pTrig->zName;
99437: nameToken.n = sqlite3Strlen30(nameToken.z);
99438: if( sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken)
99439: && sqlite3FixTriggerStep(&sFix, pTrig->step_list) ){
99440: goto triggerfinish_cleanup;
99441: }
99442:
99443: /* if we are not initializing,
99444: ** build the sqlite_master entry
99445: */
99446: if( !db->init.busy ){
99447: Vdbe *v;
99448: char *z;
99449:
99450: /* Make an entry in the sqlite_master table */
99451: v = sqlite3GetVdbe(pParse);
99452: if( v==0 ) goto triggerfinish_cleanup;
99453: sqlite3BeginWriteOperation(pParse, 0, iDb);
99454: z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n);
99455: sqlite3NestedParse(pParse,
99456: "INSERT INTO %Q.%s VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')",
99457: db->aDb[iDb].zName, SCHEMA_TABLE(iDb), zName,
99458: pTrig->table, z);
99459: sqlite3DbFree(db, z);
99460: sqlite3ChangeCookie(pParse, iDb);
99461: sqlite3VdbeAddParseSchemaOp(v, iDb,
99462: sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
99463: }
99464:
99465: if( db->init.busy ){
99466: Trigger *pLink = pTrig;
99467: Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
99468: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
99469: pTrig = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), pTrig);
99470: if( pTrig ){
99471: db->mallocFailed = 1;
99472: }else if( pLink->pSchema==pLink->pTabSchema ){
99473: Table *pTab;
99474: int n = sqlite3Strlen30(pLink->table);
99475: pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table, n);
99476: assert( pTab!=0 );
99477: pLink->pNext = pTab->pTrigger;
99478: pTab->pTrigger = pLink;
99479: }
99480: }
99481:
99482: triggerfinish_cleanup:
99483: sqlite3DeleteTrigger(db, pTrig);
99484: assert( !pParse->pNewTrigger );
99485: sqlite3DeleteTriggerStep(db, pStepList);
99486: }
99487:
99488: /*
99489: ** Turn a SELECT statement (that the pSelect parameter points to) into
99490: ** a trigger step. Return a pointer to a TriggerStep structure.
99491: **
99492: ** The parser calls this routine when it finds a SELECT statement in
99493: ** body of a TRIGGER.
99494: */
99495: SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(sqlite3 *db, Select *pSelect){
99496: TriggerStep *pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep));
99497: if( pTriggerStep==0 ) {
99498: sqlite3SelectDelete(db, pSelect);
99499: return 0;
99500: }
99501: pTriggerStep->op = TK_SELECT;
99502: pTriggerStep->pSelect = pSelect;
99503: pTriggerStep->orconf = OE_Default;
99504: return pTriggerStep;
99505: }
99506:
99507: /*
99508: ** Allocate space to hold a new trigger step. The allocated space
99509: ** holds both the TriggerStep object and the TriggerStep.target.z string.
99510: **
99511: ** If an OOM error occurs, NULL is returned and db->mallocFailed is set.
99512: */
99513: static TriggerStep *triggerStepAllocate(
99514: sqlite3 *db, /* Database connection */
99515: u8 op, /* Trigger opcode */
99516: Token *pName /* The target name */
99517: ){
99518: TriggerStep *pTriggerStep;
99519:
99520: pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n);
99521: if( pTriggerStep ){
99522: char *z = (char*)&pTriggerStep[1];
99523: memcpy(z, pName->z, pName->n);
99524: pTriggerStep->target.z = z;
99525: pTriggerStep->target.n = pName->n;
99526: pTriggerStep->op = op;
99527: }
99528: return pTriggerStep;
99529: }
99530:
99531: /*
99532: ** Build a trigger step out of an INSERT statement. Return a pointer
99533: ** to the new trigger step.
99534: **
99535: ** The parser calls this routine when it sees an INSERT inside the
99536: ** body of a trigger.
99537: */
99538: SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(
99539: sqlite3 *db, /* The database connection */
99540: Token *pTableName, /* Name of the table into which we insert */
99541: IdList *pColumn, /* List of columns in pTableName to insert into */
99542: ExprList *pEList, /* The VALUE clause: a list of values to be inserted */
99543: Select *pSelect, /* A SELECT statement that supplies values */
99544: u8 orconf /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
99545: ){
99546: TriggerStep *pTriggerStep;
99547:
99548: assert(pEList == 0 || pSelect == 0);
99549: assert(pEList != 0 || pSelect != 0 || db->mallocFailed);
99550:
99551: pTriggerStep = triggerStepAllocate(db, TK_INSERT, pTableName);
99552: if( pTriggerStep ){
99553: pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
99554: pTriggerStep->pIdList = pColumn;
99555: pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
99556: pTriggerStep->orconf = orconf;
99557: }else{
99558: sqlite3IdListDelete(db, pColumn);
99559: }
99560: sqlite3ExprListDelete(db, pEList);
99561: sqlite3SelectDelete(db, pSelect);
99562:
99563: return pTriggerStep;
99564: }
99565:
99566: /*
99567: ** Construct a trigger step that implements an UPDATE statement and return
99568: ** a pointer to that trigger step. The parser calls this routine when it
99569: ** sees an UPDATE statement inside the body of a CREATE TRIGGER.
99570: */
99571: SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(
99572: sqlite3 *db, /* The database connection */
99573: Token *pTableName, /* Name of the table to be updated */
99574: ExprList *pEList, /* The SET clause: list of column and new values */
99575: Expr *pWhere, /* The WHERE clause */
99576: u8 orconf /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */
99577: ){
99578: TriggerStep *pTriggerStep;
99579:
99580: pTriggerStep = triggerStepAllocate(db, TK_UPDATE, pTableName);
99581: if( pTriggerStep ){
99582: pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
99583: pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
99584: pTriggerStep->orconf = orconf;
99585: }
99586: sqlite3ExprListDelete(db, pEList);
99587: sqlite3ExprDelete(db, pWhere);
99588: return pTriggerStep;
99589: }
99590:
99591: /*
99592: ** Construct a trigger step that implements a DELETE statement and return
99593: ** a pointer to that trigger step. The parser calls this routine when it
99594: ** sees a DELETE statement inside the body of a CREATE TRIGGER.
99595: */
99596: SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(
99597: sqlite3 *db, /* Database connection */
99598: Token *pTableName, /* The table from which rows are deleted */
99599: Expr *pWhere /* The WHERE clause */
99600: ){
99601: TriggerStep *pTriggerStep;
99602:
99603: pTriggerStep = triggerStepAllocate(db, TK_DELETE, pTableName);
99604: if( pTriggerStep ){
99605: pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
99606: pTriggerStep->orconf = OE_Default;
99607: }
99608: sqlite3ExprDelete(db, pWhere);
99609: return pTriggerStep;
99610: }
99611:
99612: /*
99613: ** Recursively delete a Trigger structure
99614: */
99615: SQLITE_PRIVATE void sqlite3DeleteTrigger(sqlite3 *db, Trigger *pTrigger){
99616: if( pTrigger==0 ) return;
99617: sqlite3DeleteTriggerStep(db, pTrigger->step_list);
99618: sqlite3DbFree(db, pTrigger->zName);
99619: sqlite3DbFree(db, pTrigger->table);
99620: sqlite3ExprDelete(db, pTrigger->pWhen);
99621: sqlite3IdListDelete(db, pTrigger->pColumns);
99622: sqlite3DbFree(db, pTrigger);
99623: }
99624:
99625: /*
99626: ** This function is called to drop a trigger from the database schema.
99627: **
99628: ** This may be called directly from the parser and therefore identifies
99629: ** the trigger by name. The sqlite3DropTriggerPtr() routine does the
99630: ** same job as this routine except it takes a pointer to the trigger
99631: ** instead of the trigger name.
99632: **/
99633: SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
99634: Trigger *pTrigger = 0;
99635: int i;
99636: const char *zDb;
99637: const char *zName;
99638: int nName;
99639: sqlite3 *db = pParse->db;
99640:
99641: if( db->mallocFailed ) goto drop_trigger_cleanup;
99642: if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
99643: goto drop_trigger_cleanup;
99644: }
99645:
99646: assert( pName->nSrc==1 );
99647: zDb = pName->a[0].zDatabase;
99648: zName = pName->a[0].zName;
99649: nName = sqlite3Strlen30(zName);
99650: assert( zDb!=0 || sqlite3BtreeHoldsAllMutexes(db) );
99651: for(i=OMIT_TEMPDB; i<db->nDb; i++){
99652: int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */
99653: if( zDb && sqlite3StrICmp(db->aDb[j].zName, zDb) ) continue;
99654: assert( sqlite3SchemaMutexHeld(db, j, 0) );
99655: pTrigger = sqlite3HashFind(&(db->aDb[j].pSchema->trigHash), zName, nName);
99656: if( pTrigger ) break;
99657: }
99658: if( !pTrigger ){
99659: if( !noErr ){
99660: sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);
99661: }else{
99662: sqlite3CodeVerifyNamedSchema(pParse, zDb);
99663: }
99664: pParse->checkSchema = 1;
99665: goto drop_trigger_cleanup;
99666: }
99667: sqlite3DropTriggerPtr(pParse, pTrigger);
99668:
99669: drop_trigger_cleanup:
99670: sqlite3SrcListDelete(db, pName);
99671: }
99672:
99673: /*
99674: ** Return a pointer to the Table structure for the table that a trigger
99675: ** is set on.
99676: */
99677: static Table *tableOfTrigger(Trigger *pTrigger){
99678: int n = sqlite3Strlen30(pTrigger->table);
99679: return sqlite3HashFind(&pTrigger->pTabSchema->tblHash, pTrigger->table, n);
99680: }
99681:
99682:
99683: /*
99684: ** Drop a trigger given a pointer to that trigger.
99685: */
99686: SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
99687: Table *pTable;
99688: Vdbe *v;
99689: sqlite3 *db = pParse->db;
99690: int iDb;
99691:
99692: iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
99693: assert( iDb>=0 && iDb<db->nDb );
99694: pTable = tableOfTrigger(pTrigger);
99695: assert( pTable );
99696: assert( pTable->pSchema==pTrigger->pSchema || iDb==1 );
99697: #ifndef SQLITE_OMIT_AUTHORIZATION
99698: {
99699: int code = SQLITE_DROP_TRIGGER;
99700: const char *zDb = db->aDb[iDb].zName;
99701: const char *zTab = SCHEMA_TABLE(iDb);
99702: if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
99703: if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
99704: sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
99705: return;
99706: }
99707: }
99708: #endif
99709:
99710: /* Generate code to destroy the database record of the trigger.
99711: */
99712: assert( pTable!=0 );
99713: if( (v = sqlite3GetVdbe(pParse))!=0 ){
99714: int base;
99715: static const VdbeOpList dropTrigger[] = {
99716: { OP_Rewind, 0, ADDR(9), 0},
99717: { OP_String8, 0, 1, 0}, /* 1 */
99718: { OP_Column, 0, 1, 2},
99719: { OP_Ne, 2, ADDR(8), 1},
99720: { OP_String8, 0, 1, 0}, /* 4: "trigger" */
99721: { OP_Column, 0, 0, 2},
99722: { OP_Ne, 2, ADDR(8), 1},
99723: { OP_Delete, 0, 0, 0},
99724: { OP_Next, 0, ADDR(1), 0}, /* 8 */
99725: };
99726:
99727: sqlite3BeginWriteOperation(pParse, 0, iDb);
99728: sqlite3OpenMasterTable(pParse, iDb);
99729: base = sqlite3VdbeAddOpList(v, ArraySize(dropTrigger), dropTrigger);
99730: sqlite3VdbeChangeP4(v, base+1, pTrigger->zName, P4_TRANSIENT);
99731: sqlite3VdbeChangeP4(v, base+4, "trigger", P4_STATIC);
99732: sqlite3ChangeCookie(pParse, iDb);
99733: sqlite3VdbeAddOp2(v, OP_Close, 0, 0);
99734: sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
99735: if( pParse->nMem<3 ){
99736: pParse->nMem = 3;
99737: }
99738: }
99739: }
99740:
99741: /*
99742: ** Remove a trigger from the hash tables of the sqlite* pointer.
99743: */
99744: SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTrigger(sqlite3 *db, int iDb, const char *zName){
99745: Trigger *pTrigger;
99746: Hash *pHash;
99747:
99748: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
99749: pHash = &(db->aDb[iDb].pSchema->trigHash);
99750: pTrigger = sqlite3HashInsert(pHash, zName, sqlite3Strlen30(zName), 0);
99751: if( ALWAYS(pTrigger) ){
99752: if( pTrigger->pSchema==pTrigger->pTabSchema ){
99753: Table *pTab = tableOfTrigger(pTrigger);
99754: Trigger **pp;
99755: for(pp=&pTab->pTrigger; *pp!=pTrigger; pp=&((*pp)->pNext));
99756: *pp = (*pp)->pNext;
99757: }
99758: sqlite3DeleteTrigger(db, pTrigger);
99759: db->flags |= SQLITE_InternChanges;
99760: }
99761: }
99762:
99763: /*
99764: ** pEList is the SET clause of an UPDATE statement. Each entry
99765: ** in pEList is of the format <id>=<expr>. If any of the entries
99766: ** in pEList have an <id> which matches an identifier in pIdList,
99767: ** then return TRUE. If pIdList==NULL, then it is considered a
99768: ** wildcard that matches anything. Likewise if pEList==NULL then
99769: ** it matches anything so always return true. Return false only
99770: ** if there is no match.
99771: */
99772: static int checkColumnOverlap(IdList *pIdList, ExprList *pEList){
99773: int e;
99774: if( pIdList==0 || NEVER(pEList==0) ) return 1;
99775: for(e=0; e<pEList->nExpr; e++){
99776: if( sqlite3IdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1;
99777: }
99778: return 0;
99779: }
99780:
99781: /*
99782: ** Return a list of all triggers on table pTab if there exists at least
99783: ** one trigger that must be fired when an operation of type 'op' is
99784: ** performed on the table, and, if that operation is an UPDATE, if at
99785: ** least one of the columns in pChanges is being modified.
99786: */
99787: SQLITE_PRIVATE Trigger *sqlite3TriggersExist(
99788: Parse *pParse, /* Parse context */
99789: Table *pTab, /* The table the contains the triggers */
99790: int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
99791: ExprList *pChanges, /* Columns that change in an UPDATE statement */
99792: int *pMask /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
99793: ){
99794: int mask = 0;
99795: Trigger *pList = 0;
99796: Trigger *p;
99797:
99798: if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){
99799: pList = sqlite3TriggerList(pParse, pTab);
99800: }
99801: assert( pList==0 || IsVirtual(pTab)==0 );
99802: for(p=pList; p; p=p->pNext){
99803: if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
99804: mask |= p->tr_tm;
99805: }
99806: }
99807: if( pMask ){
99808: *pMask = mask;
99809: }
99810: return (mask ? pList : 0);
99811: }
99812:
99813: /*
99814: ** Convert the pStep->target token into a SrcList and return a pointer
99815: ** to that SrcList.
99816: **
99817: ** This routine adds a specific database name, if needed, to the target when
99818: ** forming the SrcList. This prevents a trigger in one database from
99819: ** referring to a target in another database. An exception is when the
99820: ** trigger is in TEMP in which case it can refer to any other database it
99821: ** wants.
99822: */
99823: static SrcList *targetSrcList(
99824: Parse *pParse, /* The parsing context */
99825: TriggerStep *pStep /* The trigger containing the target token */
99826: ){
99827: int iDb; /* Index of the database to use */
99828: SrcList *pSrc; /* SrcList to be returned */
99829:
99830: pSrc = sqlite3SrcListAppend(pParse->db, 0, &pStep->target, 0);
99831: if( pSrc ){
99832: assert( pSrc->nSrc>0 );
99833: assert( pSrc->a!=0 );
99834: iDb = sqlite3SchemaToIndex(pParse->db, pStep->pTrig->pSchema);
99835: if( iDb==0 || iDb>=2 ){
99836: sqlite3 *db = pParse->db;
99837: assert( iDb<pParse->db->nDb );
99838: pSrc->a[pSrc->nSrc-1].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
99839: }
99840: }
99841: return pSrc;
99842: }
99843:
99844: /*
99845: ** Generate VDBE code for the statements inside the body of a single
99846: ** trigger.
99847: */
99848: static int codeTriggerProgram(
99849: Parse *pParse, /* The parser context */
99850: TriggerStep *pStepList, /* List of statements inside the trigger body */
99851: int orconf /* Conflict algorithm. (OE_Abort, etc) */
99852: ){
99853: TriggerStep *pStep;
99854: Vdbe *v = pParse->pVdbe;
99855: sqlite3 *db = pParse->db;
99856:
99857: assert( pParse->pTriggerTab && pParse->pToplevel );
99858: assert( pStepList );
99859: assert( v!=0 );
99860: for(pStep=pStepList; pStep; pStep=pStep->pNext){
99861: /* Figure out the ON CONFLICT policy that will be used for this step
99862: ** of the trigger program. If the statement that caused this trigger
99863: ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
99864: ** the ON CONFLICT policy that was specified as part of the trigger
99865: ** step statement. Example:
99866: **
99867: ** CREATE TRIGGER AFTER INSERT ON t1 BEGIN;
99868: ** INSERT OR REPLACE INTO t2 VALUES(new.a, new.b);
99869: ** END;
99870: **
99871: ** INSERT INTO t1 ... ; -- insert into t2 uses REPLACE policy
99872: ** INSERT OR IGNORE INTO t1 ... ; -- insert into t2 uses IGNORE policy
99873: */
99874: pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
99875:
99876: switch( pStep->op ){
99877: case TK_UPDATE: {
99878: sqlite3Update(pParse,
99879: targetSrcList(pParse, pStep),
99880: sqlite3ExprListDup(db, pStep->pExprList, 0),
99881: sqlite3ExprDup(db, pStep->pWhere, 0),
99882: pParse->eOrconf
99883: );
99884: break;
99885: }
99886: case TK_INSERT: {
99887: sqlite3Insert(pParse,
99888: targetSrcList(pParse, pStep),
99889: sqlite3ExprListDup(db, pStep->pExprList, 0),
99890: sqlite3SelectDup(db, pStep->pSelect, 0),
99891: sqlite3IdListDup(db, pStep->pIdList),
99892: pParse->eOrconf
99893: );
99894: break;
99895: }
99896: case TK_DELETE: {
99897: sqlite3DeleteFrom(pParse,
99898: targetSrcList(pParse, pStep),
99899: sqlite3ExprDup(db, pStep->pWhere, 0)
99900: );
99901: break;
99902: }
99903: default: assert( pStep->op==TK_SELECT ); {
99904: SelectDest sDest;
99905: Select *pSelect = sqlite3SelectDup(db, pStep->pSelect, 0);
99906: sqlite3SelectDestInit(&sDest, SRT_Discard, 0);
99907: sqlite3Select(pParse, pSelect, &sDest);
99908: sqlite3SelectDelete(db, pSelect);
99909: break;
99910: }
99911: }
99912: if( pStep->op!=TK_SELECT ){
99913: sqlite3VdbeAddOp0(v, OP_ResetCount);
99914: }
99915: }
99916:
99917: return 0;
99918: }
99919:
99920: #ifdef SQLITE_DEBUG
99921: /*
99922: ** This function is used to add VdbeComment() annotations to a VDBE
99923: ** program. It is not used in production code, only for debugging.
99924: */
99925: static const char *onErrorText(int onError){
99926: switch( onError ){
99927: case OE_Abort: return "abort";
99928: case OE_Rollback: return "rollback";
99929: case OE_Fail: return "fail";
99930: case OE_Replace: return "replace";
99931: case OE_Ignore: return "ignore";
99932: case OE_Default: return "default";
99933: }
99934: return "n/a";
99935: }
99936: #endif
99937:
99938: /*
99939: ** Parse context structure pFrom has just been used to create a sub-vdbe
99940: ** (trigger program). If an error has occurred, transfer error information
99941: ** from pFrom to pTo.
99942: */
99943: static void transferParseError(Parse *pTo, Parse *pFrom){
99944: assert( pFrom->zErrMsg==0 || pFrom->nErr );
99945: assert( pTo->zErrMsg==0 || pTo->nErr );
99946: if( pTo->nErr==0 ){
99947: pTo->zErrMsg = pFrom->zErrMsg;
99948: pTo->nErr = pFrom->nErr;
99949: }else{
99950: sqlite3DbFree(pFrom->db, pFrom->zErrMsg);
99951: }
99952: }
99953:
99954: /*
99955: ** Create and populate a new TriggerPrg object with a sub-program
99956: ** implementing trigger pTrigger with ON CONFLICT policy orconf.
99957: */
99958: static TriggerPrg *codeRowTrigger(
99959: Parse *pParse, /* Current parse context */
99960: Trigger *pTrigger, /* Trigger to code */
99961: Table *pTab, /* The table pTrigger is attached to */
99962: int orconf /* ON CONFLICT policy to code trigger program with */
99963: ){
99964: Parse *pTop = sqlite3ParseToplevel(pParse);
99965: sqlite3 *db = pParse->db; /* Database handle */
99966: TriggerPrg *pPrg; /* Value to return */
99967: Expr *pWhen = 0; /* Duplicate of trigger WHEN expression */
99968: Vdbe *v; /* Temporary VM */
99969: NameContext sNC; /* Name context for sub-vdbe */
99970: SubProgram *pProgram = 0; /* Sub-vdbe for trigger program */
99971: Parse *pSubParse; /* Parse context for sub-vdbe */
99972: int iEndTrigger = 0; /* Label to jump to if WHEN is false */
99973:
99974: assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
99975: assert( pTop->pVdbe );
99976:
99977: /* Allocate the TriggerPrg and SubProgram objects. To ensure that they
99978: ** are freed if an error occurs, link them into the Parse.pTriggerPrg
99979: ** list of the top-level Parse object sooner rather than later. */
99980: pPrg = sqlite3DbMallocZero(db, sizeof(TriggerPrg));
99981: if( !pPrg ) return 0;
99982: pPrg->pNext = pTop->pTriggerPrg;
99983: pTop->pTriggerPrg = pPrg;
99984: pPrg->pProgram = pProgram = sqlite3DbMallocZero(db, sizeof(SubProgram));
99985: if( !pProgram ) return 0;
99986: sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram);
99987: pPrg->pTrigger = pTrigger;
99988: pPrg->orconf = orconf;
99989: pPrg->aColmask[0] = 0xffffffff;
99990: pPrg->aColmask[1] = 0xffffffff;
99991:
99992: /* Allocate and populate a new Parse context to use for coding the
99993: ** trigger sub-program. */
99994: pSubParse = sqlite3StackAllocZero(db, sizeof(Parse));
99995: if( !pSubParse ) return 0;
99996: memset(&sNC, 0, sizeof(sNC));
99997: sNC.pParse = pSubParse;
99998: pSubParse->db = db;
99999: pSubParse->pTriggerTab = pTab;
100000: pSubParse->pToplevel = pTop;
100001: pSubParse->zAuthContext = pTrigger->zName;
100002: pSubParse->eTriggerOp = pTrigger->op;
100003: pSubParse->nQueryLoop = pParse->nQueryLoop;
100004:
100005: v = sqlite3GetVdbe(pSubParse);
100006: if( v ){
100007: VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)",
100008: pTrigger->zName, onErrorText(orconf),
100009: (pTrigger->tr_tm==TRIGGER_BEFORE ? "BEFORE" : "AFTER"),
100010: (pTrigger->op==TK_UPDATE ? "UPDATE" : ""),
100011: (pTrigger->op==TK_INSERT ? "INSERT" : ""),
100012: (pTrigger->op==TK_DELETE ? "DELETE" : ""),
100013: pTab->zName
100014: ));
100015: #ifndef SQLITE_OMIT_TRACE
100016: sqlite3VdbeChangeP4(v, -1,
100017: sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger->zName), P4_DYNAMIC
100018: );
100019: #endif
100020:
100021: /* If one was specified, code the WHEN clause. If it evaluates to false
100022: ** (or NULL) the sub-vdbe is immediately halted by jumping to the
100023: ** OP_Halt inserted at the end of the program. */
100024: if( pTrigger->pWhen ){
100025: pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0);
100026: if( SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
100027: && db->mallocFailed==0
100028: ){
100029: iEndTrigger = sqlite3VdbeMakeLabel(v);
100030: sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL);
100031: }
100032: sqlite3ExprDelete(db, pWhen);
100033: }
100034:
100035: /* Code the trigger program into the sub-vdbe. */
100036: codeTriggerProgram(pSubParse, pTrigger->step_list, orconf);
100037:
100038: /* Insert an OP_Halt at the end of the sub-program. */
100039: if( iEndTrigger ){
100040: sqlite3VdbeResolveLabel(v, iEndTrigger);
100041: }
100042: sqlite3VdbeAddOp0(v, OP_Halt);
100043: VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
100044:
100045: transferParseError(pParse, pSubParse);
100046: if( db->mallocFailed==0 ){
100047: pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg);
100048: }
100049: pProgram->nMem = pSubParse->nMem;
100050: pProgram->nCsr = pSubParse->nTab;
100051: pProgram->nOnce = pSubParse->nOnce;
100052: pProgram->token = (void *)pTrigger;
100053: pPrg->aColmask[0] = pSubParse->oldmask;
100054: pPrg->aColmask[1] = pSubParse->newmask;
100055: sqlite3VdbeDelete(v);
100056: }
100057:
100058: assert( !pSubParse->pAinc && !pSubParse->pZombieTab );
100059: assert( !pSubParse->pTriggerPrg && !pSubParse->nMaxArg );
100060: sqlite3StackFree(db, pSubParse);
100061:
100062: return pPrg;
100063: }
100064:
100065: /*
100066: ** Return a pointer to a TriggerPrg object containing the sub-program for
100067: ** trigger pTrigger with default ON CONFLICT algorithm orconf. If no such
100068: ** TriggerPrg object exists, a new object is allocated and populated before
100069: ** being returned.
100070: */
100071: static TriggerPrg *getRowTrigger(
100072: Parse *pParse, /* Current parse context */
100073: Trigger *pTrigger, /* Trigger to code */
100074: Table *pTab, /* The table trigger pTrigger is attached to */
100075: int orconf /* ON CONFLICT algorithm. */
100076: ){
100077: Parse *pRoot = sqlite3ParseToplevel(pParse);
100078: TriggerPrg *pPrg;
100079:
100080: assert( pTrigger->zName==0 || pTab==tableOfTrigger(pTrigger) );
100081:
100082: /* It may be that this trigger has already been coded (or is in the
100083: ** process of being coded). If this is the case, then an entry with
100084: ** a matching TriggerPrg.pTrigger field will be present somewhere
100085: ** in the Parse.pTriggerPrg list. Search for such an entry. */
100086: for(pPrg=pRoot->pTriggerPrg;
100087: pPrg && (pPrg->pTrigger!=pTrigger || pPrg->orconf!=orconf);
100088: pPrg=pPrg->pNext
100089: );
100090:
100091: /* If an existing TriggerPrg could not be located, create a new one. */
100092: if( !pPrg ){
100093: pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
100094: }
100095:
100096: return pPrg;
100097: }
100098:
100099: /*
100100: ** Generate code for the trigger program associated with trigger p on
100101: ** table pTab. The reg, orconf and ignoreJump parameters passed to this
100102: ** function are the same as those described in the header function for
100103: ** sqlite3CodeRowTrigger()
100104: */
100105: SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(
100106: Parse *pParse, /* Parse context */
100107: Trigger *p, /* Trigger to code */
100108: Table *pTab, /* The table to code triggers from */
100109: int reg, /* Reg array containing OLD.* and NEW.* values */
100110: int orconf, /* ON CONFLICT policy */
100111: int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */
100112: ){
100113: Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
100114: TriggerPrg *pPrg;
100115: pPrg = getRowTrigger(pParse, p, pTab, orconf);
100116: assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
100117:
100118: /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program
100119: ** is a pointer to the sub-vdbe containing the trigger program. */
100120: if( pPrg ){
100121: int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
100122:
100123: sqlite3VdbeAddOp3(v, OP_Program, reg, ignoreJump, ++pParse->nMem);
100124: sqlite3VdbeChangeP4(v, -1, (const char *)pPrg->pProgram, P4_SUBPROGRAM);
100125: VdbeComment(
100126: (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
100127:
100128: /* Set the P5 operand of the OP_Program instruction to non-zero if
100129: ** recursive invocation of this trigger program is disallowed. Recursive
100130: ** invocation is disallowed if (a) the sub-program is really a trigger,
100131: ** not a foreign key action, and (b) the flag to enable recursive triggers
100132: ** is clear. */
100133: sqlite3VdbeChangeP5(v, (u8)bRecursive);
100134: }
100135: }
100136:
100137: /*
100138: ** This is called to code the required FOR EACH ROW triggers for an operation
100139: ** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE)
100140: ** is given by the op paramater. The tr_tm parameter determines whether the
100141: ** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then
100142: ** parameter pChanges is passed the list of columns being modified.
100143: **
100144: ** If there are no triggers that fire at the specified time for the specified
100145: ** operation on pTab, this function is a no-op.
100146: **
100147: ** The reg argument is the address of the first in an array of registers
100148: ** that contain the values substituted for the new.* and old.* references
100149: ** in the trigger program. If N is the number of columns in table pTab
100150: ** (a copy of pTab->nCol), then registers are populated as follows:
100151: **
100152: ** Register Contains
100153: ** ------------------------------------------------------
100154: ** reg+0 OLD.rowid
100155: ** reg+1 OLD.* value of left-most column of pTab
100156: ** ... ...
100157: ** reg+N OLD.* value of right-most column of pTab
100158: ** reg+N+1 NEW.rowid
100159: ** reg+N+2 OLD.* value of left-most column of pTab
100160: ** ... ...
100161: ** reg+N+N+1 NEW.* value of right-most column of pTab
100162: **
100163: ** For ON DELETE triggers, the registers containing the NEW.* values will
100164: ** never be accessed by the trigger program, so they are not allocated or
100165: ** populated by the caller (there is no data to populate them with anyway).
100166: ** Similarly, for ON INSERT triggers the values stored in the OLD.* registers
100167: ** are never accessed, and so are not allocated by the caller. So, for an
100168: ** ON INSERT trigger, the value passed to this function as parameter reg
100169: ** is not a readable register, although registers (reg+N) through
100170: ** (reg+N+N+1) are.
100171: **
100172: ** Parameter orconf is the default conflict resolution algorithm for the
100173: ** trigger program to use (REPLACE, IGNORE etc.). Parameter ignoreJump
100174: ** is the instruction that control should jump to if a trigger program
100175: ** raises an IGNORE exception.
100176: */
100177: SQLITE_PRIVATE void sqlite3CodeRowTrigger(
100178: Parse *pParse, /* Parse context */
100179: Trigger *pTrigger, /* List of triggers on table pTab */
100180: int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */
100181: ExprList *pChanges, /* Changes list for any UPDATE OF triggers */
100182: int tr_tm, /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
100183: Table *pTab, /* The table to code triggers from */
100184: int reg, /* The first in an array of registers (see above) */
100185: int orconf, /* ON CONFLICT policy */
100186: int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */
100187: ){
100188: Trigger *p; /* Used to iterate through pTrigger list */
100189:
100190: assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE );
100191: assert( tr_tm==TRIGGER_BEFORE || tr_tm==TRIGGER_AFTER );
100192: assert( (op==TK_UPDATE)==(pChanges!=0) );
100193:
100194: for(p=pTrigger; p; p=p->pNext){
100195:
100196: /* Sanity checking: The schema for the trigger and for the table are
100197: ** always defined. The trigger must be in the same schema as the table
100198: ** or else it must be a TEMP trigger. */
100199: assert( p->pSchema!=0 );
100200: assert( p->pTabSchema!=0 );
100201: assert( p->pSchema==p->pTabSchema
100202: || p->pSchema==pParse->db->aDb[1].pSchema );
100203:
100204: /* Determine whether we should code this trigger */
100205: if( p->op==op
100206: && p->tr_tm==tr_tm
100207: && checkColumnOverlap(p->pColumns, pChanges)
100208: ){
100209: sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
100210: }
100211: }
100212: }
100213:
100214: /*
100215: ** Triggers may access values stored in the old.* or new.* pseudo-table.
100216: ** This function returns a 32-bit bitmask indicating which columns of the
100217: ** old.* or new.* tables actually are used by triggers. This information
100218: ** may be used by the caller, for example, to avoid having to load the entire
100219: ** old.* record into memory when executing an UPDATE or DELETE command.
100220: **
100221: ** Bit 0 of the returned mask is set if the left-most column of the
100222: ** table may be accessed using an [old|new].<col> reference. Bit 1 is set if
100223: ** the second leftmost column value is required, and so on. If there
100224: ** are more than 32 columns in the table, and at least one of the columns
100225: ** with an index greater than 32 may be accessed, 0xffffffff is returned.
100226: **
100227: ** It is not possible to determine if the old.rowid or new.rowid column is
100228: ** accessed by triggers. The caller must always assume that it is.
100229: **
100230: ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
100231: ** applies to the old.* table. If 1, the new.* table.
100232: **
100233: ** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE
100234: ** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only
100235: ** included in the returned mask if the TRIGGER_BEFORE bit is set in the
100236: ** tr_tm parameter. Similarly, values accessed by AFTER triggers are only
100237: ** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm.
100238: */
100239: SQLITE_PRIVATE u32 sqlite3TriggerColmask(
100240: Parse *pParse, /* Parse context */
100241: Trigger *pTrigger, /* List of triggers on table pTab */
100242: ExprList *pChanges, /* Changes list for any UPDATE OF triggers */
100243: int isNew, /* 1 for new.* ref mask, 0 for old.* ref mask */
100244: int tr_tm, /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
100245: Table *pTab, /* The table to code triggers from */
100246: int orconf /* Default ON CONFLICT policy for trigger steps */
100247: ){
100248: const int op = pChanges ? TK_UPDATE : TK_DELETE;
100249: u32 mask = 0;
100250: Trigger *p;
100251:
100252: assert( isNew==1 || isNew==0 );
100253: for(p=pTrigger; p; p=p->pNext){
100254: if( p->op==op && (tr_tm&p->tr_tm)
100255: && checkColumnOverlap(p->pColumns,pChanges)
100256: ){
100257: TriggerPrg *pPrg;
100258: pPrg = getRowTrigger(pParse, p, pTab, orconf);
100259: if( pPrg ){
100260: mask |= pPrg->aColmask[isNew];
100261: }
100262: }
100263: }
100264:
100265: return mask;
100266: }
100267:
100268: #endif /* !defined(SQLITE_OMIT_TRIGGER) */
100269:
100270: /************** End of trigger.c *********************************************/
100271: /************** Begin file update.c ******************************************/
100272: /*
100273: ** 2001 September 15
100274: **
100275: ** The author disclaims copyright to this source code. In place of
100276: ** a legal notice, here is a blessing:
100277: **
100278: ** May you do good and not evil.
100279: ** May you find forgiveness for yourself and forgive others.
100280: ** May you share freely, never taking more than you give.
100281: **
100282: *************************************************************************
100283: ** This file contains C code routines that are called by the parser
100284: ** to handle UPDATE statements.
100285: */
100286:
100287: #ifndef SQLITE_OMIT_VIRTUALTABLE
100288: /* Forward declaration */
100289: static void updateVirtualTable(
100290: Parse *pParse, /* The parsing context */
100291: SrcList *pSrc, /* The virtual table to be modified */
100292: Table *pTab, /* The virtual table */
100293: ExprList *pChanges, /* The columns to change in the UPDATE statement */
100294: Expr *pRowidExpr, /* Expression used to recompute the rowid */
100295: int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
100296: Expr *pWhere, /* WHERE clause of the UPDATE statement */
100297: int onError /* ON CONFLICT strategy */
100298: );
100299: #endif /* SQLITE_OMIT_VIRTUALTABLE */
100300:
100301: /*
100302: ** The most recently coded instruction was an OP_Column to retrieve the
100303: ** i-th column of table pTab. This routine sets the P4 parameter of the
100304: ** OP_Column to the default value, if any.
100305: **
100306: ** The default value of a column is specified by a DEFAULT clause in the
100307: ** column definition. This was either supplied by the user when the table
100308: ** was created, or added later to the table definition by an ALTER TABLE
100309: ** command. If the latter, then the row-records in the table btree on disk
100310: ** may not contain a value for the column and the default value, taken
100311: ** from the P4 parameter of the OP_Column instruction, is returned instead.
100312: ** If the former, then all row-records are guaranteed to include a value
100313: ** for the column and the P4 value is not required.
100314: **
100315: ** Column definitions created by an ALTER TABLE command may only have
100316: ** literal default values specified: a number, null or a string. (If a more
100317: ** complicated default expression value was provided, it is evaluated
100318: ** when the ALTER TABLE is executed and one of the literal values written
100319: ** into the sqlite_master table.)
100320: **
100321: ** Therefore, the P4 parameter is only required if the default value for
100322: ** the column is a literal number, string or null. The sqlite3ValueFromExpr()
100323: ** function is capable of transforming these types of expressions into
100324: ** sqlite3_value objects.
100325: **
100326: ** If parameter iReg is not negative, code an OP_RealAffinity instruction
100327: ** on register iReg. This is used when an equivalent integer value is
100328: ** stored in place of an 8-byte floating point value in order to save
100329: ** space.
100330: */
100331: SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
100332: assert( pTab!=0 );
100333: if( !pTab->pSelect ){
100334: sqlite3_value *pValue;
100335: u8 enc = ENC(sqlite3VdbeDb(v));
100336: Column *pCol = &pTab->aCol[i];
100337: VdbeComment((v, "%s.%s", pTab->zName, pCol->zName));
100338: assert( i<pTab->nCol );
100339: sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc,
100340: pCol->affinity, &pValue);
100341: if( pValue ){
100342: sqlite3VdbeChangeP4(v, -1, (const char *)pValue, P4_MEM);
100343: }
100344: #ifndef SQLITE_OMIT_FLOATING_POINT
100345: if( iReg>=0 && pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
100346: sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
100347: }
100348: #endif
100349: }
100350: }
100351:
100352: /*
100353: ** Process an UPDATE statement.
100354: **
100355: ** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
100356: ** \_______/ \________/ \______/ \________________/
100357: * onError pTabList pChanges pWhere
100358: */
100359: SQLITE_PRIVATE void sqlite3Update(
100360: Parse *pParse, /* The parser context */
100361: SrcList *pTabList, /* The table in which we should change things */
100362: ExprList *pChanges, /* Things to be changed */
100363: Expr *pWhere, /* The WHERE clause. May be null */
100364: int onError /* How to handle constraint errors */
100365: ){
100366: int i, j; /* Loop counters */
100367: Table *pTab; /* The table to be updated */
100368: int addr = 0; /* VDBE instruction address of the start of the loop */
100369: WhereInfo *pWInfo; /* Information about the WHERE clause */
100370: Vdbe *v; /* The virtual database engine */
100371: Index *pIdx; /* For looping over indices */
100372: int nIdx; /* Number of indices that need updating */
100373: int iCur; /* VDBE Cursor number of pTab */
100374: sqlite3 *db; /* The database structure */
100375: int *aRegIdx = 0; /* One register assigned to each index to be updated */
100376: int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the
100377: ** an expression for the i-th column of the table.
100378: ** aXRef[i]==-1 if the i-th column is not changed. */
100379: int chngRowid; /* True if the record number is being changed */
100380: Expr *pRowidExpr = 0; /* Expression defining the new record number */
100381: int openAll = 0; /* True if all indices need to be opened */
100382: AuthContext sContext; /* The authorization context */
100383: NameContext sNC; /* The name-context to resolve expressions in */
100384: int iDb; /* Database containing the table being updated */
100385: int okOnePass; /* True for one-pass algorithm without the FIFO */
100386: int hasFK; /* True if foreign key processing is required */
100387:
100388: #ifndef SQLITE_OMIT_TRIGGER
100389: int isView; /* True when updating a view (INSTEAD OF trigger) */
100390: Trigger *pTrigger; /* List of triggers on pTab, if required */
100391: int tmask; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
100392: #endif
100393: int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */
100394:
100395: /* Register Allocations */
100396: int regRowCount = 0; /* A count of rows changed */
100397: int regOldRowid; /* The old rowid */
100398: int regNewRowid; /* The new rowid */
100399: int regNew; /* Content of the NEW.* table in triggers */
100400: int regOld = 0; /* Content of OLD.* table in triggers */
100401: int regRowSet = 0; /* Rowset of rows to be updated */
100402:
100403: memset(&sContext, 0, sizeof(sContext));
100404: db = pParse->db;
100405: if( pParse->nErr || db->mallocFailed ){
100406: goto update_cleanup;
100407: }
100408: assert( pTabList->nSrc==1 );
100409:
100410: /* Locate the table which we want to update.
100411: */
100412: pTab = sqlite3SrcListLookup(pParse, pTabList);
100413: if( pTab==0 ) goto update_cleanup;
100414: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
100415:
100416: /* Figure out if we have any triggers and if the table being
100417: ** updated is a view.
100418: */
100419: #ifndef SQLITE_OMIT_TRIGGER
100420: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
100421: isView = pTab->pSelect!=0;
100422: assert( pTrigger || tmask==0 );
100423: #else
100424: # define pTrigger 0
100425: # define isView 0
100426: # define tmask 0
100427: #endif
100428: #ifdef SQLITE_OMIT_VIEW
100429: # undef isView
100430: # define isView 0
100431: #endif
100432:
100433: if( sqlite3ViewGetColumnNames(pParse, pTab) ){
100434: goto update_cleanup;
100435: }
100436: if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
100437: goto update_cleanup;
100438: }
100439: aXRef = sqlite3DbMallocRaw(db, sizeof(int) * pTab->nCol );
100440: if( aXRef==0 ) goto update_cleanup;
100441: for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
100442:
100443: /* Allocate a cursors for the main database table and for all indices.
100444: ** The index cursors might not be used, but if they are used they
100445: ** need to occur right after the database cursor. So go ahead and
100446: ** allocate enough space, just in case.
100447: */
100448: pTabList->a[0].iCursor = iCur = pParse->nTab++;
100449: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
100450: pParse->nTab++;
100451: }
100452:
100453: /* Initialize the name-context */
100454: memset(&sNC, 0, sizeof(sNC));
100455: sNC.pParse = pParse;
100456: sNC.pSrcList = pTabList;
100457:
100458: /* Resolve the column names in all the expressions of the
100459: ** of the UPDATE statement. Also find the column index
100460: ** for each column to be updated in the pChanges array. For each
100461: ** column to be updated, make sure we have authorization to change
100462: ** that column.
100463: */
100464: chngRowid = 0;
100465: for(i=0; i<pChanges->nExpr; i++){
100466: if( sqlite3ResolveExprNames(&sNC, pChanges->a[i].pExpr) ){
100467: goto update_cleanup;
100468: }
100469: for(j=0; j<pTab->nCol; j++){
100470: if( sqlite3StrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){
100471: if( j==pTab->iPKey ){
100472: chngRowid = 1;
100473: pRowidExpr = pChanges->a[i].pExpr;
100474: }
100475: aXRef[j] = i;
100476: break;
100477: }
100478: }
100479: if( j>=pTab->nCol ){
100480: if( sqlite3IsRowid(pChanges->a[i].zName) ){
100481: chngRowid = 1;
100482: pRowidExpr = pChanges->a[i].pExpr;
100483: }else{
100484: sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
100485: pParse->checkSchema = 1;
100486: goto update_cleanup;
100487: }
100488: }
100489: #ifndef SQLITE_OMIT_AUTHORIZATION
100490: {
100491: int rc;
100492: rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
100493: pTab->aCol[j].zName, db->aDb[iDb].zName);
100494: if( rc==SQLITE_DENY ){
100495: goto update_cleanup;
100496: }else if( rc==SQLITE_IGNORE ){
100497: aXRef[j] = -1;
100498: }
100499: }
100500: #endif
100501: }
100502:
100503: hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngRowid);
100504:
100505: /* Allocate memory for the array aRegIdx[]. There is one entry in the
100506: ** array for each index associated with table being updated. Fill in
100507: ** the value with a register number for indices that are to be used
100508: ** and with zero for unused indices.
100509: */
100510: for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
100511: if( nIdx>0 ){
100512: aRegIdx = sqlite3DbMallocRaw(db, sizeof(Index*) * nIdx );
100513: if( aRegIdx==0 ) goto update_cleanup;
100514: }
100515: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
100516: int reg;
100517: if( hasFK || chngRowid ){
100518: reg = ++pParse->nMem;
100519: }else{
100520: reg = 0;
100521: for(i=0; i<pIdx->nColumn; i++){
100522: if( aXRef[pIdx->aiColumn[i]]>=0 ){
100523: reg = ++pParse->nMem;
100524: break;
100525: }
100526: }
100527: }
100528: aRegIdx[j] = reg;
100529: }
100530:
100531: /* Begin generating code. */
100532: v = sqlite3GetVdbe(pParse);
100533: if( v==0 ) goto update_cleanup;
100534: if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
100535: sqlite3BeginWriteOperation(pParse, 1, iDb);
100536:
100537: #ifndef SQLITE_OMIT_VIRTUALTABLE
100538: /* Virtual tables must be handled separately */
100539: if( IsVirtual(pTab) ){
100540: updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
100541: pWhere, onError);
100542: pWhere = 0;
100543: pTabList = 0;
100544: goto update_cleanup;
100545: }
100546: #endif
100547:
100548: /* Allocate required registers. */
100549: regRowSet = ++pParse->nMem;
100550: regOldRowid = regNewRowid = ++pParse->nMem;
100551: if( pTrigger || hasFK ){
100552: regOld = pParse->nMem + 1;
100553: pParse->nMem += pTab->nCol;
100554: }
100555: if( chngRowid || pTrigger || hasFK ){
100556: regNewRowid = ++pParse->nMem;
100557: }
100558: regNew = pParse->nMem + 1;
100559: pParse->nMem += pTab->nCol;
100560:
100561: /* Start the view context. */
100562: if( isView ){
100563: sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
100564: }
100565:
100566: /* If we are trying to update a view, realize that view into
100567: ** a ephemeral table.
100568: */
100569: #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER)
100570: if( isView ){
100571: sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
100572: }
100573: #endif
100574:
100575: /* Resolve the column names in all the expressions in the
100576: ** WHERE clause.
100577: */
100578: if( sqlite3ResolveExprNames(&sNC, pWhere) ){
100579: goto update_cleanup;
100580: }
100581:
100582: /* Begin the database scan
100583: */
100584: sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
100585: pWInfo = sqlite3WhereBegin(
100586: pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED
100587: );
100588: if( pWInfo==0 ) goto update_cleanup;
100589: okOnePass = pWInfo->okOnePass;
100590:
100591: /* Remember the rowid of every item to be updated.
100592: */
100593: sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regOldRowid);
100594: if( !okOnePass ){
100595: sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
100596: }
100597:
100598: /* End the database scan loop.
100599: */
100600: sqlite3WhereEnd(pWInfo);
100601:
100602: /* Initialize the count of updated rows
100603: */
100604: if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
100605: regRowCount = ++pParse->nMem;
100606: sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
100607: }
100608:
100609: if( !isView ){
100610: /*
100611: ** Open every index that needs updating. Note that if any
100612: ** index could potentially invoke a REPLACE conflict resolution
100613: ** action, then we need to open all indices because we might need
100614: ** to be deleting some records.
100615: */
100616: if( !okOnePass ) sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
100617: if( onError==OE_Replace ){
100618: openAll = 1;
100619: }else{
100620: openAll = 0;
100621: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
100622: if( pIdx->onError==OE_Replace ){
100623: openAll = 1;
100624: break;
100625: }
100626: }
100627: }
100628: for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
100629: assert( aRegIdx );
100630: if( openAll || aRegIdx[i]>0 ){
100631: KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
100632: sqlite3VdbeAddOp4(v, OP_OpenWrite, iCur+i+1, pIdx->tnum, iDb,
100633: (char*)pKey, P4_KEYINFO_HANDOFF);
100634: assert( pParse->nTab>iCur+i+1 );
100635: }
100636: }
100637: }
100638:
100639: /* Top of the update loop */
100640: if( okOnePass ){
100641: int a1 = sqlite3VdbeAddOp1(v, OP_NotNull, regOldRowid);
100642: addr = sqlite3VdbeAddOp0(v, OP_Goto);
100643: sqlite3VdbeJumpHere(v, a1);
100644: }else{
100645: addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, 0, regOldRowid);
100646: }
100647:
100648: /* Make cursor iCur point to the record that is being updated. If
100649: ** this record does not exist for some reason (deleted by a trigger,
100650: ** for example, then jump to the next iteration of the RowSet loop. */
100651: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
100652:
100653: /* If the record number will change, set register regNewRowid to
100654: ** contain the new value. If the record number is not being modified,
100655: ** then regNewRowid is the same register as regOldRowid, which is
100656: ** already populated. */
100657: assert( chngRowid || pTrigger || hasFK || regOldRowid==regNewRowid );
100658: if( chngRowid ){
100659: sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
100660: sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid);
100661: }
100662:
100663: /* If there are triggers on this table, populate an array of registers
100664: ** with the required old.* column data. */
100665: if( hasFK || pTrigger ){
100666: u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
100667: oldmask |= sqlite3TriggerColmask(pParse,
100668: pTrigger, pChanges, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onError
100669: );
100670: for(i=0; i<pTab->nCol; i++){
100671: if( aXRef[i]<0 || oldmask==0xffffffff || (i<32 && (oldmask & (1<<i))) ){
100672: sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOld+i);
100673: }else{
100674: sqlite3VdbeAddOp2(v, OP_Null, 0, regOld+i);
100675: }
100676: }
100677: if( chngRowid==0 ){
100678: sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
100679: }
100680: }
100681:
100682: /* Populate the array of registers beginning at regNew with the new
100683: ** row data. This array is used to check constaints, create the new
100684: ** table and index records, and as the values for any new.* references
100685: ** made by triggers.
100686: **
100687: ** If there are one or more BEFORE triggers, then do not populate the
100688: ** registers associated with columns that are (a) not modified by
100689: ** this UPDATE statement and (b) not accessed by new.* references. The
100690: ** values for registers not modified by the UPDATE must be reloaded from
100691: ** the database after the BEFORE triggers are fired anyway (as the trigger
100692: ** may have modified them). So not loading those that are not going to
100693: ** be used eliminates some redundant opcodes.
100694: */
100695: newmask = sqlite3TriggerColmask(
100696: pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
100697: );
100698: sqlite3VdbeAddOp3(v, OP_Null, 0, regNew, regNew+pTab->nCol-1);
100699: for(i=0; i<pTab->nCol; i++){
100700: if( i==pTab->iPKey ){
100701: /*sqlite3VdbeAddOp2(v, OP_Null, 0, regNew+i);*/
100702: }else{
100703: j = aXRef[i];
100704: if( j>=0 ){
100705: sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
100706: }else if( 0==(tmask&TRIGGER_BEFORE) || i>31 || (newmask&(1<<i)) ){
100707: /* This branch loads the value of a column that will not be changed
100708: ** into a register. This is done if there are no BEFORE triggers, or
100709: ** if there are one or more BEFORE triggers that use this value via
100710: ** a new.* reference in a trigger program.
100711: */
100712: testcase( i==31 );
100713: testcase( i==32 );
100714: sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
100715: sqlite3ColumnDefault(v, pTab, i, regNew+i);
100716: }
100717: }
100718: }
100719:
100720: /* Fire any BEFORE UPDATE triggers. This happens before constraints are
100721: ** verified. One could argue that this is wrong.
100722: */
100723: if( tmask&TRIGGER_BEFORE ){
100724: sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab->nCol);
100725: sqlite3TableAffinityStr(v, pTab);
100726: sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
100727: TRIGGER_BEFORE, pTab, regOldRowid, onError, addr);
100728:
100729: /* The row-trigger may have deleted the row being updated. In this
100730: ** case, jump to the next row. No updates or AFTER triggers are
100731: ** required. This behaviour - what happens when the row being updated
100732: ** is deleted or renamed by a BEFORE trigger - is left undefined in the
100733: ** documentation.
100734: */
100735: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
100736:
100737: /* If it did not delete it, the row-trigger may still have modified
100738: ** some of the columns of the row being updated. Load the values for
100739: ** all columns not modified by the update statement into their
100740: ** registers in case this has happened.
100741: */
100742: for(i=0; i<pTab->nCol; i++){
100743: if( aXRef[i]<0 && i!=pTab->iPKey ){
100744: sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew+i);
100745: sqlite3ColumnDefault(v, pTab, i, regNew+i);
100746: }
100747: }
100748: }
100749:
100750: if( !isView ){
100751: int j1; /* Address of jump instruction */
100752:
100753: /* Do constraint checks. */
100754: sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,
100755: aRegIdx, (chngRowid?regOldRowid:0), 1, onError, addr, 0);
100756:
100757: /* Do FK constraint checks. */
100758: if( hasFK ){
100759: sqlite3FkCheck(pParse, pTab, regOldRowid, 0);
100760: }
100761:
100762: /* Delete the index entries associated with the current record. */
100763: j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);
100764: sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);
100765:
100766: /* If changing the record number, delete the old record. */
100767: if( hasFK || chngRowid ){
100768: sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0);
100769: }
100770: sqlite3VdbeJumpHere(v, j1);
100771:
100772: if( hasFK ){
100773: sqlite3FkCheck(pParse, pTab, 0, regNewRowid);
100774: }
100775:
100776: /* Insert the new index entries and the new record. */
100777: sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, 0, 0);
100778:
100779: /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
100780: ** handle rows (possibly in other tables) that refer via a foreign key
100781: ** to the row just updated. */
100782: if( hasFK ){
100783: sqlite3FkActions(pParse, pTab, pChanges, regOldRowid);
100784: }
100785: }
100786:
100787: /* Increment the row counter
100788: */
100789: if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
100790: sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
100791: }
100792:
100793: sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
100794: TRIGGER_AFTER, pTab, regOldRowid, onError, addr);
100795:
100796: /* Repeat the above with the next record to be updated, until
100797: ** all record selected by the WHERE clause have been updated.
100798: */
100799: sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
100800: sqlite3VdbeJumpHere(v, addr);
100801:
100802: /* Close all tables */
100803: for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
100804: assert( aRegIdx );
100805: if( openAll || aRegIdx[i]>0 ){
100806: sqlite3VdbeAddOp2(v, OP_Close, iCur+i+1, 0);
100807: }
100808: }
100809: sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);
100810:
100811: /* Update the sqlite_sequence table by storing the content of the
100812: ** maximum rowid counter values recorded while inserting into
100813: ** autoincrement tables.
100814: */
100815: if( pParse->nested==0 && pParse->pTriggerTab==0 ){
100816: sqlite3AutoincrementEnd(pParse);
100817: }
100818:
100819: /*
100820: ** Return the number of rows that were changed. If this routine is
100821: ** generating code because of a call to sqlite3NestedParse(), do not
100822: ** invoke the callback function.
100823: */
100824: if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
100825: sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
100826: sqlite3VdbeSetNumCols(v, 1);
100827: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
100828: }
100829:
100830: update_cleanup:
100831: sqlite3AuthContextPop(&sContext);
100832: sqlite3DbFree(db, aRegIdx);
100833: sqlite3DbFree(db, aXRef);
100834: sqlite3SrcListDelete(db, pTabList);
100835: sqlite3ExprListDelete(db, pChanges);
100836: sqlite3ExprDelete(db, pWhere);
100837: return;
100838: }
100839: /* Make sure "isView" and other macros defined above are undefined. Otherwise
100840: ** thely may interfere with compilation of other functions in this file
100841: ** (or in another file, if this file becomes part of the amalgamation). */
100842: #ifdef isView
100843: #undef isView
100844: #endif
100845: #ifdef pTrigger
100846: #undef pTrigger
100847: #endif
100848:
100849: #ifndef SQLITE_OMIT_VIRTUALTABLE
100850: /*
100851: ** Generate code for an UPDATE of a virtual table.
100852: **
100853: ** The strategy is that we create an ephemerial table that contains
100854: ** for each row to be changed:
100855: **
100856: ** (A) The original rowid of that row.
100857: ** (B) The revised rowid for the row. (note1)
100858: ** (C) The content of every column in the row.
100859: **
100860: ** Then we loop over this ephemeral table and for each row in
100861: ** the ephermeral table call VUpdate.
100862: **
100863: ** When finished, drop the ephemeral table.
100864: **
100865: ** (note1) Actually, if we know in advance that (A) is always the same
100866: ** as (B) we only store (A), then duplicate (A) when pulling
100867: ** it out of the ephemeral table before calling VUpdate.
100868: */
100869: static void updateVirtualTable(
100870: Parse *pParse, /* The parsing context */
100871: SrcList *pSrc, /* The virtual table to be modified */
100872: Table *pTab, /* The virtual table */
100873: ExprList *pChanges, /* The columns to change in the UPDATE statement */
100874: Expr *pRowid, /* Expression used to recompute the rowid */
100875: int *aXRef, /* Mapping from columns of pTab to entries in pChanges */
100876: Expr *pWhere, /* WHERE clause of the UPDATE statement */
100877: int onError /* ON CONFLICT strategy */
100878: ){
100879: Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
100880: ExprList *pEList = 0; /* The result set of the SELECT statement */
100881: Select *pSelect = 0; /* The SELECT statement */
100882: Expr *pExpr; /* Temporary expression */
100883: int ephemTab; /* Table holding the result of the SELECT */
100884: int i; /* Loop counter */
100885: int addr; /* Address of top of loop */
100886: int iReg; /* First register in set passed to OP_VUpdate */
100887: sqlite3 *db = pParse->db; /* Database connection */
100888: const char *pVTab = (const char*)sqlite3GetVTable(db, pTab);
100889: SelectDest dest;
100890:
100891: /* Construct the SELECT statement that will find the new values for
100892: ** all updated rows.
100893: */
100894: pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, "_rowid_"));
100895: if( pRowid ){
100896: pEList = sqlite3ExprListAppend(pParse, pEList,
100897: sqlite3ExprDup(db, pRowid, 0));
100898: }
100899: assert( pTab->iPKey<0 );
100900: for(i=0; i<pTab->nCol; i++){
100901: if( aXRef[i]>=0 ){
100902: pExpr = sqlite3ExprDup(db, pChanges->a[aXRef[i]].pExpr, 0);
100903: }else{
100904: pExpr = sqlite3Expr(db, TK_ID, pTab->aCol[i].zName);
100905: }
100906: pEList = sqlite3ExprListAppend(pParse, pEList, pExpr);
100907: }
100908: pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0);
100909:
100910: /* Create the ephemeral table into which the update results will
100911: ** be stored.
100912: */
100913: assert( v );
100914: ephemTab = pParse->nTab++;
100915: sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab->nCol+1+(pRowid!=0));
100916: sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
100917:
100918: /* fill the ephemeral table
100919: */
100920: sqlite3SelectDestInit(&dest, SRT_Table, ephemTab);
100921: sqlite3Select(pParse, pSelect, &dest);
100922:
100923: /* Generate code to scan the ephemeral table and call VUpdate. */
100924: iReg = ++pParse->nMem;
100925: pParse->nMem += pTab->nCol+1;
100926: addr = sqlite3VdbeAddOp2(v, OP_Rewind, ephemTab, 0);
100927: sqlite3VdbeAddOp3(v, OP_Column, ephemTab, 0, iReg);
100928: sqlite3VdbeAddOp3(v, OP_Column, ephemTab, (pRowid?1:0), iReg+1);
100929: for(i=0; i<pTab->nCol; i++){
100930: sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i+1+(pRowid!=0), iReg+2+i);
100931: }
100932: sqlite3VtabMakeWritable(pParse, pTab);
100933: sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab->nCol+2, iReg, pVTab, P4_VTAB);
100934: sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
100935: sqlite3MayAbort(pParse);
100936: sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1);
100937: sqlite3VdbeJumpHere(v, addr);
100938: sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
100939:
100940: /* Cleanup */
100941: sqlite3SelectDelete(db, pSelect);
100942: }
100943: #endif /* SQLITE_OMIT_VIRTUALTABLE */
100944:
100945: /************** End of update.c **********************************************/
100946: /************** Begin file vacuum.c ******************************************/
100947: /*
100948: ** 2003 April 6
100949: **
100950: ** The author disclaims copyright to this source code. In place of
100951: ** a legal notice, here is a blessing:
100952: **
100953: ** May you do good and not evil.
100954: ** May you find forgiveness for yourself and forgive others.
100955: ** May you share freely, never taking more than you give.
100956: **
100957: *************************************************************************
100958: ** This file contains code used to implement the VACUUM command.
100959: **
100960: ** Most of the code in this file may be omitted by defining the
100961: ** SQLITE_OMIT_VACUUM macro.
100962: */
100963:
100964: #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
100965: /*
100966: ** Finalize a prepared statement. If there was an error, store the
100967: ** text of the error message in *pzErrMsg. Return the result code.
100968: */
100969: static int vacuumFinalize(sqlite3 *db, sqlite3_stmt *pStmt, char **pzErrMsg){
100970: int rc;
100971: rc = sqlite3VdbeFinalize((Vdbe*)pStmt);
100972: if( rc ){
100973: sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db));
100974: }
100975: return rc;
100976: }
100977:
100978: /*
100979: ** Execute zSql on database db. Return an error code.
100980: */
100981: static int execSql(sqlite3 *db, char **pzErrMsg, const char *zSql){
100982: sqlite3_stmt *pStmt;
100983: VVA_ONLY( int rc; )
100984: if( !zSql ){
100985: return SQLITE_NOMEM;
100986: }
100987: if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){
100988: sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db));
100989: return sqlite3_errcode(db);
100990: }
100991: VVA_ONLY( rc = ) sqlite3_step(pStmt);
100992: assert( rc!=SQLITE_ROW || (db->flags&SQLITE_CountRows) );
100993: return vacuumFinalize(db, pStmt, pzErrMsg);
100994: }
100995:
100996: /*
100997: ** Execute zSql on database db. The statement returns exactly
100998: ** one column. Execute this as SQL on the same database.
100999: */
101000: static int execExecSql(sqlite3 *db, char **pzErrMsg, const char *zSql){
101001: sqlite3_stmt *pStmt;
101002: int rc;
101003:
101004: rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
101005: if( rc!=SQLITE_OK ) return rc;
101006:
101007: while( SQLITE_ROW==sqlite3_step(pStmt) ){
101008: rc = execSql(db, pzErrMsg, (char*)sqlite3_column_text(pStmt, 0));
101009: if( rc!=SQLITE_OK ){
101010: vacuumFinalize(db, pStmt, pzErrMsg);
101011: return rc;
101012: }
101013: }
101014:
101015: return vacuumFinalize(db, pStmt, pzErrMsg);
101016: }
101017:
101018: /*
101019: ** The non-standard VACUUM command is used to clean up the database,
101020: ** collapse free space, etc. It is modelled after the VACUUM command
101021: ** in PostgreSQL.
101022: **
101023: ** In version 1.0.x of SQLite, the VACUUM command would call
101024: ** gdbm_reorganize() on all the database tables. But beginning
101025: ** with 2.0.0, SQLite no longer uses GDBM so this command has
101026: ** become a no-op.
101027: */
101028: SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse){
101029: Vdbe *v = sqlite3GetVdbe(pParse);
101030: if( v ){
101031: sqlite3VdbeAddOp2(v, OP_Vacuum, 0, 0);
101032: }
101033: return;
101034: }
101035:
101036: /*
101037: ** This routine implements the OP_Vacuum opcode of the VDBE.
101038: */
101039: SQLITE_PRIVATE int sqlite3RunVacuum(char **pzErrMsg, sqlite3 *db){
101040: int rc = SQLITE_OK; /* Return code from service routines */
101041: Btree *pMain; /* The database being vacuumed */
101042: Btree *pTemp; /* The temporary database we vacuum into */
101043: char *zSql = 0; /* SQL statements */
101044: int saved_flags; /* Saved value of the db->flags */
101045: int saved_nChange; /* Saved value of db->nChange */
101046: int saved_nTotalChange; /* Saved value of db->nTotalChange */
101047: void (*saved_xTrace)(void*,const char*); /* Saved db->xTrace */
101048: Db *pDb = 0; /* Database to detach at end of vacuum */
101049: int isMemDb; /* True if vacuuming a :memory: database */
101050: int nRes; /* Bytes of reserved space at the end of each page */
101051: int nDb; /* Number of attached databases */
101052:
101053: if( !db->autoCommit ){
101054: sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
101055: return SQLITE_ERROR;
101056: }
101057: if( db->activeVdbeCnt>1 ){
101058: sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
101059: return SQLITE_ERROR;
101060: }
101061:
101062: /* Save the current value of the database flags so that it can be
101063: ** restored before returning. Then set the writable-schema flag, and
101064: ** disable CHECK and foreign key constraints. */
101065: saved_flags = db->flags;
101066: saved_nChange = db->nChange;
101067: saved_nTotalChange = db->nTotalChange;
101068: saved_xTrace = db->xTrace;
101069: db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks | SQLITE_PreferBuiltin;
101070: db->flags &= ~(SQLITE_ForeignKeys | SQLITE_ReverseOrder);
101071: db->xTrace = 0;
101072:
101073: pMain = db->aDb[0].pBt;
101074: isMemDb = sqlite3PagerIsMemdb(sqlite3BtreePager(pMain));
101075:
101076: /* Attach the temporary database as 'vacuum_db'. The synchronous pragma
101077: ** can be set to 'off' for this file, as it is not recovered if a crash
101078: ** occurs anyway. The integrity of the database is maintained by a
101079: ** (possibly synchronous) transaction opened on the main database before
101080: ** sqlite3BtreeCopyFile() is called.
101081: **
101082: ** An optimisation would be to use a non-journaled pager.
101083: ** (Later:) I tried setting "PRAGMA vacuum_db.journal_mode=OFF" but
101084: ** that actually made the VACUUM run slower. Very little journalling
101085: ** actually occurs when doing a vacuum since the vacuum_db is initially
101086: ** empty. Only the journal header is written. Apparently it takes more
101087: ** time to parse and run the PRAGMA to turn journalling off than it does
101088: ** to write the journal header file.
101089: */
101090: nDb = db->nDb;
101091: if( sqlite3TempInMemory(db) ){
101092: zSql = "ATTACH ':memory:' AS vacuum_db;";
101093: }else{
101094: zSql = "ATTACH '' AS vacuum_db;";
101095: }
101096: rc = execSql(db, pzErrMsg, zSql);
101097: if( db->nDb>nDb ){
101098: pDb = &db->aDb[db->nDb-1];
101099: assert( strcmp(pDb->zName,"vacuum_db")==0 );
101100: }
101101: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101102: pTemp = db->aDb[db->nDb-1].pBt;
101103:
101104: /* The call to execSql() to attach the temp database has left the file
101105: ** locked (as there was more than one active statement when the transaction
101106: ** to read the schema was concluded. Unlock it here so that this doesn't
101107: ** cause problems for the call to BtreeSetPageSize() below. */
101108: sqlite3BtreeCommit(pTemp);
101109:
101110: nRes = sqlite3BtreeGetReserve(pMain);
101111:
101112: /* A VACUUM cannot change the pagesize of an encrypted database. */
101113: #ifdef SQLITE_HAS_CODEC
101114: if( db->nextPagesize ){
101115: extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
101116: int nKey;
101117: char *zKey;
101118: sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
101119: if( nKey ) db->nextPagesize = 0;
101120: }
101121: #endif
101122:
101123: /* Do not attempt to change the page size for a WAL database */
101124: if( sqlite3PagerGetJournalMode(sqlite3BtreePager(pMain))
101125: ==PAGER_JOURNALMODE_WAL ){
101126: db->nextPagesize = 0;
101127: }
101128:
101129: if( sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain), nRes, 0)
101130: || (!isMemDb && sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes, 0))
101131: || NEVER(db->mallocFailed)
101132: ){
101133: rc = SQLITE_NOMEM;
101134: goto end_of_vacuum;
101135: }
101136: rc = execSql(db, pzErrMsg, "PRAGMA vacuum_db.synchronous=OFF");
101137: if( rc!=SQLITE_OK ){
101138: goto end_of_vacuum;
101139: }
101140:
101141: #ifndef SQLITE_OMIT_AUTOVACUUM
101142: sqlite3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac :
101143: sqlite3BtreeGetAutoVacuum(pMain));
101144: #endif
101145:
101146: /* Begin a transaction */
101147: rc = execSql(db, pzErrMsg, "BEGIN EXCLUSIVE;");
101148: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101149:
101150: /* Query the schema of the main database. Create a mirror schema
101151: ** in the temporary database.
101152: */
101153: rc = execExecSql(db, pzErrMsg,
101154: "SELECT 'CREATE TABLE vacuum_db.' || substr(sql,14) "
101155: " FROM sqlite_master WHERE type='table' AND name!='sqlite_sequence'"
101156: " AND rootpage>0"
101157: );
101158: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101159: rc = execExecSql(db, pzErrMsg,
101160: "SELECT 'CREATE INDEX vacuum_db.' || substr(sql,14)"
101161: " FROM sqlite_master WHERE sql LIKE 'CREATE INDEX %' ");
101162: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101163: rc = execExecSql(db, pzErrMsg,
101164: "SELECT 'CREATE UNIQUE INDEX vacuum_db.' || substr(sql,21) "
101165: " FROM sqlite_master WHERE sql LIKE 'CREATE UNIQUE INDEX %'");
101166: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101167:
101168: /* Loop through the tables in the main database. For each, do
101169: ** an "INSERT INTO vacuum_db.xxx SELECT * FROM main.xxx;" to copy
101170: ** the contents to the temporary database.
101171: */
101172: rc = execExecSql(db, pzErrMsg,
101173: "SELECT 'INSERT INTO vacuum_db.' || quote(name) "
101174: "|| ' SELECT * FROM main.' || quote(name) || ';'"
101175: "FROM main.sqlite_master "
101176: "WHERE type = 'table' AND name!='sqlite_sequence' "
101177: " AND rootpage>0"
101178: );
101179: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101180:
101181: /* Copy over the sequence table
101182: */
101183: rc = execExecSql(db, pzErrMsg,
101184: "SELECT 'DELETE FROM vacuum_db.' || quote(name) || ';' "
101185: "FROM vacuum_db.sqlite_master WHERE name='sqlite_sequence' "
101186: );
101187: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101188: rc = execExecSql(db, pzErrMsg,
101189: "SELECT 'INSERT INTO vacuum_db.' || quote(name) "
101190: "|| ' SELECT * FROM main.' || quote(name) || ';' "
101191: "FROM vacuum_db.sqlite_master WHERE name=='sqlite_sequence';"
101192: );
101193: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101194:
101195:
101196: /* Copy the triggers, views, and virtual tables from the main database
101197: ** over to the temporary database. None of these objects has any
101198: ** associated storage, so all we have to do is copy their entries
101199: ** from the SQLITE_MASTER table.
101200: */
101201: rc = execSql(db, pzErrMsg,
101202: "INSERT INTO vacuum_db.sqlite_master "
101203: " SELECT type, name, tbl_name, rootpage, sql"
101204: " FROM main.sqlite_master"
101205: " WHERE type='view' OR type='trigger'"
101206: " OR (type='table' AND rootpage=0)"
101207: );
101208: if( rc ) goto end_of_vacuum;
101209:
101210: /* At this point, there is a write transaction open on both the
101211: ** vacuum database and the main database. Assuming no error occurs,
101212: ** both transactions are closed by this block - the main database
101213: ** transaction by sqlite3BtreeCopyFile() and the other by an explicit
101214: ** call to sqlite3BtreeCommit().
101215: */
101216: {
101217: u32 meta;
101218: int i;
101219:
101220: /* This array determines which meta meta values are preserved in the
101221: ** vacuum. Even entries are the meta value number and odd entries
101222: ** are an increment to apply to the meta value after the vacuum.
101223: ** The increment is used to increase the schema cookie so that other
101224: ** connections to the same database will know to reread the schema.
101225: */
101226: static const unsigned char aCopy[] = {
101227: BTREE_SCHEMA_VERSION, 1, /* Add one to the old schema cookie */
101228: BTREE_DEFAULT_CACHE_SIZE, 0, /* Preserve the default page cache size */
101229: BTREE_TEXT_ENCODING, 0, /* Preserve the text encoding */
101230: BTREE_USER_VERSION, 0, /* Preserve the user version */
101231: };
101232:
101233: assert( 1==sqlite3BtreeIsInTrans(pTemp) );
101234: assert( 1==sqlite3BtreeIsInTrans(pMain) );
101235:
101236: /* Copy Btree meta values */
101237: for(i=0; i<ArraySize(aCopy); i+=2){
101238: /* GetMeta() and UpdateMeta() cannot fail in this context because
101239: ** we already have page 1 loaded into cache and marked dirty. */
101240: sqlite3BtreeGetMeta(pMain, aCopy[i], &meta);
101241: rc = sqlite3BtreeUpdateMeta(pTemp, aCopy[i], meta+aCopy[i+1]);
101242: if( NEVER(rc!=SQLITE_OK) ) goto end_of_vacuum;
101243: }
101244:
101245: rc = sqlite3BtreeCopyFile(pMain, pTemp);
101246: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101247: rc = sqlite3BtreeCommit(pTemp);
101248: if( rc!=SQLITE_OK ) goto end_of_vacuum;
101249: #ifndef SQLITE_OMIT_AUTOVACUUM
101250: sqlite3BtreeSetAutoVacuum(pMain, sqlite3BtreeGetAutoVacuum(pTemp));
101251: #endif
101252: }
101253:
101254: assert( rc==SQLITE_OK );
101255: rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes,1);
101256:
101257: end_of_vacuum:
101258: /* Restore the original value of db->flags */
101259: db->flags = saved_flags;
101260: db->nChange = saved_nChange;
101261: db->nTotalChange = saved_nTotalChange;
101262: db->xTrace = saved_xTrace;
101263: sqlite3BtreeSetPageSize(pMain, -1, -1, 1);
101264:
101265: /* Currently there is an SQL level transaction open on the vacuum
101266: ** database. No locks are held on any other files (since the main file
101267: ** was committed at the btree level). So it safe to end the transaction
101268: ** by manually setting the autoCommit flag to true and detaching the
101269: ** vacuum database. The vacuum_db journal file is deleted when the pager
101270: ** is closed by the DETACH.
101271: */
101272: db->autoCommit = 1;
101273:
101274: if( pDb ){
101275: sqlite3BtreeClose(pDb->pBt);
101276: pDb->pBt = 0;
101277: pDb->pSchema = 0;
101278: }
101279:
101280: /* This both clears the schemas and reduces the size of the db->aDb[]
101281: ** array. */
101282: sqlite3ResetInternalSchema(db, -1);
101283:
101284: return rc;
101285: }
101286:
101287: #endif /* SQLITE_OMIT_VACUUM && SQLITE_OMIT_ATTACH */
101288:
101289: /************** End of vacuum.c **********************************************/
101290: /************** Begin file vtab.c ********************************************/
101291: /*
101292: ** 2006 June 10
101293: **
101294: ** The author disclaims copyright to this source code. In place of
101295: ** a legal notice, here is a blessing:
101296: **
101297: ** May you do good and not evil.
101298: ** May you find forgiveness for yourself and forgive others.
101299: ** May you share freely, never taking more than you give.
101300: **
101301: *************************************************************************
101302: ** This file contains code used to help implement virtual tables.
101303: */
101304: #ifndef SQLITE_OMIT_VIRTUALTABLE
101305:
101306: /*
101307: ** Before a virtual table xCreate() or xConnect() method is invoked, the
101308: ** sqlite3.pVtabCtx member variable is set to point to an instance of
101309: ** this struct allocated on the stack. It is used by the implementation of
101310: ** the sqlite3_declare_vtab() and sqlite3_vtab_config() APIs, both of which
101311: ** are invoked only from within xCreate and xConnect methods.
101312: */
101313: struct VtabCtx {
101314: Table *pTab;
101315: VTable *pVTable;
101316: };
101317:
101318: /*
101319: ** The actual function that does the work of creating a new module.
101320: ** This function implements the sqlite3_create_module() and
101321: ** sqlite3_create_module_v2() interfaces.
101322: */
101323: static int createModule(
101324: sqlite3 *db, /* Database in which module is registered */
101325: const char *zName, /* Name assigned to this module */
101326: const sqlite3_module *pModule, /* The definition of the module */
101327: void *pAux, /* Context pointer for xCreate/xConnect */
101328: void (*xDestroy)(void *) /* Module destructor function */
101329: ){
101330: int rc, nName;
101331: Module *pMod;
101332:
101333: sqlite3_mutex_enter(db->mutex);
101334: nName = sqlite3Strlen30(zName);
101335: pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);
101336: if( pMod ){
101337: Module *pDel;
101338: char *zCopy = (char *)(&pMod[1]);
101339: memcpy(zCopy, zName, nName+1);
101340: pMod->zName = zCopy;
101341: pMod->pModule = pModule;
101342: pMod->pAux = pAux;
101343: pMod->xDestroy = xDestroy;
101344: pDel = (Module *)sqlite3HashInsert(&db->aModule, zCopy, nName, (void*)pMod);
101345: if( pDel && pDel->xDestroy ){
101346: sqlite3ResetInternalSchema(db, -1);
101347: pDel->xDestroy(pDel->pAux);
101348: }
101349: sqlite3DbFree(db, pDel);
101350: if( pDel==pMod ){
101351: db->mallocFailed = 1;
101352: }
101353: }else if( xDestroy ){
101354: xDestroy(pAux);
101355: }
101356: rc = sqlite3ApiExit(db, SQLITE_OK);
101357: sqlite3_mutex_leave(db->mutex);
101358: return rc;
101359: }
101360:
101361:
101362: /*
101363: ** External API function used to create a new virtual-table module.
101364: */
101365: SQLITE_API int sqlite3_create_module(
101366: sqlite3 *db, /* Database in which module is registered */
101367: const char *zName, /* Name assigned to this module */
101368: const sqlite3_module *pModule, /* The definition of the module */
101369: void *pAux /* Context pointer for xCreate/xConnect */
101370: ){
101371: return createModule(db, zName, pModule, pAux, 0);
101372: }
101373:
101374: /*
101375: ** External API function used to create a new virtual-table module.
101376: */
101377: SQLITE_API int sqlite3_create_module_v2(
101378: sqlite3 *db, /* Database in which module is registered */
101379: const char *zName, /* Name assigned to this module */
101380: const sqlite3_module *pModule, /* The definition of the module */
101381: void *pAux, /* Context pointer for xCreate/xConnect */
101382: void (*xDestroy)(void *) /* Module destructor function */
101383: ){
101384: return createModule(db, zName, pModule, pAux, xDestroy);
101385: }
101386:
101387: /*
101388: ** Lock the virtual table so that it cannot be disconnected.
101389: ** Locks nest. Every lock should have a corresponding unlock.
101390: ** If an unlock is omitted, resources leaks will occur.
101391: **
101392: ** If a disconnect is attempted while a virtual table is locked,
101393: ** the disconnect is deferred until all locks have been removed.
101394: */
101395: SQLITE_PRIVATE void sqlite3VtabLock(VTable *pVTab){
101396: pVTab->nRef++;
101397: }
101398:
101399:
101400: /*
101401: ** pTab is a pointer to a Table structure representing a virtual-table.
101402: ** Return a pointer to the VTable object used by connection db to access
101403: ** this virtual-table, if one has been created, or NULL otherwise.
101404: */
101405: SQLITE_PRIVATE VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab){
101406: VTable *pVtab;
101407: assert( IsVirtual(pTab) );
101408: for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
101409: return pVtab;
101410: }
101411:
101412: /*
101413: ** Decrement the ref-count on a virtual table object. When the ref-count
101414: ** reaches zero, call the xDisconnect() method to delete the object.
101415: */
101416: SQLITE_PRIVATE void sqlite3VtabUnlock(VTable *pVTab){
101417: sqlite3 *db = pVTab->db;
101418:
101419: assert( db );
101420: assert( pVTab->nRef>0 );
101421: assert( sqlite3SafetyCheckOk(db) );
101422:
101423: pVTab->nRef--;
101424: if( pVTab->nRef==0 ){
101425: sqlite3_vtab *p = pVTab->pVtab;
101426: if( p ){
101427: p->pModule->xDisconnect(p);
101428: }
101429: sqlite3DbFree(db, pVTab);
101430: }
101431: }
101432:
101433: /*
101434: ** Table p is a virtual table. This function moves all elements in the
101435: ** p->pVTable list to the sqlite3.pDisconnect lists of their associated
101436: ** database connections to be disconnected at the next opportunity.
101437: ** Except, if argument db is not NULL, then the entry associated with
101438: ** connection db is left in the p->pVTable list.
101439: */
101440: static VTable *vtabDisconnectAll(sqlite3 *db, Table *p){
101441: VTable *pRet = 0;
101442: VTable *pVTable = p->pVTable;
101443: p->pVTable = 0;
101444:
101445: /* Assert that the mutex (if any) associated with the BtShared database
101446: ** that contains table p is held by the caller. See header comments
101447: ** above function sqlite3VtabUnlockList() for an explanation of why
101448: ** this makes it safe to access the sqlite3.pDisconnect list of any
101449: ** database connection that may have an entry in the p->pVTable list.
101450: */
101451: assert( db==0 || sqlite3SchemaMutexHeld(db, 0, p->pSchema) );
101452:
101453: while( pVTable ){
101454: sqlite3 *db2 = pVTable->db;
101455: VTable *pNext = pVTable->pNext;
101456: assert( db2 );
101457: if( db2==db ){
101458: pRet = pVTable;
101459: p->pVTable = pRet;
101460: pRet->pNext = 0;
101461: }else{
101462: pVTable->pNext = db2->pDisconnect;
101463: db2->pDisconnect = pVTable;
101464: }
101465: pVTable = pNext;
101466: }
101467:
101468: assert( !db || pRet );
101469: return pRet;
101470: }
101471:
101472:
101473: /*
101474: ** Disconnect all the virtual table objects in the sqlite3.pDisconnect list.
101475: **
101476: ** This function may only be called when the mutexes associated with all
101477: ** shared b-tree databases opened using connection db are held by the
101478: ** caller. This is done to protect the sqlite3.pDisconnect list. The
101479: ** sqlite3.pDisconnect list is accessed only as follows:
101480: **
101481: ** 1) By this function. In this case, all BtShared mutexes and the mutex
101482: ** associated with the database handle itself must be held.
101483: **
101484: ** 2) By function vtabDisconnectAll(), when it adds a VTable entry to
101485: ** the sqlite3.pDisconnect list. In this case either the BtShared mutex
101486: ** associated with the database the virtual table is stored in is held
101487: ** or, if the virtual table is stored in a non-sharable database, then
101488: ** the database handle mutex is held.
101489: **
101490: ** As a result, a sqlite3.pDisconnect cannot be accessed simultaneously
101491: ** by multiple threads. It is thread-safe.
101492: */
101493: SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){
101494: VTable *p = db->pDisconnect;
101495: db->pDisconnect = 0;
101496:
101497: assert( sqlite3BtreeHoldsAllMutexes(db) );
101498: assert( sqlite3_mutex_held(db->mutex) );
101499:
101500: if( p ){
101501: sqlite3ExpirePreparedStatements(db);
101502: do {
101503: VTable *pNext = p->pNext;
101504: sqlite3VtabUnlock(p);
101505: p = pNext;
101506: }while( p );
101507: }
101508: }
101509:
101510: /*
101511: ** Clear any and all virtual-table information from the Table record.
101512: ** This routine is called, for example, just before deleting the Table
101513: ** record.
101514: **
101515: ** Since it is a virtual-table, the Table structure contains a pointer
101516: ** to the head of a linked list of VTable structures. Each VTable
101517: ** structure is associated with a single sqlite3* user of the schema.
101518: ** The reference count of the VTable structure associated with database
101519: ** connection db is decremented immediately (which may lead to the
101520: ** structure being xDisconnected and free). Any other VTable structures
101521: ** in the list are moved to the sqlite3.pDisconnect list of the associated
101522: ** database connection.
101523: */
101524: SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){
101525: if( !db || db->pnBytesFreed==0 ) vtabDisconnectAll(0, p);
101526: if( p->azModuleArg ){
101527: int i;
101528: for(i=0; i<p->nModuleArg; i++){
101529: sqlite3DbFree(db, p->azModuleArg[i]);
101530: }
101531: sqlite3DbFree(db, p->azModuleArg);
101532: }
101533: }
101534:
101535: /*
101536: ** Add a new module argument to pTable->azModuleArg[].
101537: ** The string is not copied - the pointer is stored. The
101538: ** string will be freed automatically when the table is
101539: ** deleted.
101540: */
101541: static void addModuleArgument(sqlite3 *db, Table *pTable, char *zArg){
101542: int i = pTable->nModuleArg++;
101543: int nBytes = sizeof(char *)*(1+pTable->nModuleArg);
101544: char **azModuleArg;
101545: azModuleArg = sqlite3DbRealloc(db, pTable->azModuleArg, nBytes);
101546: if( azModuleArg==0 ){
101547: int j;
101548: for(j=0; j<i; j++){
101549: sqlite3DbFree(db, pTable->azModuleArg[j]);
101550: }
101551: sqlite3DbFree(db, zArg);
101552: sqlite3DbFree(db, pTable->azModuleArg);
101553: pTable->nModuleArg = 0;
101554: }else{
101555: azModuleArg[i] = zArg;
101556: azModuleArg[i+1] = 0;
101557: }
101558: pTable->azModuleArg = azModuleArg;
101559: }
101560:
101561: /*
101562: ** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE
101563: ** statement. The module name has been parsed, but the optional list
101564: ** of parameters that follow the module name are still pending.
101565: */
101566: SQLITE_PRIVATE void sqlite3VtabBeginParse(
101567: Parse *pParse, /* Parsing context */
101568: Token *pName1, /* Name of new table, or database name */
101569: Token *pName2, /* Name of new table or NULL */
101570: Token *pModuleName /* Name of the module for the virtual table */
101571: ){
101572: int iDb; /* The database the table is being created in */
101573: Table *pTable; /* The new virtual table */
101574: sqlite3 *db; /* Database connection */
101575:
101576: sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, 0);
101577: pTable = pParse->pNewTable;
101578: if( pTable==0 ) return;
101579: assert( 0==pTable->pIndex );
101580:
101581: db = pParse->db;
101582: iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
101583: assert( iDb>=0 );
101584:
101585: pTable->tabFlags |= TF_Virtual;
101586: pTable->nModuleArg = 0;
101587: addModuleArgument(db, pTable, sqlite3NameFromToken(db, pModuleName));
101588: addModuleArgument(db, pTable, sqlite3DbStrDup(db, db->aDb[iDb].zName));
101589: addModuleArgument(db, pTable, sqlite3DbStrDup(db, pTable->zName));
101590: pParse->sNameToken.n = (int)(&pModuleName->z[pModuleName->n] - pName1->z);
101591:
101592: #ifndef SQLITE_OMIT_AUTHORIZATION
101593: /* Creating a virtual table invokes the authorization callback twice.
101594: ** The first invocation, to obtain permission to INSERT a row into the
101595: ** sqlite_master table, has already been made by sqlite3StartTable().
101596: ** The second call, to obtain permission to create the table, is made now.
101597: */
101598: if( pTable->azModuleArg ){
101599: sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
101600: pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
101601: }
101602: #endif
101603: }
101604:
101605: /*
101606: ** This routine takes the module argument that has been accumulating
101607: ** in pParse->zArg[] and appends it to the list of arguments on the
101608: ** virtual table currently under construction in pParse->pTable.
101609: */
101610: static void addArgumentToVtab(Parse *pParse){
101611: if( pParse->sArg.z && ALWAYS(pParse->pNewTable) ){
101612: const char *z = (const char*)pParse->sArg.z;
101613: int n = pParse->sArg.n;
101614: sqlite3 *db = pParse->db;
101615: addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
101616: }
101617: }
101618:
101619: /*
101620: ** The parser calls this routine after the CREATE VIRTUAL TABLE statement
101621: ** has been completely parsed.
101622: */
101623: SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
101624: Table *pTab = pParse->pNewTable; /* The table being constructed */
101625: sqlite3 *db = pParse->db; /* The database connection */
101626:
101627: if( pTab==0 ) return;
101628: addArgumentToVtab(pParse);
101629: pParse->sArg.z = 0;
101630: if( pTab->nModuleArg<1 ) return;
101631:
101632: /* If the CREATE VIRTUAL TABLE statement is being entered for the
101633: ** first time (in other words if the virtual table is actually being
101634: ** created now instead of just being read out of sqlite_master) then
101635: ** do additional initialization work and store the statement text
101636: ** in the sqlite_master table.
101637: */
101638: if( !db->init.busy ){
101639: char *zStmt;
101640: char *zWhere;
101641: int iDb;
101642: Vdbe *v;
101643:
101644: /* Compute the complete text of the CREATE VIRTUAL TABLE statement */
101645: if( pEnd ){
101646: pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
101647: }
101648: zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
101649:
101650: /* A slot for the record has already been allocated in the
101651: ** SQLITE_MASTER table. We just need to update that slot with all
101652: ** the information we've collected.
101653: **
101654: ** The VM register number pParse->regRowid holds the rowid of an
101655: ** entry in the sqlite_master table tht was created for this vtab
101656: ** by sqlite3StartTable().
101657: */
101658: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
101659: sqlite3NestedParse(pParse,
101660: "UPDATE %Q.%s "
101661: "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "
101662: "WHERE rowid=#%d",
101663: db->aDb[iDb].zName, SCHEMA_TABLE(iDb),
101664: pTab->zName,
101665: pTab->zName,
101666: zStmt,
101667: pParse->regRowid
101668: );
101669: sqlite3DbFree(db, zStmt);
101670: v = sqlite3GetVdbe(pParse);
101671: sqlite3ChangeCookie(pParse, iDb);
101672:
101673: sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
101674: zWhere = sqlite3MPrintf(db, "name='%q' AND type='table'", pTab->zName);
101675: sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere);
101676: sqlite3VdbeAddOp4(v, OP_VCreate, iDb, 0, 0,
101677: pTab->zName, sqlite3Strlen30(pTab->zName) + 1);
101678: }
101679:
101680: /* If we are rereading the sqlite_master table create the in-memory
101681: ** record of the table. The xConnect() method is not called until
101682: ** the first time the virtual table is used in an SQL statement. This
101683: ** allows a schema that contains virtual tables to be loaded before
101684: ** the required virtual table implementations are registered. */
101685: else {
101686: Table *pOld;
101687: Schema *pSchema = pTab->pSchema;
101688: const char *zName = pTab->zName;
101689: int nName = sqlite3Strlen30(zName);
101690: assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
101691: pOld = sqlite3HashInsert(&pSchema->tblHash, zName, nName, pTab);
101692: if( pOld ){
101693: db->mallocFailed = 1;
101694: assert( pTab==pOld ); /* Malloc must have failed inside HashInsert() */
101695: return;
101696: }
101697: pParse->pNewTable = 0;
101698: }
101699: }
101700:
101701: /*
101702: ** The parser calls this routine when it sees the first token
101703: ** of an argument to the module name in a CREATE VIRTUAL TABLE statement.
101704: */
101705: SQLITE_PRIVATE void sqlite3VtabArgInit(Parse *pParse){
101706: addArgumentToVtab(pParse);
101707: pParse->sArg.z = 0;
101708: pParse->sArg.n = 0;
101709: }
101710:
101711: /*
101712: ** The parser calls this routine for each token after the first token
101713: ** in an argument to the module name in a CREATE VIRTUAL TABLE statement.
101714: */
101715: SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){
101716: Token *pArg = &pParse->sArg;
101717: if( pArg->z==0 ){
101718: pArg->z = p->z;
101719: pArg->n = p->n;
101720: }else{
101721: assert(pArg->z < p->z);
101722: pArg->n = (int)(&p->z[p->n] - pArg->z);
101723: }
101724: }
101725:
101726: /*
101727: ** Invoke a virtual table constructor (either xCreate or xConnect). The
101728: ** pointer to the function to invoke is passed as the fourth parameter
101729: ** to this procedure.
101730: */
101731: static int vtabCallConstructor(
101732: sqlite3 *db,
101733: Table *pTab,
101734: Module *pMod,
101735: int (*xConstruct)(sqlite3*,void*,int,const char*const*,sqlite3_vtab**,char**),
101736: char **pzErr
101737: ){
101738: VtabCtx sCtx;
101739: VTable *pVTable;
101740: int rc;
101741: const char *const*azArg = (const char *const*)pTab->azModuleArg;
101742: int nArg = pTab->nModuleArg;
101743: char *zErr = 0;
101744: char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
101745:
101746: if( !zModuleName ){
101747: return SQLITE_NOMEM;
101748: }
101749:
101750: pVTable = sqlite3DbMallocZero(db, sizeof(VTable));
101751: if( !pVTable ){
101752: sqlite3DbFree(db, zModuleName);
101753: return SQLITE_NOMEM;
101754: }
101755: pVTable->db = db;
101756: pVTable->pMod = pMod;
101757:
101758: /* Invoke the virtual table constructor */
101759: assert( &db->pVtabCtx );
101760: assert( xConstruct );
101761: sCtx.pTab = pTab;
101762: sCtx.pVTable = pVTable;
101763: db->pVtabCtx = &sCtx;
101764: rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
101765: db->pVtabCtx = 0;
101766: if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
101767:
101768: if( SQLITE_OK!=rc ){
101769: if( zErr==0 ){
101770: *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
101771: }else {
101772: *pzErr = sqlite3MPrintf(db, "%s", zErr);
101773: sqlite3_free(zErr);
101774: }
101775: sqlite3DbFree(db, pVTable);
101776: }else if( ALWAYS(pVTable->pVtab) ){
101777: /* Justification of ALWAYS(): A correct vtab constructor must allocate
101778: ** the sqlite3_vtab object if successful. */
101779: pVTable->pVtab->pModule = pMod->pModule;
101780: pVTable->nRef = 1;
101781: if( sCtx.pTab ){
101782: const char *zFormat = "vtable constructor did not declare schema: %s";
101783: *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
101784: sqlite3VtabUnlock(pVTable);
101785: rc = SQLITE_ERROR;
101786: }else{
101787: int iCol;
101788: /* If everything went according to plan, link the new VTable structure
101789: ** into the linked list headed by pTab->pVTable. Then loop through the
101790: ** columns of the table to see if any of them contain the token "hidden".
101791: ** If so, set the Column.isHidden flag and remove the token from
101792: ** the type string. */
101793: pVTable->pNext = pTab->pVTable;
101794: pTab->pVTable = pVTable;
101795:
101796: for(iCol=0; iCol<pTab->nCol; iCol++){
101797: char *zType = pTab->aCol[iCol].zType;
101798: int nType;
101799: int i = 0;
101800: if( !zType ) continue;
101801: nType = sqlite3Strlen30(zType);
101802: if( sqlite3StrNICmp("hidden", zType, 6)||(zType[6] && zType[6]!=' ') ){
101803: for(i=0; i<nType; i++){
101804: if( (0==sqlite3StrNICmp(" hidden", &zType[i], 7))
101805: && (zType[i+7]=='\0' || zType[i+7]==' ')
101806: ){
101807: i++;
101808: break;
101809: }
101810: }
101811: }
101812: if( i<nType ){
101813: int j;
101814: int nDel = 6 + (zType[i+6] ? 1 : 0);
101815: for(j=i; (j+nDel)<=nType; j++){
101816: zType[j] = zType[j+nDel];
101817: }
101818: if( zType[i]=='\0' && i>0 ){
101819: assert(zType[i-1]==' ');
101820: zType[i-1] = '\0';
101821: }
101822: pTab->aCol[iCol].isHidden = 1;
101823: }
101824: }
101825: }
101826: }
101827:
101828: sqlite3DbFree(db, zModuleName);
101829: return rc;
101830: }
101831:
101832: /*
101833: ** This function is invoked by the parser to call the xConnect() method
101834: ** of the virtual table pTab. If an error occurs, an error code is returned
101835: ** and an error left in pParse.
101836: **
101837: ** This call is a no-op if table pTab is not a virtual table.
101838: */
101839: SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
101840: sqlite3 *db = pParse->db;
101841: const char *zMod;
101842: Module *pMod;
101843: int rc;
101844:
101845: assert( pTab );
101846: if( (pTab->tabFlags & TF_Virtual)==0 || sqlite3GetVTable(db, pTab) ){
101847: return SQLITE_OK;
101848: }
101849:
101850: /* Locate the required virtual table module */
101851: zMod = pTab->azModuleArg[0];
101852: pMod = (Module*)sqlite3HashFind(&db->aModule, zMod, sqlite3Strlen30(zMod));
101853:
101854: if( !pMod ){
101855: const char *zModule = pTab->azModuleArg[0];
101856: sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
101857: rc = SQLITE_ERROR;
101858: }else{
101859: char *zErr = 0;
101860: rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xConnect, &zErr);
101861: if( rc!=SQLITE_OK ){
101862: sqlite3ErrorMsg(pParse, "%s", zErr);
101863: }
101864: sqlite3DbFree(db, zErr);
101865: }
101866:
101867: return rc;
101868: }
101869: /*
101870: ** Grow the db->aVTrans[] array so that there is room for at least one
101871: ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
101872: */
101873: static int growVTrans(sqlite3 *db){
101874: const int ARRAY_INCR = 5;
101875:
101876: /* Grow the sqlite3.aVTrans array if required */
101877: if( (db->nVTrans%ARRAY_INCR)==0 ){
101878: VTable **aVTrans;
101879: int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
101880: aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
101881: if( !aVTrans ){
101882: return SQLITE_NOMEM;
101883: }
101884: memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
101885: db->aVTrans = aVTrans;
101886: }
101887:
101888: return SQLITE_OK;
101889: }
101890:
101891: /*
101892: ** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should
101893: ** have already been reserved using growVTrans().
101894: */
101895: static void addToVTrans(sqlite3 *db, VTable *pVTab){
101896: /* Add pVtab to the end of sqlite3.aVTrans */
101897: db->aVTrans[db->nVTrans++] = pVTab;
101898: sqlite3VtabLock(pVTab);
101899: }
101900:
101901: /*
101902: ** This function is invoked by the vdbe to call the xCreate method
101903: ** of the virtual table named zTab in database iDb.
101904: **
101905: ** If an error occurs, *pzErr is set to point an an English language
101906: ** description of the error and an SQLITE_XXX error code is returned.
101907: ** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
101908: */
101909: SQLITE_PRIVATE int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
101910: int rc = SQLITE_OK;
101911: Table *pTab;
101912: Module *pMod;
101913: const char *zMod;
101914:
101915: pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
101916: assert( pTab && (pTab->tabFlags & TF_Virtual)!=0 && !pTab->pVTable );
101917:
101918: /* Locate the required virtual table module */
101919: zMod = pTab->azModuleArg[0];
101920: pMod = (Module*)sqlite3HashFind(&db->aModule, zMod, sqlite3Strlen30(zMod));
101921:
101922: /* If the module has been registered and includes a Create method,
101923: ** invoke it now. If the module has not been registered, return an
101924: ** error. Otherwise, do nothing.
101925: */
101926: if( !pMod ){
101927: *pzErr = sqlite3MPrintf(db, "no such module: %s", zMod);
101928: rc = SQLITE_ERROR;
101929: }else{
101930: rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);
101931: }
101932:
101933: /* Justification of ALWAYS(): The xConstructor method is required to
101934: ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
101935: if( rc==SQLITE_OK && ALWAYS(sqlite3GetVTable(db, pTab)) ){
101936: rc = growVTrans(db);
101937: if( rc==SQLITE_OK ){
101938: addToVTrans(db, sqlite3GetVTable(db, pTab));
101939: }
101940: }
101941:
101942: return rc;
101943: }
101944:
101945: /*
101946: ** This function is used to set the schema of a virtual table. It is only
101947: ** valid to call this function from within the xCreate() or xConnect() of a
101948: ** virtual table module.
101949: */
101950: SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
101951: Parse *pParse;
101952:
101953: int rc = SQLITE_OK;
101954: Table *pTab;
101955: char *zErr = 0;
101956:
101957: sqlite3_mutex_enter(db->mutex);
101958: if( !db->pVtabCtx || !(pTab = db->pVtabCtx->pTab) ){
101959: sqlite3Error(db, SQLITE_MISUSE, 0);
101960: sqlite3_mutex_leave(db->mutex);
101961: return SQLITE_MISUSE_BKPT;
101962: }
101963: assert( (pTab->tabFlags & TF_Virtual)!=0 );
101964:
101965: pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
101966: if( pParse==0 ){
101967: rc = SQLITE_NOMEM;
101968: }else{
101969: pParse->declareVtab = 1;
101970: pParse->db = db;
101971: pParse->nQueryLoop = 1;
101972:
101973: if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
101974: && pParse->pNewTable
101975: && !db->mallocFailed
101976: && !pParse->pNewTable->pSelect
101977: && (pParse->pNewTable->tabFlags & TF_Virtual)==0
101978: ){
101979: if( !pTab->aCol ){
101980: pTab->aCol = pParse->pNewTable->aCol;
101981: pTab->nCol = pParse->pNewTable->nCol;
101982: pParse->pNewTable->nCol = 0;
101983: pParse->pNewTable->aCol = 0;
101984: }
101985: db->pVtabCtx->pTab = 0;
101986: }else{
101987: sqlite3Error(db, SQLITE_ERROR, (zErr ? "%s" : 0), zErr);
101988: sqlite3DbFree(db, zErr);
101989: rc = SQLITE_ERROR;
101990: }
101991: pParse->declareVtab = 0;
101992:
101993: if( pParse->pVdbe ){
101994: sqlite3VdbeFinalize(pParse->pVdbe);
101995: }
101996: sqlite3DeleteTable(db, pParse->pNewTable);
101997: sqlite3StackFree(db, pParse);
101998: }
101999:
102000: assert( (rc&0xff)==rc );
102001: rc = sqlite3ApiExit(db, rc);
102002: sqlite3_mutex_leave(db->mutex);
102003: return rc;
102004: }
102005:
102006: /*
102007: ** This function is invoked by the vdbe to call the xDestroy method
102008: ** of the virtual table named zTab in database iDb. This occurs
102009: ** when a DROP TABLE is mentioned.
102010: **
102011: ** This call is a no-op if zTab is not a virtual table.
102012: */
102013: SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab){
102014: int rc = SQLITE_OK;
102015: Table *pTab;
102016:
102017: pTab = sqlite3FindTable(db, zTab, db->aDb[iDb].zName);
102018: if( ALWAYS(pTab!=0 && pTab->pVTable!=0) ){
102019: VTable *p = vtabDisconnectAll(db, pTab);
102020:
102021: assert( rc==SQLITE_OK );
102022: rc = p->pMod->pModule->xDestroy(p->pVtab);
102023:
102024: /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
102025: if( rc==SQLITE_OK ){
102026: assert( pTab->pVTable==p && p->pNext==0 );
102027: p->pVtab = 0;
102028: pTab->pVTable = 0;
102029: sqlite3VtabUnlock(p);
102030: }
102031: }
102032:
102033: return rc;
102034: }
102035:
102036: /*
102037: ** This function invokes either the xRollback or xCommit method
102038: ** of each of the virtual tables in the sqlite3.aVTrans array. The method
102039: ** called is identified by the second argument, "offset", which is
102040: ** the offset of the method to call in the sqlite3_module structure.
102041: **
102042: ** The array is cleared after invoking the callbacks.
102043: */
102044: static void callFinaliser(sqlite3 *db, int offset){
102045: int i;
102046: if( db->aVTrans ){
102047: for(i=0; i<db->nVTrans; i++){
102048: VTable *pVTab = db->aVTrans[i];
102049: sqlite3_vtab *p = pVTab->pVtab;
102050: if( p ){
102051: int (*x)(sqlite3_vtab *);
102052: x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
102053: if( x ) x(p);
102054: }
102055: pVTab->iSavepoint = 0;
102056: sqlite3VtabUnlock(pVTab);
102057: }
102058: sqlite3DbFree(db, db->aVTrans);
102059: db->nVTrans = 0;
102060: db->aVTrans = 0;
102061: }
102062: }
102063:
102064: /*
102065: ** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans
102066: ** array. Return the error code for the first error that occurs, or
102067: ** SQLITE_OK if all xSync operations are successful.
102068: **
102069: ** Set *pzErrmsg to point to a buffer that should be released using
102070: ** sqlite3DbFree() containing an error message, if one is available.
102071: */
102072: SQLITE_PRIVATE int sqlite3VtabSync(sqlite3 *db, char **pzErrmsg){
102073: int i;
102074: int rc = SQLITE_OK;
102075: VTable **aVTrans = db->aVTrans;
102076:
102077: db->aVTrans = 0;
102078: for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
102079: int (*x)(sqlite3_vtab *);
102080: sqlite3_vtab *pVtab = aVTrans[i]->pVtab;
102081: if( pVtab && (x = pVtab->pModule->xSync)!=0 ){
102082: rc = x(pVtab);
102083: sqlite3DbFree(db, *pzErrmsg);
102084: *pzErrmsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
102085: sqlite3_free(pVtab->zErrMsg);
102086: }
102087: }
102088: db->aVTrans = aVTrans;
102089: return rc;
102090: }
102091:
102092: /*
102093: ** Invoke the xRollback method of all virtual tables in the
102094: ** sqlite3.aVTrans array. Then clear the array itself.
102095: */
102096: SQLITE_PRIVATE int sqlite3VtabRollback(sqlite3 *db){
102097: callFinaliser(db, offsetof(sqlite3_module,xRollback));
102098: return SQLITE_OK;
102099: }
102100:
102101: /*
102102: ** Invoke the xCommit method of all virtual tables in the
102103: ** sqlite3.aVTrans array. Then clear the array itself.
102104: */
102105: SQLITE_PRIVATE int sqlite3VtabCommit(sqlite3 *db){
102106: callFinaliser(db, offsetof(sqlite3_module,xCommit));
102107: return SQLITE_OK;
102108: }
102109:
102110: /*
102111: ** If the virtual table pVtab supports the transaction interface
102112: ** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
102113: ** not currently open, invoke the xBegin method now.
102114: **
102115: ** If the xBegin call is successful, place the sqlite3_vtab pointer
102116: ** in the sqlite3.aVTrans array.
102117: */
102118: SQLITE_PRIVATE int sqlite3VtabBegin(sqlite3 *db, VTable *pVTab){
102119: int rc = SQLITE_OK;
102120: const sqlite3_module *pModule;
102121:
102122: /* Special case: If db->aVTrans is NULL and db->nVTrans is greater
102123: ** than zero, then this function is being called from within a
102124: ** virtual module xSync() callback. It is illegal to write to
102125: ** virtual module tables in this case, so return SQLITE_LOCKED.
102126: */
102127: if( sqlite3VtabInSync(db) ){
102128: return SQLITE_LOCKED;
102129: }
102130: if( !pVTab ){
102131: return SQLITE_OK;
102132: }
102133: pModule = pVTab->pVtab->pModule;
102134:
102135: if( pModule->xBegin ){
102136: int i;
102137:
102138: /* If pVtab is already in the aVTrans array, return early */
102139: for(i=0; i<db->nVTrans; i++){
102140: if( db->aVTrans[i]==pVTab ){
102141: return SQLITE_OK;
102142: }
102143: }
102144:
102145: /* Invoke the xBegin method. If successful, add the vtab to the
102146: ** sqlite3.aVTrans[] array. */
102147: rc = growVTrans(db);
102148: if( rc==SQLITE_OK ){
102149: rc = pModule->xBegin(pVTab->pVtab);
102150: if( rc==SQLITE_OK ){
102151: addToVTrans(db, pVTab);
102152: }
102153: }
102154: }
102155: return rc;
102156: }
102157:
102158: /*
102159: ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
102160: ** virtual tables that currently have an open transaction. Pass iSavepoint
102161: ** as the second argument to the virtual table method invoked.
102162: **
102163: ** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is
102164: ** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is
102165: ** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with
102166: ** an open transaction is invoked.
102167: **
102168: ** If any virtual table method returns an error code other than SQLITE_OK,
102169: ** processing is abandoned and the error returned to the caller of this
102170: ** function immediately. If all calls to virtual table methods are successful,
102171: ** SQLITE_OK is returned.
102172: */
102173: SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){
102174: int rc = SQLITE_OK;
102175:
102176: assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
102177: assert( iSavepoint>=0 );
102178: if( db->aVTrans ){
102179: int i;
102180: for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
102181: VTable *pVTab = db->aVTrans[i];
102182: const sqlite3_module *pMod = pVTab->pMod->pModule;
102183: if( pVTab->pVtab && pMod->iVersion>=2 ){
102184: int (*xMethod)(sqlite3_vtab *, int);
102185: switch( op ){
102186: case SAVEPOINT_BEGIN:
102187: xMethod = pMod->xSavepoint;
102188: pVTab->iSavepoint = iSavepoint+1;
102189: break;
102190: case SAVEPOINT_ROLLBACK:
102191: xMethod = pMod->xRollbackTo;
102192: break;
102193: default:
102194: xMethod = pMod->xRelease;
102195: break;
102196: }
102197: if( xMethod && pVTab->iSavepoint>iSavepoint ){
102198: rc = xMethod(pVTab->pVtab, iSavepoint);
102199: }
102200: }
102201: }
102202: }
102203: return rc;
102204: }
102205:
102206: /*
102207: ** The first parameter (pDef) is a function implementation. The
102208: ** second parameter (pExpr) is the first argument to this function.
102209: ** If pExpr is a column in a virtual table, then let the virtual
102210: ** table implementation have an opportunity to overload the function.
102211: **
102212: ** This routine is used to allow virtual table implementations to
102213: ** overload MATCH, LIKE, GLOB, and REGEXP operators.
102214: **
102215: ** Return either the pDef argument (indicating no change) or a
102216: ** new FuncDef structure that is marked as ephemeral using the
102217: ** SQLITE_FUNC_EPHEM flag.
102218: */
102219: SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(
102220: sqlite3 *db, /* Database connection for reporting malloc problems */
102221: FuncDef *pDef, /* Function to possibly overload */
102222: int nArg, /* Number of arguments to the function */
102223: Expr *pExpr /* First argument to the function */
102224: ){
102225: Table *pTab;
102226: sqlite3_vtab *pVtab;
102227: sqlite3_module *pMod;
102228: void (*xFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
102229: void *pArg = 0;
102230: FuncDef *pNew;
102231: int rc = 0;
102232: char *zLowerName;
102233: unsigned char *z;
102234:
102235:
102236: /* Check to see the left operand is a column in a virtual table */
102237: if( NEVER(pExpr==0) ) return pDef;
102238: if( pExpr->op!=TK_COLUMN ) return pDef;
102239: pTab = pExpr->pTab;
102240: if( NEVER(pTab==0) ) return pDef;
102241: if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;
102242: pVtab = sqlite3GetVTable(db, pTab)->pVtab;
102243: assert( pVtab!=0 );
102244: assert( pVtab->pModule!=0 );
102245: pMod = (sqlite3_module *)pVtab->pModule;
102246: if( pMod->xFindFunction==0 ) return pDef;
102247:
102248: /* Call the xFindFunction method on the virtual table implementation
102249: ** to see if the implementation wants to overload this function
102250: */
102251: zLowerName = sqlite3DbStrDup(db, pDef->zName);
102252: if( zLowerName ){
102253: for(z=(unsigned char*)zLowerName; *z; z++){
102254: *z = sqlite3UpperToLower[*z];
102255: }
102256: rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg);
102257: sqlite3DbFree(db, zLowerName);
102258: }
102259: if( rc==0 ){
102260: return pDef;
102261: }
102262:
102263: /* Create a new ephemeral function definition for the overloaded
102264: ** function */
102265: pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
102266: + sqlite3Strlen30(pDef->zName) + 1);
102267: if( pNew==0 ){
102268: return pDef;
102269: }
102270: *pNew = *pDef;
102271: pNew->zName = (char *)&pNew[1];
102272: memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
102273: pNew->xFunc = xFunc;
102274: pNew->pUserData = pArg;
102275: pNew->flags |= SQLITE_FUNC_EPHEM;
102276: return pNew;
102277: }
102278:
102279: /*
102280: ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
102281: ** array so that an OP_VBegin will get generated for it. Add pTab to the
102282: ** array if it is missing. If pTab is already in the array, this routine
102283: ** is a no-op.
102284: */
102285: SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
102286: Parse *pToplevel = sqlite3ParseToplevel(pParse);
102287: int i, n;
102288: Table **apVtabLock;
102289:
102290: assert( IsVirtual(pTab) );
102291: for(i=0; i<pToplevel->nVtabLock; i++){
102292: if( pTab==pToplevel->apVtabLock[i] ) return;
102293: }
102294: n = (pToplevel->nVtabLock+1)*sizeof(pToplevel->apVtabLock[0]);
102295: apVtabLock = sqlite3_realloc(pToplevel->apVtabLock, n);
102296: if( apVtabLock ){
102297: pToplevel->apVtabLock = apVtabLock;
102298: pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
102299: }else{
102300: pToplevel->db->mallocFailed = 1;
102301: }
102302: }
102303:
102304: /*
102305: ** Return the ON CONFLICT resolution mode in effect for the virtual
102306: ** table update operation currently in progress.
102307: **
102308: ** The results of this routine are undefined unless it is called from
102309: ** within an xUpdate method.
102310: */
102311: SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *db){
102312: static const unsigned char aMap[] = {
102313: SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE
102314: };
102315: assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
102316: assert( OE_Ignore==4 && OE_Replace==5 );
102317: assert( db->vtabOnConflict>=1 && db->vtabOnConflict<=5 );
102318: return (int)aMap[db->vtabOnConflict-1];
102319: }
102320:
102321: /*
102322: ** Call from within the xCreate() or xConnect() methods to provide
102323: ** the SQLite core with additional information about the behavior
102324: ** of the virtual table being implemented.
102325: */
102326: SQLITE_API int sqlite3_vtab_config(sqlite3 *db, int op, ...){
102327: va_list ap;
102328: int rc = SQLITE_OK;
102329:
102330: sqlite3_mutex_enter(db->mutex);
102331:
102332: va_start(ap, op);
102333: switch( op ){
102334: case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
102335: VtabCtx *p = db->pVtabCtx;
102336: if( !p ){
102337: rc = SQLITE_MISUSE_BKPT;
102338: }else{
102339: assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 );
102340: p->pVTable->bConstraint = (u8)va_arg(ap, int);
102341: }
102342: break;
102343: }
102344: default:
102345: rc = SQLITE_MISUSE_BKPT;
102346: break;
102347: }
102348: va_end(ap);
102349:
102350: if( rc!=SQLITE_OK ) sqlite3Error(db, rc, 0);
102351: sqlite3_mutex_leave(db->mutex);
102352: return rc;
102353: }
102354:
102355: #endif /* SQLITE_OMIT_VIRTUALTABLE */
102356:
102357: /************** End of vtab.c ************************************************/
102358: /************** Begin file where.c *******************************************/
102359: /*
102360: ** 2001 September 15
102361: **
102362: ** The author disclaims copyright to this source code. In place of
102363: ** a legal notice, here is a blessing:
102364: **
102365: ** May you do good and not evil.
102366: ** May you find forgiveness for yourself and forgive others.
102367: ** May you share freely, never taking more than you give.
102368: **
102369: *************************************************************************
102370: ** This module contains C code that generates VDBE code used to process
102371: ** the WHERE clause of SQL statements. This module is responsible for
102372: ** generating the code that loops through a table looking for applicable
102373: ** rows. Indices are selected and used to speed the search when doing
102374: ** so is applicable. Because this module is responsible for selecting
102375: ** indices, you might also think of this module as the "query optimizer".
102376: */
102377:
102378:
102379: /*
102380: ** Trace output macros
102381: */
102382: #if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
102383: SQLITE_PRIVATE int sqlite3WhereTrace = 0;
102384: #endif
102385: #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG)
102386: # define WHERETRACE(X) if(sqlite3WhereTrace) sqlite3DebugPrintf X
102387: #else
102388: # define WHERETRACE(X)
102389: #endif
102390:
102391: /* Forward reference
102392: */
102393: typedef struct WhereClause WhereClause;
102394: typedef struct WhereMaskSet WhereMaskSet;
102395: typedef struct WhereOrInfo WhereOrInfo;
102396: typedef struct WhereAndInfo WhereAndInfo;
102397: typedef struct WhereCost WhereCost;
102398:
102399: /*
102400: ** The query generator uses an array of instances of this structure to
102401: ** help it analyze the subexpressions of the WHERE clause. Each WHERE
102402: ** clause subexpression is separated from the others by AND operators,
102403: ** usually, or sometimes subexpressions separated by OR.
102404: **
102405: ** All WhereTerms are collected into a single WhereClause structure.
102406: ** The following identity holds:
102407: **
102408: ** WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm
102409: **
102410: ** When a term is of the form:
102411: **
102412: ** X <op> <expr>
102413: **
102414: ** where X is a column name and <op> is one of certain operators,
102415: ** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the
102416: ** cursor number and column number for X. WhereTerm.eOperator records
102417: ** the <op> using a bitmask encoding defined by WO_xxx below. The
102418: ** use of a bitmask encoding for the operator allows us to search
102419: ** quickly for terms that match any of several different operators.
102420: **
102421: ** A WhereTerm might also be two or more subterms connected by OR:
102422: **
102423: ** (t1.X <op> <expr>) OR (t1.Y <op> <expr>) OR ....
102424: **
102425: ** In this second case, wtFlag as the TERM_ORINFO set and eOperator==WO_OR
102426: ** and the WhereTerm.u.pOrInfo field points to auxiliary information that
102427: ** is collected about the
102428: **
102429: ** If a term in the WHERE clause does not match either of the two previous
102430: ** categories, then eOperator==0. The WhereTerm.pExpr field is still set
102431: ** to the original subexpression content and wtFlags is set up appropriately
102432: ** but no other fields in the WhereTerm object are meaningful.
102433: **
102434: ** When eOperator!=0, prereqRight and prereqAll record sets of cursor numbers,
102435: ** but they do so indirectly. A single WhereMaskSet structure translates
102436: ** cursor number into bits and the translated bit is stored in the prereq
102437: ** fields. The translation is used in order to maximize the number of
102438: ** bits that will fit in a Bitmask. The VDBE cursor numbers might be
102439: ** spread out over the non-negative integers. For example, the cursor
102440: ** numbers might be 3, 8, 9, 10, 20, 23, 41, and 45. The WhereMaskSet
102441: ** translates these sparse cursor numbers into consecutive integers
102442: ** beginning with 0 in order to make the best possible use of the available
102443: ** bits in the Bitmask. So, in the example above, the cursor numbers
102444: ** would be mapped into integers 0 through 7.
102445: **
102446: ** The number of terms in a join is limited by the number of bits
102447: ** in prereqRight and prereqAll. The default is 64 bits, hence SQLite
102448: ** is only able to process joins with 64 or fewer tables.
102449: */
102450: typedef struct WhereTerm WhereTerm;
102451: struct WhereTerm {
102452: Expr *pExpr; /* Pointer to the subexpression that is this term */
102453: int iParent; /* Disable pWC->a[iParent] when this term disabled */
102454: int leftCursor; /* Cursor number of X in "X <op> <expr>" */
102455: union {
102456: int leftColumn; /* Column number of X in "X <op> <expr>" */
102457: WhereOrInfo *pOrInfo; /* Extra information if eOperator==WO_OR */
102458: WhereAndInfo *pAndInfo; /* Extra information if eOperator==WO_AND */
102459: } u;
102460: u16 eOperator; /* A WO_xx value describing <op> */
102461: u8 wtFlags; /* TERM_xxx bit flags. See below */
102462: u8 nChild; /* Number of children that must disable us */
102463: WhereClause *pWC; /* The clause this term is part of */
102464: Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */
102465: Bitmask prereqAll; /* Bitmask of tables referenced by pExpr */
102466: };
102467:
102468: /*
102469: ** Allowed values of WhereTerm.wtFlags
102470: */
102471: #define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */
102472: #define TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */
102473: #define TERM_CODED 0x04 /* This term is already coded */
102474: #define TERM_COPIED 0x08 /* Has a child */
102475: #define TERM_ORINFO 0x10 /* Need to free the WhereTerm.u.pOrInfo object */
102476: #define TERM_ANDINFO 0x20 /* Need to free the WhereTerm.u.pAndInfo obj */
102477: #define TERM_OR_OK 0x40 /* Used during OR-clause processing */
102478: #ifdef SQLITE_ENABLE_STAT3
102479: # define TERM_VNULL 0x80 /* Manufactured x>NULL or x<=NULL term */
102480: #else
102481: # define TERM_VNULL 0x00 /* Disabled if not using stat3 */
102482: #endif
102483:
102484: /*
102485: ** An instance of the following structure holds all information about a
102486: ** WHERE clause. Mostly this is a container for one or more WhereTerms.
102487: **
102488: ** Explanation of pOuter: For a WHERE clause of the form
102489: **
102490: ** a AND ((b AND c) OR (d AND e)) AND f
102491: **
102492: ** There are separate WhereClause objects for the whole clause and for
102493: ** the subclauses "(b AND c)" and "(d AND e)". The pOuter field of the
102494: ** subclauses points to the WhereClause object for the whole clause.
102495: */
102496: struct WhereClause {
102497: Parse *pParse; /* The parser context */
102498: WhereMaskSet *pMaskSet; /* Mapping of table cursor numbers to bitmasks */
102499: Bitmask vmask; /* Bitmask identifying virtual table cursors */
102500: WhereClause *pOuter; /* Outer conjunction */
102501: u8 op; /* Split operator. TK_AND or TK_OR */
102502: u16 wctrlFlags; /* Might include WHERE_AND_ONLY */
102503: int nTerm; /* Number of terms */
102504: int nSlot; /* Number of entries in a[] */
102505: WhereTerm *a; /* Each a[] describes a term of the WHERE cluase */
102506: #if defined(SQLITE_SMALL_STACK)
102507: WhereTerm aStatic[1]; /* Initial static space for a[] */
102508: #else
102509: WhereTerm aStatic[8]; /* Initial static space for a[] */
102510: #endif
102511: };
102512:
102513: /*
102514: ** A WhereTerm with eOperator==WO_OR has its u.pOrInfo pointer set to
102515: ** a dynamically allocated instance of the following structure.
102516: */
102517: struct WhereOrInfo {
102518: WhereClause wc; /* Decomposition into subterms */
102519: Bitmask indexable; /* Bitmask of all indexable tables in the clause */
102520: };
102521:
102522: /*
102523: ** A WhereTerm with eOperator==WO_AND has its u.pAndInfo pointer set to
102524: ** a dynamically allocated instance of the following structure.
102525: */
102526: struct WhereAndInfo {
102527: WhereClause wc; /* The subexpression broken out */
102528: };
102529:
102530: /*
102531: ** An instance of the following structure keeps track of a mapping
102532: ** between VDBE cursor numbers and bits of the bitmasks in WhereTerm.
102533: **
102534: ** The VDBE cursor numbers are small integers contained in
102535: ** SrcList_item.iCursor and Expr.iTable fields. For any given WHERE
102536: ** clause, the cursor numbers might not begin with 0 and they might
102537: ** contain gaps in the numbering sequence. But we want to make maximum
102538: ** use of the bits in our bitmasks. This structure provides a mapping
102539: ** from the sparse cursor numbers into consecutive integers beginning
102540: ** with 0.
102541: **
102542: ** If WhereMaskSet.ix[A]==B it means that The A-th bit of a Bitmask
102543: ** corresponds VDBE cursor number B. The A-th bit of a bitmask is 1<<A.
102544: **
102545: ** For example, if the WHERE clause expression used these VDBE
102546: ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure
102547: ** would map those cursor numbers into bits 0 through 5.
102548: **
102549: ** Note that the mapping is not necessarily ordered. In the example
102550: ** above, the mapping might go like this: 4->3, 5->1, 8->2, 29->0,
102551: ** 57->5, 73->4. Or one of 719 other combinations might be used. It
102552: ** does not really matter. What is important is that sparse cursor
102553: ** numbers all get mapped into bit numbers that begin with 0 and contain
102554: ** no gaps.
102555: */
102556: struct WhereMaskSet {
102557: int n; /* Number of assigned cursor values */
102558: int ix[BMS]; /* Cursor assigned to each bit */
102559: };
102560:
102561: /*
102562: ** A WhereCost object records a lookup strategy and the estimated
102563: ** cost of pursuing that strategy.
102564: */
102565: struct WhereCost {
102566: WherePlan plan; /* The lookup strategy */
102567: double rCost; /* Overall cost of pursuing this search strategy */
102568: Bitmask used; /* Bitmask of cursors used by this plan */
102569: };
102570:
102571: /*
102572: ** Bitmasks for the operators that indices are able to exploit. An
102573: ** OR-ed combination of these values can be used when searching for
102574: ** terms in the where clause.
102575: */
102576: #define WO_IN 0x001
102577: #define WO_EQ 0x002
102578: #define WO_LT (WO_EQ<<(TK_LT-TK_EQ))
102579: #define WO_LE (WO_EQ<<(TK_LE-TK_EQ))
102580: #define WO_GT (WO_EQ<<(TK_GT-TK_EQ))
102581: #define WO_GE (WO_EQ<<(TK_GE-TK_EQ))
102582: #define WO_MATCH 0x040
102583: #define WO_ISNULL 0x080
102584: #define WO_OR 0x100 /* Two or more OR-connected terms */
102585: #define WO_AND 0x200 /* Two or more AND-connected terms */
102586: #define WO_NOOP 0x800 /* This term does not restrict search space */
102587:
102588: #define WO_ALL 0xfff /* Mask of all possible WO_* values */
102589: #define WO_SINGLE 0x0ff /* Mask of all non-compound WO_* values */
102590:
102591: /*
102592: ** Value for wsFlags returned by bestIndex() and stored in
102593: ** WhereLevel.wsFlags. These flags determine which search
102594: ** strategies are appropriate.
102595: **
102596: ** The least significant 12 bits is reserved as a mask for WO_ values above.
102597: ** The WhereLevel.wsFlags field is usually set to WO_IN|WO_EQ|WO_ISNULL.
102598: ** But if the table is the right table of a left join, WhereLevel.wsFlags
102599: ** is set to WO_IN|WO_EQ. The WhereLevel.wsFlags field can then be used as
102600: ** the "op" parameter to findTerm when we are resolving equality constraints.
102601: ** ISNULL constraints will then not be used on the right table of a left
102602: ** join. Tickets #2177 and #2189.
102603: */
102604: #define WHERE_ROWID_EQ 0x00001000 /* rowid=EXPR or rowid IN (...) */
102605: #define WHERE_ROWID_RANGE 0x00002000 /* rowid<EXPR and/or rowid>EXPR */
102606: #define WHERE_COLUMN_EQ 0x00010000 /* x=EXPR or x IN (...) or x IS NULL */
102607: #define WHERE_COLUMN_RANGE 0x00020000 /* x<EXPR and/or x>EXPR */
102608: #define WHERE_COLUMN_IN 0x00040000 /* x IN (...) */
102609: #define WHERE_COLUMN_NULL 0x00080000 /* x IS NULL */
102610: #define WHERE_INDEXED 0x000f0000 /* Anything that uses an index */
102611: #define WHERE_NOT_FULLSCAN 0x100f3000 /* Does not do a full table scan */
102612: #define WHERE_IN_ABLE 0x000f1000 /* Able to support an IN operator */
102613: #define WHERE_TOP_LIMIT 0x00100000 /* x<EXPR or x<=EXPR constraint */
102614: #define WHERE_BTM_LIMIT 0x00200000 /* x>EXPR or x>=EXPR constraint */
102615: #define WHERE_BOTH_LIMIT 0x00300000 /* Both x>EXPR and x<EXPR */
102616: #define WHERE_IDX_ONLY 0x00800000 /* Use index only - omit table */
102617: #define WHERE_ORDERBY 0x01000000 /* Output will appear in correct order */
102618: #define WHERE_REVERSE 0x02000000 /* Scan in reverse order */
102619: #define WHERE_UNIQUE 0x04000000 /* Selects no more than one row */
102620: #define WHERE_VIRTUALTABLE 0x08000000 /* Use virtual-table processing */
102621: #define WHERE_MULTI_OR 0x10000000 /* OR using multiple indices */
102622: #define WHERE_TEMP_INDEX 0x20000000 /* Uses an ephemeral index */
102623: #define WHERE_DISTINCT 0x40000000 /* Correct order for DISTINCT */
102624:
102625: /*
102626: ** Initialize a preallocated WhereClause structure.
102627: */
102628: static void whereClauseInit(
102629: WhereClause *pWC, /* The WhereClause to be initialized */
102630: Parse *pParse, /* The parsing context */
102631: WhereMaskSet *pMaskSet, /* Mapping from table cursor numbers to bitmasks */
102632: u16 wctrlFlags /* Might include WHERE_AND_ONLY */
102633: ){
102634: pWC->pParse = pParse;
102635: pWC->pMaskSet = pMaskSet;
102636: pWC->pOuter = 0;
102637: pWC->nTerm = 0;
102638: pWC->nSlot = ArraySize(pWC->aStatic);
102639: pWC->a = pWC->aStatic;
102640: pWC->vmask = 0;
102641: pWC->wctrlFlags = wctrlFlags;
102642: }
102643:
102644: /* Forward reference */
102645: static void whereClauseClear(WhereClause*);
102646:
102647: /*
102648: ** Deallocate all memory associated with a WhereOrInfo object.
102649: */
102650: static void whereOrInfoDelete(sqlite3 *db, WhereOrInfo *p){
102651: whereClauseClear(&p->wc);
102652: sqlite3DbFree(db, p);
102653: }
102654:
102655: /*
102656: ** Deallocate all memory associated with a WhereAndInfo object.
102657: */
102658: static void whereAndInfoDelete(sqlite3 *db, WhereAndInfo *p){
102659: whereClauseClear(&p->wc);
102660: sqlite3DbFree(db, p);
102661: }
102662:
102663: /*
102664: ** Deallocate a WhereClause structure. The WhereClause structure
102665: ** itself is not freed. This routine is the inverse of whereClauseInit().
102666: */
102667: static void whereClauseClear(WhereClause *pWC){
102668: int i;
102669: WhereTerm *a;
102670: sqlite3 *db = pWC->pParse->db;
102671: for(i=pWC->nTerm-1, a=pWC->a; i>=0; i--, a++){
102672: if( a->wtFlags & TERM_DYNAMIC ){
102673: sqlite3ExprDelete(db, a->pExpr);
102674: }
102675: if( a->wtFlags & TERM_ORINFO ){
102676: whereOrInfoDelete(db, a->u.pOrInfo);
102677: }else if( a->wtFlags & TERM_ANDINFO ){
102678: whereAndInfoDelete(db, a->u.pAndInfo);
102679: }
102680: }
102681: if( pWC->a!=pWC->aStatic ){
102682: sqlite3DbFree(db, pWC->a);
102683: }
102684: }
102685:
102686: /*
102687: ** Add a single new WhereTerm entry to the WhereClause object pWC.
102688: ** The new WhereTerm object is constructed from Expr p and with wtFlags.
102689: ** The index in pWC->a[] of the new WhereTerm is returned on success.
102690: ** 0 is returned if the new WhereTerm could not be added due to a memory
102691: ** allocation error. The memory allocation failure will be recorded in
102692: ** the db->mallocFailed flag so that higher-level functions can detect it.
102693: **
102694: ** This routine will increase the size of the pWC->a[] array as necessary.
102695: **
102696: ** If the wtFlags argument includes TERM_DYNAMIC, then responsibility
102697: ** for freeing the expression p is assumed by the WhereClause object pWC.
102698: ** This is true even if this routine fails to allocate a new WhereTerm.
102699: **
102700: ** WARNING: This routine might reallocate the space used to store
102701: ** WhereTerms. All pointers to WhereTerms should be invalidated after
102702: ** calling this routine. Such pointers may be reinitialized by referencing
102703: ** the pWC->a[] array.
102704: */
102705: static int whereClauseInsert(WhereClause *pWC, Expr *p, u8 wtFlags){
102706: WhereTerm *pTerm;
102707: int idx;
102708: testcase( wtFlags & TERM_VIRTUAL ); /* EV: R-00211-15100 */
102709: if( pWC->nTerm>=pWC->nSlot ){
102710: WhereTerm *pOld = pWC->a;
102711: sqlite3 *db = pWC->pParse->db;
102712: pWC->a = sqlite3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
102713: if( pWC->a==0 ){
102714: if( wtFlags & TERM_DYNAMIC ){
102715: sqlite3ExprDelete(db, p);
102716: }
102717: pWC->a = pOld;
102718: return 0;
102719: }
102720: memcpy(pWC->a, pOld, sizeof(pWC->a[0])*pWC->nTerm);
102721: if( pOld!=pWC->aStatic ){
102722: sqlite3DbFree(db, pOld);
102723: }
102724: pWC->nSlot = sqlite3DbMallocSize(db, pWC->a)/sizeof(pWC->a[0]);
102725: }
102726: pTerm = &pWC->a[idx = pWC->nTerm++];
102727: pTerm->pExpr = p;
102728: pTerm->wtFlags = wtFlags;
102729: pTerm->pWC = pWC;
102730: pTerm->iParent = -1;
102731: return idx;
102732: }
102733:
102734: /*
102735: ** This routine identifies subexpressions in the WHERE clause where
102736: ** each subexpression is separated by the AND operator or some other
102737: ** operator specified in the op parameter. The WhereClause structure
102738: ** is filled with pointers to subexpressions. For example:
102739: **
102740: ** WHERE a=='hello' AND coalesce(b,11)<10 AND (c+12!=d OR c==22)
102741: ** \________/ \_______________/ \________________/
102742: ** slot[0] slot[1] slot[2]
102743: **
102744: ** The original WHERE clause in pExpr is unaltered. All this routine
102745: ** does is make slot[] entries point to substructure within pExpr.
102746: **
102747: ** In the previous sentence and in the diagram, "slot[]" refers to
102748: ** the WhereClause.a[] array. The slot[] array grows as needed to contain
102749: ** all terms of the WHERE clause.
102750: */
102751: static void whereSplit(WhereClause *pWC, Expr *pExpr, int op){
102752: pWC->op = (u8)op;
102753: if( pExpr==0 ) return;
102754: if( pExpr->op!=op ){
102755: whereClauseInsert(pWC, pExpr, 0);
102756: }else{
102757: whereSplit(pWC, pExpr->pLeft, op);
102758: whereSplit(pWC, pExpr->pRight, op);
102759: }
102760: }
102761:
102762: /*
102763: ** Initialize an expression mask set (a WhereMaskSet object)
102764: */
102765: #define initMaskSet(P) memset(P, 0, sizeof(*P))
102766:
102767: /*
102768: ** Return the bitmask for the given cursor number. Return 0 if
102769: ** iCursor is not in the set.
102770: */
102771: static Bitmask getMask(WhereMaskSet *pMaskSet, int iCursor){
102772: int i;
102773: assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 );
102774: for(i=0; i<pMaskSet->n; i++){
102775: if( pMaskSet->ix[i]==iCursor ){
102776: return ((Bitmask)1)<<i;
102777: }
102778: }
102779: return 0;
102780: }
102781:
102782: /*
102783: ** Create a new mask for cursor iCursor.
102784: **
102785: ** There is one cursor per table in the FROM clause. The number of
102786: ** tables in the FROM clause is limited by a test early in the
102787: ** sqlite3WhereBegin() routine. So we know that the pMaskSet->ix[]
102788: ** array will never overflow.
102789: */
102790: static void createMask(WhereMaskSet *pMaskSet, int iCursor){
102791: assert( pMaskSet->n < ArraySize(pMaskSet->ix) );
102792: pMaskSet->ix[pMaskSet->n++] = iCursor;
102793: }
102794:
102795: /*
102796: ** This routine walks (recursively) an expression tree and generates
102797: ** a bitmask indicating which tables are used in that expression
102798: ** tree.
102799: **
102800: ** In order for this routine to work, the calling function must have
102801: ** previously invoked sqlite3ResolveExprNames() on the expression. See
102802: ** the header comment on that routine for additional information.
102803: ** The sqlite3ResolveExprNames() routines looks for column names and
102804: ** sets their opcodes to TK_COLUMN and their Expr.iTable fields to
102805: ** the VDBE cursor number of the table. This routine just has to
102806: ** translate the cursor numbers into bitmask values and OR all
102807: ** the bitmasks together.
102808: */
102809: static Bitmask exprListTableUsage(WhereMaskSet*, ExprList*);
102810: static Bitmask exprSelectTableUsage(WhereMaskSet*, Select*);
102811: static Bitmask exprTableUsage(WhereMaskSet *pMaskSet, Expr *p){
102812: Bitmask mask = 0;
102813: if( p==0 ) return 0;
102814: if( p->op==TK_COLUMN ){
102815: mask = getMask(pMaskSet, p->iTable);
102816: return mask;
102817: }
102818: mask = exprTableUsage(pMaskSet, p->pRight);
102819: mask |= exprTableUsage(pMaskSet, p->pLeft);
102820: if( ExprHasProperty(p, EP_xIsSelect) ){
102821: mask |= exprSelectTableUsage(pMaskSet, p->x.pSelect);
102822: }else{
102823: mask |= exprListTableUsage(pMaskSet, p->x.pList);
102824: }
102825: return mask;
102826: }
102827: static Bitmask exprListTableUsage(WhereMaskSet *pMaskSet, ExprList *pList){
102828: int i;
102829: Bitmask mask = 0;
102830: if( pList ){
102831: for(i=0; i<pList->nExpr; i++){
102832: mask |= exprTableUsage(pMaskSet, pList->a[i].pExpr);
102833: }
102834: }
102835: return mask;
102836: }
102837: static Bitmask exprSelectTableUsage(WhereMaskSet *pMaskSet, Select *pS){
102838: Bitmask mask = 0;
102839: while( pS ){
102840: SrcList *pSrc = pS->pSrc;
102841: mask |= exprListTableUsage(pMaskSet, pS->pEList);
102842: mask |= exprListTableUsage(pMaskSet, pS->pGroupBy);
102843: mask |= exprListTableUsage(pMaskSet, pS->pOrderBy);
102844: mask |= exprTableUsage(pMaskSet, pS->pWhere);
102845: mask |= exprTableUsage(pMaskSet, pS->pHaving);
102846: if( ALWAYS(pSrc!=0) ){
102847: int i;
102848: for(i=0; i<pSrc->nSrc; i++){
102849: mask |= exprSelectTableUsage(pMaskSet, pSrc->a[i].pSelect);
102850: mask |= exprTableUsage(pMaskSet, pSrc->a[i].pOn);
102851: }
102852: }
102853: pS = pS->pPrior;
102854: }
102855: return mask;
102856: }
102857:
102858: /*
102859: ** Return TRUE if the given operator is one of the operators that is
102860: ** allowed for an indexable WHERE clause term. The allowed operators are
102861: ** "=", "<", ">", "<=", ">=", and "IN".
102862: **
102863: ** IMPLEMENTATION-OF: R-59926-26393 To be usable by an index a term must be
102864: ** of one of the following forms: column = expression column > expression
102865: ** column >= expression column < expression column <= expression
102866: ** expression = column expression > column expression >= column
102867: ** expression < column expression <= column column IN
102868: ** (expression-list) column IN (subquery) column IS NULL
102869: */
102870: static int allowedOp(int op){
102871: assert( TK_GT>TK_EQ && TK_GT<TK_GE );
102872: assert( TK_LT>TK_EQ && TK_LT<TK_GE );
102873: assert( TK_LE>TK_EQ && TK_LE<TK_GE );
102874: assert( TK_GE==TK_EQ+4 );
102875: return op==TK_IN || (op>=TK_EQ && op<=TK_GE) || op==TK_ISNULL;
102876: }
102877:
102878: /*
102879: ** Swap two objects of type TYPE.
102880: */
102881: #define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;}
102882:
102883: /*
102884: ** Commute a comparison operator. Expressions of the form "X op Y"
102885: ** are converted into "Y op X".
102886: **
102887: ** If a collation sequence is associated with either the left or right
102888: ** side of the comparison, it remains associated with the same side after
102889: ** the commutation. So "Y collate NOCASE op X" becomes
102890: ** "X collate NOCASE op Y". This is because any collation sequence on
102891: ** the left hand side of a comparison overrides any collation sequence
102892: ** attached to the right. For the same reason the EP_ExpCollate flag
102893: ** is not commuted.
102894: */
102895: static void exprCommute(Parse *pParse, Expr *pExpr){
102896: u16 expRight = (pExpr->pRight->flags & EP_ExpCollate);
102897: u16 expLeft = (pExpr->pLeft->flags & EP_ExpCollate);
102898: assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
102899: pExpr->pRight->pColl = sqlite3ExprCollSeq(pParse, pExpr->pRight);
102900: pExpr->pLeft->pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
102901: SWAP(CollSeq*,pExpr->pRight->pColl,pExpr->pLeft->pColl);
102902: pExpr->pRight->flags = (pExpr->pRight->flags & ~EP_ExpCollate) | expLeft;
102903: pExpr->pLeft->flags = (pExpr->pLeft->flags & ~EP_ExpCollate) | expRight;
102904: SWAP(Expr*,pExpr->pRight,pExpr->pLeft);
102905: if( pExpr->op>=TK_GT ){
102906: assert( TK_LT==TK_GT+2 );
102907: assert( TK_GE==TK_LE+2 );
102908: assert( TK_GT>TK_EQ );
102909: assert( TK_GT<TK_LE );
102910: assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
102911: pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
102912: }
102913: }
102914:
102915: /*
102916: ** Translate from TK_xx operator to WO_xx bitmask.
102917: */
102918: static u16 operatorMask(int op){
102919: u16 c;
102920: assert( allowedOp(op) );
102921: if( op==TK_IN ){
102922: c = WO_IN;
102923: }else if( op==TK_ISNULL ){
102924: c = WO_ISNULL;
102925: }else{
102926: assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
102927: c = (u16)(WO_EQ<<(op-TK_EQ));
102928: }
102929: assert( op!=TK_ISNULL || c==WO_ISNULL );
102930: assert( op!=TK_IN || c==WO_IN );
102931: assert( op!=TK_EQ || c==WO_EQ );
102932: assert( op!=TK_LT || c==WO_LT );
102933: assert( op!=TK_LE || c==WO_LE );
102934: assert( op!=TK_GT || c==WO_GT );
102935: assert( op!=TK_GE || c==WO_GE );
102936: return c;
102937: }
102938:
102939: /*
102940: ** Search for a term in the WHERE clause that is of the form "X <op> <expr>"
102941: ** where X is a reference to the iColumn of table iCur and <op> is one of
102942: ** the WO_xx operator codes specified by the op parameter.
102943: ** Return a pointer to the term. Return 0 if not found.
102944: */
102945: static WhereTerm *findTerm(
102946: WhereClause *pWC, /* The WHERE clause to be searched */
102947: int iCur, /* Cursor number of LHS */
102948: int iColumn, /* Column number of LHS */
102949: Bitmask notReady, /* RHS must not overlap with this mask */
102950: u32 op, /* Mask of WO_xx values describing operator */
102951: Index *pIdx /* Must be compatible with this index, if not NULL */
102952: ){
102953: WhereTerm *pTerm;
102954: int k;
102955: assert( iCur>=0 );
102956: op &= WO_ALL;
102957: for(; pWC; pWC=pWC->pOuter){
102958: for(pTerm=pWC->a, k=pWC->nTerm; k; k--, pTerm++){
102959: if( pTerm->leftCursor==iCur
102960: && (pTerm->prereqRight & notReady)==0
102961: && pTerm->u.leftColumn==iColumn
102962: && (pTerm->eOperator & op)!=0
102963: ){
102964: if( iColumn>=0 && pIdx && pTerm->eOperator!=WO_ISNULL ){
102965: Expr *pX = pTerm->pExpr;
102966: CollSeq *pColl;
102967: char idxaff;
102968: int j;
102969: Parse *pParse = pWC->pParse;
102970:
102971: idxaff = pIdx->pTable->aCol[iColumn].affinity;
102972: if( !sqlite3IndexAffinityOk(pX, idxaff) ) continue;
102973:
102974: /* Figure out the collation sequence required from an index for
102975: ** it to be useful for optimising expression pX. Store this
102976: ** value in variable pColl.
102977: */
102978: assert(pX->pLeft);
102979: pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
102980: assert(pColl || pParse->nErr);
102981:
102982: for(j=0; pIdx->aiColumn[j]!=iColumn; j++){
102983: if( NEVER(j>=pIdx->nColumn) ) return 0;
102984: }
102985: if( pColl && sqlite3StrICmp(pColl->zName, pIdx->azColl[j]) ) continue;
102986: }
102987: return pTerm;
102988: }
102989: }
102990: }
102991: return 0;
102992: }
102993:
102994: /* Forward reference */
102995: static void exprAnalyze(SrcList*, WhereClause*, int);
102996:
102997: /*
102998: ** Call exprAnalyze on all terms in a WHERE clause.
102999: **
103000: **
103001: */
103002: static void exprAnalyzeAll(
103003: SrcList *pTabList, /* the FROM clause */
103004: WhereClause *pWC /* the WHERE clause to be analyzed */
103005: ){
103006: int i;
103007: for(i=pWC->nTerm-1; i>=0; i--){
103008: exprAnalyze(pTabList, pWC, i);
103009: }
103010: }
103011:
103012: #ifndef SQLITE_OMIT_LIKE_OPTIMIZATION
103013: /*
103014: ** Check to see if the given expression is a LIKE or GLOB operator that
103015: ** can be optimized using inequality constraints. Return TRUE if it is
103016: ** so and false if not.
103017: **
103018: ** In order for the operator to be optimizible, the RHS must be a string
103019: ** literal that does not begin with a wildcard.
103020: */
103021: static int isLikeOrGlob(
103022: Parse *pParse, /* Parsing and code generating context */
103023: Expr *pExpr, /* Test this expression */
103024: Expr **ppPrefix, /* Pointer to TK_STRING expression with pattern prefix */
103025: int *pisComplete, /* True if the only wildcard is % in the last character */
103026: int *pnoCase /* True if uppercase is equivalent to lowercase */
103027: ){
103028: const char *z = 0; /* String on RHS of LIKE operator */
103029: Expr *pRight, *pLeft; /* Right and left size of LIKE operator */
103030: ExprList *pList; /* List of operands to the LIKE operator */
103031: int c; /* One character in z[] */
103032: int cnt; /* Number of non-wildcard prefix characters */
103033: char wc[3]; /* Wildcard characters */
103034: sqlite3 *db = pParse->db; /* Database connection */
103035: sqlite3_value *pVal = 0;
103036: int op; /* Opcode of pRight */
103037:
103038: if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, wc) ){
103039: return 0;
103040: }
103041: #ifdef SQLITE_EBCDIC
103042: if( *pnoCase ) return 0;
103043: #endif
103044: pList = pExpr->x.pList;
103045: pLeft = pList->a[1].pExpr;
103046: if( pLeft->op!=TK_COLUMN || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT ){
103047: /* IMP: R-02065-49465 The left-hand side of the LIKE or GLOB operator must
103048: ** be the name of an indexed column with TEXT affinity. */
103049: return 0;
103050: }
103051: assert( pLeft->iColumn!=(-1) ); /* Because IPK never has AFF_TEXT */
103052:
103053: pRight = pList->a[0].pExpr;
103054: op = pRight->op;
103055: if( op==TK_REGISTER ){
103056: op = pRight->op2;
103057: }
103058: if( op==TK_VARIABLE ){
103059: Vdbe *pReprepare = pParse->pReprepare;
103060: int iCol = pRight->iColumn;
103061: pVal = sqlite3VdbeGetValue(pReprepare, iCol, SQLITE_AFF_NONE);
103062: if( pVal && sqlite3_value_type(pVal)==SQLITE_TEXT ){
103063: z = (char *)sqlite3_value_text(pVal);
103064: }
103065: sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
103066: assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
103067: }else if( op==TK_STRING ){
103068: z = pRight->u.zToken;
103069: }
103070: if( z ){
103071: cnt = 0;
103072: while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
103073: cnt++;
103074: }
103075: if( cnt!=0 && 255!=(u8)z[cnt-1] ){
103076: Expr *pPrefix;
103077: *pisComplete = c==wc[0] && z[cnt+1]==0;
103078: pPrefix = sqlite3Expr(db, TK_STRING, z);
103079: if( pPrefix ) pPrefix->u.zToken[cnt] = 0;
103080: *ppPrefix = pPrefix;
103081: if( op==TK_VARIABLE ){
103082: Vdbe *v = pParse->pVdbe;
103083: sqlite3VdbeSetVarmask(v, pRight->iColumn);
103084: if( *pisComplete && pRight->u.zToken[1] ){
103085: /* If the rhs of the LIKE expression is a variable, and the current
103086: ** value of the variable means there is no need to invoke the LIKE
103087: ** function, then no OP_Variable will be added to the program.
103088: ** This causes problems for the sqlite3_bind_parameter_name()
103089: ** API. To workaround them, add a dummy OP_Variable here.
103090: */
103091: int r1 = sqlite3GetTempReg(pParse);
103092: sqlite3ExprCodeTarget(pParse, pRight, r1);
103093: sqlite3VdbeChangeP3(v, sqlite3VdbeCurrentAddr(v)-1, 0);
103094: sqlite3ReleaseTempReg(pParse, r1);
103095: }
103096: }
103097: }else{
103098: z = 0;
103099: }
103100: }
103101:
103102: sqlite3ValueFree(pVal);
103103: return (z!=0);
103104: }
103105: #endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */
103106:
103107:
103108: #ifndef SQLITE_OMIT_VIRTUALTABLE
103109: /*
103110: ** Check to see if the given expression is of the form
103111: **
103112: ** column MATCH expr
103113: **
103114: ** If it is then return TRUE. If not, return FALSE.
103115: */
103116: static int isMatchOfColumn(
103117: Expr *pExpr /* Test this expression */
103118: ){
103119: ExprList *pList;
103120:
103121: if( pExpr->op!=TK_FUNCTION ){
103122: return 0;
103123: }
103124: if( sqlite3StrICmp(pExpr->u.zToken,"match")!=0 ){
103125: return 0;
103126: }
103127: pList = pExpr->x.pList;
103128: if( pList->nExpr!=2 ){
103129: return 0;
103130: }
103131: if( pList->a[1].pExpr->op != TK_COLUMN ){
103132: return 0;
103133: }
103134: return 1;
103135: }
103136: #endif /* SQLITE_OMIT_VIRTUALTABLE */
103137:
103138: /*
103139: ** If the pBase expression originated in the ON or USING clause of
103140: ** a join, then transfer the appropriate markings over to derived.
103141: */
103142: static void transferJoinMarkings(Expr *pDerived, Expr *pBase){
103143: pDerived->flags |= pBase->flags & EP_FromJoin;
103144: pDerived->iRightJoinTable = pBase->iRightJoinTable;
103145: }
103146:
103147: #if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY)
103148: /*
103149: ** Analyze a term that consists of two or more OR-connected
103150: ** subterms. So in:
103151: **
103152: ** ... WHERE (a=5) AND (b=7 OR c=9 OR d=13) AND (d=13)
103153: ** ^^^^^^^^^^^^^^^^^^^^
103154: **
103155: ** This routine analyzes terms such as the middle term in the above example.
103156: ** A WhereOrTerm object is computed and attached to the term under
103157: ** analysis, regardless of the outcome of the analysis. Hence:
103158: **
103159: ** WhereTerm.wtFlags |= TERM_ORINFO
103160: ** WhereTerm.u.pOrInfo = a dynamically allocated WhereOrTerm object
103161: **
103162: ** The term being analyzed must have two or more of OR-connected subterms.
103163: ** A single subterm might be a set of AND-connected sub-subterms.
103164: ** Examples of terms under analysis:
103165: **
103166: ** (A) t1.x=t2.y OR t1.x=t2.z OR t1.y=15 OR t1.z=t3.a+5
103167: ** (B) x=expr1 OR expr2=x OR x=expr3
103168: ** (C) t1.x=t2.y OR (t1.x=t2.z AND t1.y=15)
103169: ** (D) x=expr1 OR (y>11 AND y<22 AND z LIKE '*hello*')
103170: ** (E) (p.a=1 AND q.b=2 AND r.c=3) OR (p.x=4 AND q.y=5 AND r.z=6)
103171: **
103172: ** CASE 1:
103173: **
103174: ** If all subterms are of the form T.C=expr for some single column of C
103175: ** a single table T (as shown in example B above) then create a new virtual
103176: ** term that is an equivalent IN expression. In other words, if the term
103177: ** being analyzed is:
103178: **
103179: ** x = expr1 OR expr2 = x OR x = expr3
103180: **
103181: ** then create a new virtual term like this:
103182: **
103183: ** x IN (expr1,expr2,expr3)
103184: **
103185: ** CASE 2:
103186: **
103187: ** If all subterms are indexable by a single table T, then set
103188: **
103189: ** WhereTerm.eOperator = WO_OR
103190: ** WhereTerm.u.pOrInfo->indexable |= the cursor number for table T
103191: **
103192: ** A subterm is "indexable" if it is of the form
103193: ** "T.C <op> <expr>" where C is any column of table T and
103194: ** <op> is one of "=", "<", "<=", ">", ">=", "IS NULL", or "IN".
103195: ** A subterm is also indexable if it is an AND of two or more
103196: ** subsubterms at least one of which is indexable. Indexable AND
103197: ** subterms have their eOperator set to WO_AND and they have
103198: ** u.pAndInfo set to a dynamically allocated WhereAndTerm object.
103199: **
103200: ** From another point of view, "indexable" means that the subterm could
103201: ** potentially be used with an index if an appropriate index exists.
103202: ** This analysis does not consider whether or not the index exists; that
103203: ** is something the bestIndex() routine will determine. This analysis
103204: ** only looks at whether subterms appropriate for indexing exist.
103205: **
103206: ** All examples A through E above all satisfy case 2. But if a term
103207: ** also statisfies case 1 (such as B) we know that the optimizer will
103208: ** always prefer case 1, so in that case we pretend that case 2 is not
103209: ** satisfied.
103210: **
103211: ** It might be the case that multiple tables are indexable. For example,
103212: ** (E) above is indexable on tables P, Q, and R.
103213: **
103214: ** Terms that satisfy case 2 are candidates for lookup by using
103215: ** separate indices to find rowids for each subterm and composing
103216: ** the union of all rowids using a RowSet object. This is similar
103217: ** to "bitmap indices" in other database engines.
103218: **
103219: ** OTHERWISE:
103220: **
103221: ** If neither case 1 nor case 2 apply, then leave the eOperator set to
103222: ** zero. This term is not useful for search.
103223: */
103224: static void exprAnalyzeOrTerm(
103225: SrcList *pSrc, /* the FROM clause */
103226: WhereClause *pWC, /* the complete WHERE clause */
103227: int idxTerm /* Index of the OR-term to be analyzed */
103228: ){
103229: Parse *pParse = pWC->pParse; /* Parser context */
103230: sqlite3 *db = pParse->db; /* Database connection */
103231: WhereTerm *pTerm = &pWC->a[idxTerm]; /* The term to be analyzed */
103232: Expr *pExpr = pTerm->pExpr; /* The expression of the term */
103233: WhereMaskSet *pMaskSet = pWC->pMaskSet; /* Table use masks */
103234: int i; /* Loop counters */
103235: WhereClause *pOrWc; /* Breakup of pTerm into subterms */
103236: WhereTerm *pOrTerm; /* A Sub-term within the pOrWc */
103237: WhereOrInfo *pOrInfo; /* Additional information associated with pTerm */
103238: Bitmask chngToIN; /* Tables that might satisfy case 1 */
103239: Bitmask indexable; /* Tables that are indexable, satisfying case 2 */
103240:
103241: /*
103242: ** Break the OR clause into its separate subterms. The subterms are
103243: ** stored in a WhereClause structure containing within the WhereOrInfo
103244: ** object that is attached to the original OR clause term.
103245: */
103246: assert( (pTerm->wtFlags & (TERM_DYNAMIC|TERM_ORINFO|TERM_ANDINFO))==0 );
103247: assert( pExpr->op==TK_OR );
103248: pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo));
103249: if( pOrInfo==0 ) return;
103250: pTerm->wtFlags |= TERM_ORINFO;
103251: pOrWc = &pOrInfo->wc;
103252: whereClauseInit(pOrWc, pWC->pParse, pMaskSet, pWC->wctrlFlags);
103253: whereSplit(pOrWc, pExpr, TK_OR);
103254: exprAnalyzeAll(pSrc, pOrWc);
103255: if( db->mallocFailed ) return;
103256: assert( pOrWc->nTerm>=2 );
103257:
103258: /*
103259: ** Compute the set of tables that might satisfy cases 1 or 2.
103260: */
103261: indexable = ~(Bitmask)0;
103262: chngToIN = ~(pWC->vmask);
103263: for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0 && indexable; i--, pOrTerm++){
103264: if( (pOrTerm->eOperator & WO_SINGLE)==0 ){
103265: WhereAndInfo *pAndInfo;
103266: assert( pOrTerm->eOperator==0 );
103267: assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
103268: chngToIN = 0;
103269: pAndInfo = sqlite3DbMallocRaw(db, sizeof(*pAndInfo));
103270: if( pAndInfo ){
103271: WhereClause *pAndWC;
103272: WhereTerm *pAndTerm;
103273: int j;
103274: Bitmask b = 0;
103275: pOrTerm->u.pAndInfo = pAndInfo;
103276: pOrTerm->wtFlags |= TERM_ANDINFO;
103277: pOrTerm->eOperator = WO_AND;
103278: pAndWC = &pAndInfo->wc;
103279: whereClauseInit(pAndWC, pWC->pParse, pMaskSet, pWC->wctrlFlags);
103280: whereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
103281: exprAnalyzeAll(pSrc, pAndWC);
103282: pAndWC->pOuter = pWC;
103283: testcase( db->mallocFailed );
103284: if( !db->mallocFailed ){
103285: for(j=0, pAndTerm=pAndWC->a; j<pAndWC->nTerm; j++, pAndTerm++){
103286: assert( pAndTerm->pExpr );
103287: if( allowedOp(pAndTerm->pExpr->op) ){
103288: b |= getMask(pMaskSet, pAndTerm->leftCursor);
103289: }
103290: }
103291: }
103292: indexable &= b;
103293: }
103294: }else if( pOrTerm->wtFlags & TERM_COPIED ){
103295: /* Skip this term for now. We revisit it when we process the
103296: ** corresponding TERM_VIRTUAL term */
103297: }else{
103298: Bitmask b;
103299: b = getMask(pMaskSet, pOrTerm->leftCursor);
103300: if( pOrTerm->wtFlags & TERM_VIRTUAL ){
103301: WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent];
103302: b |= getMask(pMaskSet, pOther->leftCursor);
103303: }
103304: indexable &= b;
103305: if( pOrTerm->eOperator!=WO_EQ ){
103306: chngToIN = 0;
103307: }else{
103308: chngToIN &= b;
103309: }
103310: }
103311: }
103312:
103313: /*
103314: ** Record the set of tables that satisfy case 2. The set might be
103315: ** empty.
103316: */
103317: pOrInfo->indexable = indexable;
103318: pTerm->eOperator = indexable==0 ? 0 : WO_OR;
103319:
103320: /*
103321: ** chngToIN holds a set of tables that *might* satisfy case 1. But
103322: ** we have to do some additional checking to see if case 1 really
103323: ** is satisfied.
103324: **
103325: ** chngToIN will hold either 0, 1, or 2 bits. The 0-bit case means
103326: ** that there is no possibility of transforming the OR clause into an
103327: ** IN operator because one or more terms in the OR clause contain
103328: ** something other than == on a column in the single table. The 1-bit
103329: ** case means that every term of the OR clause is of the form
103330: ** "table.column=expr" for some single table. The one bit that is set
103331: ** will correspond to the common table. We still need to check to make
103332: ** sure the same column is used on all terms. The 2-bit case is when
103333: ** the all terms are of the form "table1.column=table2.column". It
103334: ** might be possible to form an IN operator with either table1.column
103335: ** or table2.column as the LHS if either is common to every term of
103336: ** the OR clause.
103337: **
103338: ** Note that terms of the form "table.column1=table.column2" (the
103339: ** same table on both sizes of the ==) cannot be optimized.
103340: */
103341: if( chngToIN ){
103342: int okToChngToIN = 0; /* True if the conversion to IN is valid */
103343: int iColumn = -1; /* Column index on lhs of IN operator */
103344: int iCursor = -1; /* Table cursor common to all terms */
103345: int j = 0; /* Loop counter */
103346:
103347: /* Search for a table and column that appears on one side or the
103348: ** other of the == operator in every subterm. That table and column
103349: ** will be recorded in iCursor and iColumn. There might not be any
103350: ** such table and column. Set okToChngToIN if an appropriate table
103351: ** and column is found but leave okToChngToIN false if not found.
103352: */
103353: for(j=0; j<2 && !okToChngToIN; j++){
103354: pOrTerm = pOrWc->a;
103355: for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){
103356: assert( pOrTerm->eOperator==WO_EQ );
103357: pOrTerm->wtFlags &= ~TERM_OR_OK;
103358: if( pOrTerm->leftCursor==iCursor ){
103359: /* This is the 2-bit case and we are on the second iteration and
103360: ** current term is from the first iteration. So skip this term. */
103361: assert( j==1 );
103362: continue;
103363: }
103364: if( (chngToIN & getMask(pMaskSet, pOrTerm->leftCursor))==0 ){
103365: /* This term must be of the form t1.a==t2.b where t2 is in the
103366: ** chngToIN set but t1 is not. This term will be either preceeded
103367: ** or follwed by an inverted copy (t2.b==t1.a). Skip this term
103368: ** and use its inversion. */
103369: testcase( pOrTerm->wtFlags & TERM_COPIED );
103370: testcase( pOrTerm->wtFlags & TERM_VIRTUAL );
103371: assert( pOrTerm->wtFlags & (TERM_COPIED|TERM_VIRTUAL) );
103372: continue;
103373: }
103374: iColumn = pOrTerm->u.leftColumn;
103375: iCursor = pOrTerm->leftCursor;
103376: break;
103377: }
103378: if( i<0 ){
103379: /* No candidate table+column was found. This can only occur
103380: ** on the second iteration */
103381: assert( j==1 );
103382: assert( (chngToIN&(chngToIN-1))==0 );
103383: assert( chngToIN==getMask(pMaskSet, iCursor) );
103384: break;
103385: }
103386: testcase( j==1 );
103387:
103388: /* We have found a candidate table and column. Check to see if that
103389: ** table and column is common to every term in the OR clause */
103390: okToChngToIN = 1;
103391: for(; i>=0 && okToChngToIN; i--, pOrTerm++){
103392: assert( pOrTerm->eOperator==WO_EQ );
103393: if( pOrTerm->leftCursor!=iCursor ){
103394: pOrTerm->wtFlags &= ~TERM_OR_OK;
103395: }else if( pOrTerm->u.leftColumn!=iColumn ){
103396: okToChngToIN = 0;
103397: }else{
103398: int affLeft, affRight;
103399: /* If the right-hand side is also a column, then the affinities
103400: ** of both right and left sides must be such that no type
103401: ** conversions are required on the right. (Ticket #2249)
103402: */
103403: affRight = sqlite3ExprAffinity(pOrTerm->pExpr->pRight);
103404: affLeft = sqlite3ExprAffinity(pOrTerm->pExpr->pLeft);
103405: if( affRight!=0 && affRight!=affLeft ){
103406: okToChngToIN = 0;
103407: }else{
103408: pOrTerm->wtFlags |= TERM_OR_OK;
103409: }
103410: }
103411: }
103412: }
103413:
103414: /* At this point, okToChngToIN is true if original pTerm satisfies
103415: ** case 1. In that case, construct a new virtual term that is
103416: ** pTerm converted into an IN operator.
103417: **
103418: ** EV: R-00211-15100
103419: */
103420: if( okToChngToIN ){
103421: Expr *pDup; /* A transient duplicate expression */
103422: ExprList *pList = 0; /* The RHS of the IN operator */
103423: Expr *pLeft = 0; /* The LHS of the IN operator */
103424: Expr *pNew; /* The complete IN operator */
103425:
103426: for(i=pOrWc->nTerm-1, pOrTerm=pOrWc->a; i>=0; i--, pOrTerm++){
103427: if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue;
103428: assert( pOrTerm->eOperator==WO_EQ );
103429: assert( pOrTerm->leftCursor==iCursor );
103430: assert( pOrTerm->u.leftColumn==iColumn );
103431: pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0);
103432: pList = sqlite3ExprListAppend(pWC->pParse, pList, pDup);
103433: pLeft = pOrTerm->pExpr->pLeft;
103434: }
103435: assert( pLeft!=0 );
103436: pDup = sqlite3ExprDup(db, pLeft, 0);
103437: pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0, 0);
103438: if( pNew ){
103439: int idxNew;
103440: transferJoinMarkings(pNew, pExpr);
103441: assert( !ExprHasProperty(pNew, EP_xIsSelect) );
103442: pNew->x.pList = pList;
103443: idxNew = whereClauseInsert(pWC, pNew, TERM_VIRTUAL|TERM_DYNAMIC);
103444: testcase( idxNew==0 );
103445: exprAnalyze(pSrc, pWC, idxNew);
103446: pTerm = &pWC->a[idxTerm];
103447: pWC->a[idxNew].iParent = idxTerm;
103448: pTerm->nChild = 1;
103449: }else{
103450: sqlite3ExprListDelete(db, pList);
103451: }
103452: pTerm->eOperator = WO_NOOP; /* case 1 trumps case 2 */
103453: }
103454: }
103455: }
103456: #endif /* !SQLITE_OMIT_OR_OPTIMIZATION && !SQLITE_OMIT_SUBQUERY */
103457:
103458:
103459: /*
103460: ** The input to this routine is an WhereTerm structure with only the
103461: ** "pExpr" field filled in. The job of this routine is to analyze the
103462: ** subexpression and populate all the other fields of the WhereTerm
103463: ** structure.
103464: **
103465: ** If the expression is of the form "<expr> <op> X" it gets commuted
103466: ** to the standard form of "X <op> <expr>".
103467: **
103468: ** If the expression is of the form "X <op> Y" where both X and Y are
103469: ** columns, then the original expression is unchanged and a new virtual
103470: ** term of the form "Y <op> X" is added to the WHERE clause and
103471: ** analyzed separately. The original term is marked with TERM_COPIED
103472: ** and the new term is marked with TERM_DYNAMIC (because it's pExpr
103473: ** needs to be freed with the WhereClause) and TERM_VIRTUAL (because it
103474: ** is a commuted copy of a prior term.) The original term has nChild=1
103475: ** and the copy has idxParent set to the index of the original term.
103476: */
103477: static void exprAnalyze(
103478: SrcList *pSrc, /* the FROM clause */
103479: WhereClause *pWC, /* the WHERE clause */
103480: int idxTerm /* Index of the term to be analyzed */
103481: ){
103482: WhereTerm *pTerm; /* The term to be analyzed */
103483: WhereMaskSet *pMaskSet; /* Set of table index masks */
103484: Expr *pExpr; /* The expression to be analyzed */
103485: Bitmask prereqLeft; /* Prerequesites of the pExpr->pLeft */
103486: Bitmask prereqAll; /* Prerequesites of pExpr */
103487: Bitmask extraRight = 0; /* Extra dependencies on LEFT JOIN */
103488: Expr *pStr1 = 0; /* RHS of LIKE/GLOB operator */
103489: int isComplete = 0; /* RHS of LIKE/GLOB ends with wildcard */
103490: int noCase = 0; /* LIKE/GLOB distinguishes case */
103491: int op; /* Top-level operator. pExpr->op */
103492: Parse *pParse = pWC->pParse; /* Parsing context */
103493: sqlite3 *db = pParse->db; /* Database connection */
103494:
103495: if( db->mallocFailed ){
103496: return;
103497: }
103498: pTerm = &pWC->a[idxTerm];
103499: pMaskSet = pWC->pMaskSet;
103500: pExpr = pTerm->pExpr;
103501: prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft);
103502: op = pExpr->op;
103503: if( op==TK_IN ){
103504: assert( pExpr->pRight==0 );
103505: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
103506: pTerm->prereqRight = exprSelectTableUsage(pMaskSet, pExpr->x.pSelect);
103507: }else{
103508: pTerm->prereqRight = exprListTableUsage(pMaskSet, pExpr->x.pList);
103509: }
103510: }else if( op==TK_ISNULL ){
103511: pTerm->prereqRight = 0;
103512: }else{
103513: pTerm->prereqRight = exprTableUsage(pMaskSet, pExpr->pRight);
103514: }
103515: prereqAll = exprTableUsage(pMaskSet, pExpr);
103516: if( ExprHasProperty(pExpr, EP_FromJoin) ){
103517: Bitmask x = getMask(pMaskSet, pExpr->iRightJoinTable);
103518: prereqAll |= x;
103519: extraRight = x-1; /* ON clause terms may not be used with an index
103520: ** on left table of a LEFT JOIN. Ticket #3015 */
103521: }
103522: pTerm->prereqAll = prereqAll;
103523: pTerm->leftCursor = -1;
103524: pTerm->iParent = -1;
103525: pTerm->eOperator = 0;
103526: if( allowedOp(op) && (pTerm->prereqRight & prereqLeft)==0 ){
103527: Expr *pLeft = pExpr->pLeft;
103528: Expr *pRight = pExpr->pRight;
103529: if( pLeft->op==TK_COLUMN ){
103530: pTerm->leftCursor = pLeft->iTable;
103531: pTerm->u.leftColumn = pLeft->iColumn;
103532: pTerm->eOperator = operatorMask(op);
103533: }
103534: if( pRight && pRight->op==TK_COLUMN ){
103535: WhereTerm *pNew;
103536: Expr *pDup;
103537: if( pTerm->leftCursor>=0 ){
103538: int idxNew;
103539: pDup = sqlite3ExprDup(db, pExpr, 0);
103540: if( db->mallocFailed ){
103541: sqlite3ExprDelete(db, pDup);
103542: return;
103543: }
103544: idxNew = whereClauseInsert(pWC, pDup, TERM_VIRTUAL|TERM_DYNAMIC);
103545: if( idxNew==0 ) return;
103546: pNew = &pWC->a[idxNew];
103547: pNew->iParent = idxTerm;
103548: pTerm = &pWC->a[idxTerm];
103549: pTerm->nChild = 1;
103550: pTerm->wtFlags |= TERM_COPIED;
103551: }else{
103552: pDup = pExpr;
103553: pNew = pTerm;
103554: }
103555: exprCommute(pParse, pDup);
103556: pLeft = pDup->pLeft;
103557: pNew->leftCursor = pLeft->iTable;
103558: pNew->u.leftColumn = pLeft->iColumn;
103559: testcase( (prereqLeft | extraRight) != prereqLeft );
103560: pNew->prereqRight = prereqLeft | extraRight;
103561: pNew->prereqAll = prereqAll;
103562: pNew->eOperator = operatorMask(pDup->op);
103563: }
103564: }
103565:
103566: #ifndef SQLITE_OMIT_BETWEEN_OPTIMIZATION
103567: /* If a term is the BETWEEN operator, create two new virtual terms
103568: ** that define the range that the BETWEEN implements. For example:
103569: **
103570: ** a BETWEEN b AND c
103571: **
103572: ** is converted into:
103573: **
103574: ** (a BETWEEN b AND c) AND (a>=b) AND (a<=c)
103575: **
103576: ** The two new terms are added onto the end of the WhereClause object.
103577: ** The new terms are "dynamic" and are children of the original BETWEEN
103578: ** term. That means that if the BETWEEN term is coded, the children are
103579: ** skipped. Or, if the children are satisfied by an index, the original
103580: ** BETWEEN term is skipped.
103581: */
103582: else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
103583: ExprList *pList = pExpr->x.pList;
103584: int i;
103585: static const u8 ops[] = {TK_GE, TK_LE};
103586: assert( pList!=0 );
103587: assert( pList->nExpr==2 );
103588: for(i=0; i<2; i++){
103589: Expr *pNewExpr;
103590: int idxNew;
103591: pNewExpr = sqlite3PExpr(pParse, ops[i],
103592: sqlite3ExprDup(db, pExpr->pLeft, 0),
103593: sqlite3ExprDup(db, pList->a[i].pExpr, 0), 0);
103594: idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
103595: testcase( idxNew==0 );
103596: exprAnalyze(pSrc, pWC, idxNew);
103597: pTerm = &pWC->a[idxTerm];
103598: pWC->a[idxNew].iParent = idxTerm;
103599: }
103600: pTerm->nChild = 2;
103601: }
103602: #endif /* SQLITE_OMIT_BETWEEN_OPTIMIZATION */
103603:
103604: #if !defined(SQLITE_OMIT_OR_OPTIMIZATION) && !defined(SQLITE_OMIT_SUBQUERY)
103605: /* Analyze a term that is composed of two or more subterms connected by
103606: ** an OR operator.
103607: */
103608: else if( pExpr->op==TK_OR ){
103609: assert( pWC->op==TK_AND );
103610: exprAnalyzeOrTerm(pSrc, pWC, idxTerm);
103611: pTerm = &pWC->a[idxTerm];
103612: }
103613: #endif /* SQLITE_OMIT_OR_OPTIMIZATION */
103614:
103615: #ifndef SQLITE_OMIT_LIKE_OPTIMIZATION
103616: /* Add constraints to reduce the search space on a LIKE or GLOB
103617: ** operator.
103618: **
103619: ** A like pattern of the form "x LIKE 'abc%'" is changed into constraints
103620: **
103621: ** x>='abc' AND x<'abd' AND x LIKE 'abc%'
103622: **
103623: ** The last character of the prefix "abc" is incremented to form the
103624: ** termination condition "abd".
103625: */
103626: if( pWC->op==TK_AND
103627: && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
103628: ){
103629: Expr *pLeft; /* LHS of LIKE/GLOB operator */
103630: Expr *pStr2; /* Copy of pStr1 - RHS of LIKE/GLOB operator */
103631: Expr *pNewExpr1;
103632: Expr *pNewExpr2;
103633: int idxNew1;
103634: int idxNew2;
103635: CollSeq *pColl; /* Collating sequence to use */
103636:
103637: pLeft = pExpr->x.pList->a[1].pExpr;
103638: pStr2 = sqlite3ExprDup(db, pStr1, 0);
103639: if( !db->mallocFailed ){
103640: u8 c, *pC; /* Last character before the first wildcard */
103641: pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
103642: c = *pC;
103643: if( noCase ){
103644: /* The point is to increment the last character before the first
103645: ** wildcard. But if we increment '@', that will push it into the
103646: ** alphabetic range where case conversions will mess up the
103647: ** inequality. To avoid this, make sure to also run the full
103648: ** LIKE on all candidate expressions by clearing the isComplete flag
103649: */
103650: if( c=='A'-1 ) isComplete = 0; /* EV: R-64339-08207 */
103651:
103652:
103653: c = sqlite3UpperToLower[c];
103654: }
103655: *pC = c + 1;
103656: }
103657: pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, noCase ? "NOCASE" : "BINARY",0);
103658: pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
103659: sqlite3ExprSetColl(sqlite3ExprDup(db,pLeft,0), pColl),
103660: pStr1, 0);
103661: idxNew1 = whereClauseInsert(pWC, pNewExpr1, TERM_VIRTUAL|TERM_DYNAMIC);
103662: testcase( idxNew1==0 );
103663: exprAnalyze(pSrc, pWC, idxNew1);
103664: pNewExpr2 = sqlite3PExpr(pParse, TK_LT,
103665: sqlite3ExprSetColl(sqlite3ExprDup(db,pLeft,0), pColl),
103666: pStr2, 0);
103667: idxNew2 = whereClauseInsert(pWC, pNewExpr2, TERM_VIRTUAL|TERM_DYNAMIC);
103668: testcase( idxNew2==0 );
103669: exprAnalyze(pSrc, pWC, idxNew2);
103670: pTerm = &pWC->a[idxTerm];
103671: if( isComplete ){
103672: pWC->a[idxNew1].iParent = idxTerm;
103673: pWC->a[idxNew2].iParent = idxTerm;
103674: pTerm->nChild = 2;
103675: }
103676: }
103677: #endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */
103678:
103679: #ifndef SQLITE_OMIT_VIRTUALTABLE
103680: /* Add a WO_MATCH auxiliary term to the constraint set if the
103681: ** current expression is of the form: column MATCH expr.
103682: ** This information is used by the xBestIndex methods of
103683: ** virtual tables. The native query optimizer does not attempt
103684: ** to do anything with MATCH functions.
103685: */
103686: if( isMatchOfColumn(pExpr) ){
103687: int idxNew;
103688: Expr *pRight, *pLeft;
103689: WhereTerm *pNewTerm;
103690: Bitmask prereqColumn, prereqExpr;
103691:
103692: pRight = pExpr->x.pList->a[0].pExpr;
103693: pLeft = pExpr->x.pList->a[1].pExpr;
103694: prereqExpr = exprTableUsage(pMaskSet, pRight);
103695: prereqColumn = exprTableUsage(pMaskSet, pLeft);
103696: if( (prereqExpr & prereqColumn)==0 ){
103697: Expr *pNewExpr;
103698: pNewExpr = sqlite3PExpr(pParse, TK_MATCH,
103699: 0, sqlite3ExprDup(db, pRight, 0), 0);
103700: idxNew = whereClauseInsert(pWC, pNewExpr, TERM_VIRTUAL|TERM_DYNAMIC);
103701: testcase( idxNew==0 );
103702: pNewTerm = &pWC->a[idxNew];
103703: pNewTerm->prereqRight = prereqExpr;
103704: pNewTerm->leftCursor = pLeft->iTable;
103705: pNewTerm->u.leftColumn = pLeft->iColumn;
103706: pNewTerm->eOperator = WO_MATCH;
103707: pNewTerm->iParent = idxTerm;
103708: pTerm = &pWC->a[idxTerm];
103709: pTerm->nChild = 1;
103710: pTerm->wtFlags |= TERM_COPIED;
103711: pNewTerm->prereqAll = pTerm->prereqAll;
103712: }
103713: }
103714: #endif /* SQLITE_OMIT_VIRTUALTABLE */
103715:
103716: #ifdef SQLITE_ENABLE_STAT3
103717: /* When sqlite_stat3 histogram data is available an operator of the
103718: ** form "x IS NOT NULL" can sometimes be evaluated more efficiently
103719: ** as "x>NULL" if x is not an INTEGER PRIMARY KEY. So construct a
103720: ** virtual term of that form.
103721: **
103722: ** Note that the virtual term must be tagged with TERM_VNULL. This
103723: ** TERM_VNULL tag will suppress the not-null check at the beginning
103724: ** of the loop. Without the TERM_VNULL flag, the not-null check at
103725: ** the start of the loop will prevent any results from being returned.
103726: */
103727: if( pExpr->op==TK_NOTNULL
103728: && pExpr->pLeft->op==TK_COLUMN
103729: && pExpr->pLeft->iColumn>=0
103730: ){
103731: Expr *pNewExpr;
103732: Expr *pLeft = pExpr->pLeft;
103733: int idxNew;
103734: WhereTerm *pNewTerm;
103735:
103736: pNewExpr = sqlite3PExpr(pParse, TK_GT,
103737: sqlite3ExprDup(db, pLeft, 0),
103738: sqlite3PExpr(pParse, TK_NULL, 0, 0, 0), 0);
103739:
103740: idxNew = whereClauseInsert(pWC, pNewExpr,
103741: TERM_VIRTUAL|TERM_DYNAMIC|TERM_VNULL);
103742: if( idxNew ){
103743: pNewTerm = &pWC->a[idxNew];
103744: pNewTerm->prereqRight = 0;
103745: pNewTerm->leftCursor = pLeft->iTable;
103746: pNewTerm->u.leftColumn = pLeft->iColumn;
103747: pNewTerm->eOperator = WO_GT;
103748: pNewTerm->iParent = idxTerm;
103749: pTerm = &pWC->a[idxTerm];
103750: pTerm->nChild = 1;
103751: pTerm->wtFlags |= TERM_COPIED;
103752: pNewTerm->prereqAll = pTerm->prereqAll;
103753: }
103754: }
103755: #endif /* SQLITE_ENABLE_STAT */
103756:
103757: /* Prevent ON clause terms of a LEFT JOIN from being used to drive
103758: ** an index for tables to the left of the join.
103759: */
103760: pTerm->prereqRight |= extraRight;
103761: }
103762:
103763: /*
103764: ** Return TRUE if any of the expressions in pList->a[iFirst...] contain
103765: ** a reference to any table other than the iBase table.
103766: */
103767: static int referencesOtherTables(
103768: ExprList *pList, /* Search expressions in ths list */
103769: WhereMaskSet *pMaskSet, /* Mapping from tables to bitmaps */
103770: int iFirst, /* Be searching with the iFirst-th expression */
103771: int iBase /* Ignore references to this table */
103772: ){
103773: Bitmask allowed = ~getMask(pMaskSet, iBase);
103774: while( iFirst<pList->nExpr ){
103775: if( (exprTableUsage(pMaskSet, pList->a[iFirst++].pExpr)&allowed)!=0 ){
103776: return 1;
103777: }
103778: }
103779: return 0;
103780: }
103781:
103782: /*
103783: ** This function searches the expression list passed as the second argument
103784: ** for an expression of type TK_COLUMN that refers to the same column and
103785: ** uses the same collation sequence as the iCol'th column of index pIdx.
103786: ** Argument iBase is the cursor number used for the table that pIdx refers
103787: ** to.
103788: **
103789: ** If such an expression is found, its index in pList->a[] is returned. If
103790: ** no expression is found, -1 is returned.
103791: */
103792: static int findIndexCol(
103793: Parse *pParse, /* Parse context */
103794: ExprList *pList, /* Expression list to search */
103795: int iBase, /* Cursor for table associated with pIdx */
103796: Index *pIdx, /* Index to match column of */
103797: int iCol /* Column of index to match */
103798: ){
103799: int i;
103800: const char *zColl = pIdx->azColl[iCol];
103801:
103802: for(i=0; i<pList->nExpr; i++){
103803: Expr *p = pList->a[i].pExpr;
103804: if( p->op==TK_COLUMN
103805: && p->iColumn==pIdx->aiColumn[iCol]
103806: && p->iTable==iBase
103807: ){
103808: CollSeq *pColl = sqlite3ExprCollSeq(pParse, p);
103809: if( ALWAYS(pColl) && 0==sqlite3StrICmp(pColl->zName, zColl) ){
103810: return i;
103811: }
103812: }
103813: }
103814:
103815: return -1;
103816: }
103817:
103818: /*
103819: ** This routine determines if pIdx can be used to assist in processing a
103820: ** DISTINCT qualifier. In other words, it tests whether or not using this
103821: ** index for the outer loop guarantees that rows with equal values for
103822: ** all expressions in the pDistinct list are delivered grouped together.
103823: **
103824: ** For example, the query
103825: **
103826: ** SELECT DISTINCT a, b, c FROM tbl WHERE a = ?
103827: **
103828: ** can benefit from any index on columns "b" and "c".
103829: */
103830: static int isDistinctIndex(
103831: Parse *pParse, /* Parsing context */
103832: WhereClause *pWC, /* The WHERE clause */
103833: Index *pIdx, /* The index being considered */
103834: int base, /* Cursor number for the table pIdx is on */
103835: ExprList *pDistinct, /* The DISTINCT expressions */
103836: int nEqCol /* Number of index columns with == */
103837: ){
103838: Bitmask mask = 0; /* Mask of unaccounted for pDistinct exprs */
103839: int i; /* Iterator variable */
103840:
103841: if( pIdx->zName==0 || pDistinct==0 || pDistinct->nExpr>=BMS ) return 0;
103842: testcase( pDistinct->nExpr==BMS-1 );
103843:
103844: /* Loop through all the expressions in the distinct list. If any of them
103845: ** are not simple column references, return early. Otherwise, test if the
103846: ** WHERE clause contains a "col=X" clause. If it does, the expression
103847: ** can be ignored. If it does not, and the column does not belong to the
103848: ** same table as index pIdx, return early. Finally, if there is no
103849: ** matching "col=X" expression and the column is on the same table as pIdx,
103850: ** set the corresponding bit in variable mask.
103851: */
103852: for(i=0; i<pDistinct->nExpr; i++){
103853: WhereTerm *pTerm;
103854: Expr *p = pDistinct->a[i].pExpr;
103855: if( p->op!=TK_COLUMN ) return 0;
103856: pTerm = findTerm(pWC, p->iTable, p->iColumn, ~(Bitmask)0, WO_EQ, 0);
103857: if( pTerm ){
103858: Expr *pX = pTerm->pExpr;
103859: CollSeq *p1 = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
103860: CollSeq *p2 = sqlite3ExprCollSeq(pParse, p);
103861: if( p1==p2 ) continue;
103862: }
103863: if( p->iTable!=base ) return 0;
103864: mask |= (((Bitmask)1) << i);
103865: }
103866:
103867: for(i=nEqCol; mask && i<pIdx->nColumn; i++){
103868: int iExpr = findIndexCol(pParse, pDistinct, base, pIdx, i);
103869: if( iExpr<0 ) break;
103870: mask &= ~(((Bitmask)1) << iExpr);
103871: }
103872:
103873: return (mask==0);
103874: }
103875:
103876:
103877: /*
103878: ** Return true if the DISTINCT expression-list passed as the third argument
103879: ** is redundant. A DISTINCT list is redundant if the database contains a
103880: ** UNIQUE index that guarantees that the result of the query will be distinct
103881: ** anyway.
103882: */
103883: static int isDistinctRedundant(
103884: Parse *pParse,
103885: SrcList *pTabList,
103886: WhereClause *pWC,
103887: ExprList *pDistinct
103888: ){
103889: Table *pTab;
103890: Index *pIdx;
103891: int i;
103892: int iBase;
103893:
103894: /* If there is more than one table or sub-select in the FROM clause of
103895: ** this query, then it will not be possible to show that the DISTINCT
103896: ** clause is redundant. */
103897: if( pTabList->nSrc!=1 ) return 0;
103898: iBase = pTabList->a[0].iCursor;
103899: pTab = pTabList->a[0].pTab;
103900:
103901: /* If any of the expressions is an IPK column on table iBase, then return
103902: ** true. Note: The (p->iTable==iBase) part of this test may be false if the
103903: ** current SELECT is a correlated sub-query.
103904: */
103905: for(i=0; i<pDistinct->nExpr; i++){
103906: Expr *p = pDistinct->a[i].pExpr;
103907: if( p->op==TK_COLUMN && p->iTable==iBase && p->iColumn<0 ) return 1;
103908: }
103909:
103910: /* Loop through all indices on the table, checking each to see if it makes
103911: ** the DISTINCT qualifier redundant. It does so if:
103912: **
103913: ** 1. The index is itself UNIQUE, and
103914: **
103915: ** 2. All of the columns in the index are either part of the pDistinct
103916: ** list, or else the WHERE clause contains a term of the form "col=X",
103917: ** where X is a constant value. The collation sequences of the
103918: ** comparison and select-list expressions must match those of the index.
103919: */
103920: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
103921: if( pIdx->onError==OE_None ) continue;
103922: for(i=0; i<pIdx->nColumn; i++){
103923: int iCol = pIdx->aiColumn[i];
103924: if( 0==findTerm(pWC, iBase, iCol, ~(Bitmask)0, WO_EQ, pIdx)
103925: && 0>findIndexCol(pParse, pDistinct, iBase, pIdx, i)
103926: ){
103927: break;
103928: }
103929: }
103930: if( i==pIdx->nColumn ){
103931: /* This index implies that the DISTINCT qualifier is redundant. */
103932: return 1;
103933: }
103934: }
103935:
103936: return 0;
103937: }
103938:
103939: /*
103940: ** This routine decides if pIdx can be used to satisfy the ORDER BY
103941: ** clause. If it can, it returns 1. If pIdx cannot satisfy the
103942: ** ORDER BY clause, this routine returns 0.
103943: **
103944: ** pOrderBy is an ORDER BY clause from a SELECT statement. pTab is the
103945: ** left-most table in the FROM clause of that same SELECT statement and
103946: ** the table has a cursor number of "base". pIdx is an index on pTab.
103947: **
103948: ** nEqCol is the number of columns of pIdx that are used as equality
103949: ** constraints. Any of these columns may be missing from the ORDER BY
103950: ** clause and the match can still be a success.
103951: **
103952: ** All terms of the ORDER BY that match against the index must be either
103953: ** ASC or DESC. (Terms of the ORDER BY clause past the end of a UNIQUE
103954: ** index do not need to satisfy this constraint.) The *pbRev value is
103955: ** set to 1 if the ORDER BY clause is all DESC and it is set to 0 if
103956: ** the ORDER BY clause is all ASC.
103957: */
103958: static int isSortingIndex(
103959: Parse *pParse, /* Parsing context */
103960: WhereMaskSet *pMaskSet, /* Mapping from table cursor numbers to bitmaps */
103961: Index *pIdx, /* The index we are testing */
103962: int base, /* Cursor number for the table to be sorted */
103963: ExprList *pOrderBy, /* The ORDER BY clause */
103964: int nEqCol, /* Number of index columns with == constraints */
103965: int wsFlags, /* Index usages flags */
103966: int *pbRev /* Set to 1 if ORDER BY is DESC */
103967: ){
103968: int i, j; /* Loop counters */
103969: int sortOrder = 0; /* XOR of index and ORDER BY sort direction */
103970: int nTerm; /* Number of ORDER BY terms */
103971: struct ExprList_item *pTerm; /* A term of the ORDER BY clause */
103972: sqlite3 *db = pParse->db;
103973:
103974: if( !pOrderBy ) return 0;
103975: if( wsFlags & WHERE_COLUMN_IN ) return 0;
103976: if( pIdx->bUnordered ) return 0;
103977:
103978: nTerm = pOrderBy->nExpr;
103979: assert( nTerm>0 );
103980:
103981: /* Argument pIdx must either point to a 'real' named index structure,
103982: ** or an index structure allocated on the stack by bestBtreeIndex() to
103983: ** represent the rowid index that is part of every table. */
103984: assert( pIdx->zName || (pIdx->nColumn==1 && pIdx->aiColumn[0]==-1) );
103985:
103986: /* Match terms of the ORDER BY clause against columns of
103987: ** the index.
103988: **
103989: ** Note that indices have pIdx->nColumn regular columns plus
103990: ** one additional column containing the rowid. The rowid column
103991: ** of the index is also allowed to match against the ORDER BY
103992: ** clause.
103993: */
103994: for(i=j=0, pTerm=pOrderBy->a; j<nTerm && i<=pIdx->nColumn; i++){
103995: Expr *pExpr; /* The expression of the ORDER BY pTerm */
103996: CollSeq *pColl; /* The collating sequence of pExpr */
103997: int termSortOrder; /* Sort order for this term */
103998: int iColumn; /* The i-th column of the index. -1 for rowid */
103999: int iSortOrder; /* 1 for DESC, 0 for ASC on the i-th index term */
104000: const char *zColl; /* Name of the collating sequence for i-th index term */
104001:
104002: pExpr = pTerm->pExpr;
104003: if( pExpr->op!=TK_COLUMN || pExpr->iTable!=base ){
104004: /* Can not use an index sort on anything that is not a column in the
104005: ** left-most table of the FROM clause */
104006: break;
104007: }
104008: pColl = sqlite3ExprCollSeq(pParse, pExpr);
104009: if( !pColl ){
104010: pColl = db->pDfltColl;
104011: }
104012: if( pIdx->zName && i<pIdx->nColumn ){
104013: iColumn = pIdx->aiColumn[i];
104014: if( iColumn==pIdx->pTable->iPKey ){
104015: iColumn = -1;
104016: }
104017: iSortOrder = pIdx->aSortOrder[i];
104018: zColl = pIdx->azColl[i];
104019: }else{
104020: iColumn = -1;
104021: iSortOrder = 0;
104022: zColl = pColl->zName;
104023: }
104024: if( pExpr->iColumn!=iColumn || sqlite3StrICmp(pColl->zName, zColl) ){
104025: /* Term j of the ORDER BY clause does not match column i of the index */
104026: if( i<nEqCol ){
104027: /* If an index column that is constrained by == fails to match an
104028: ** ORDER BY term, that is OK. Just ignore that column of the index
104029: */
104030: continue;
104031: }else if( i==pIdx->nColumn ){
104032: /* Index column i is the rowid. All other terms match. */
104033: break;
104034: }else{
104035: /* If an index column fails to match and is not constrained by ==
104036: ** then the index cannot satisfy the ORDER BY constraint.
104037: */
104038: return 0;
104039: }
104040: }
104041: assert( pIdx->aSortOrder!=0 || iColumn==-1 );
104042: assert( pTerm->sortOrder==0 || pTerm->sortOrder==1 );
104043: assert( iSortOrder==0 || iSortOrder==1 );
104044: termSortOrder = iSortOrder ^ pTerm->sortOrder;
104045: if( i>nEqCol ){
104046: if( termSortOrder!=sortOrder ){
104047: /* Indices can only be used if all ORDER BY terms past the
104048: ** equality constraints are all either DESC or ASC. */
104049: return 0;
104050: }
104051: }else{
104052: sortOrder = termSortOrder;
104053: }
104054: j++;
104055: pTerm++;
104056: if( iColumn<0 && !referencesOtherTables(pOrderBy, pMaskSet, j, base) ){
104057: /* If the indexed column is the primary key and everything matches
104058: ** so far and none of the ORDER BY terms to the right reference other
104059: ** tables in the join, then we are assured that the index can be used
104060: ** to sort because the primary key is unique and so none of the other
104061: ** columns will make any difference
104062: */
104063: j = nTerm;
104064: }
104065: }
104066:
104067: *pbRev = sortOrder!=0;
104068: if( j>=nTerm ){
104069: /* All terms of the ORDER BY clause are covered by this index so
104070: ** this index can be used for sorting. */
104071: return 1;
104072: }
104073: if( pIdx->onError!=OE_None && i==pIdx->nColumn
104074: && (wsFlags & WHERE_COLUMN_NULL)==0
104075: && !referencesOtherTables(pOrderBy, pMaskSet, j, base) ){
104076: /* All terms of this index match some prefix of the ORDER BY clause
104077: ** and the index is UNIQUE and no terms on the tail of the ORDER BY
104078: ** clause reference other tables in a join. If this is all true then
104079: ** the order by clause is superfluous. Not that if the matching
104080: ** condition is IS NULL then the result is not necessarily unique
104081: ** even on a UNIQUE index, so disallow those cases. */
104082: return 1;
104083: }
104084: return 0;
104085: }
104086:
104087: /*
104088: ** Prepare a crude estimate of the logarithm of the input value.
104089: ** The results need not be exact. This is only used for estimating
104090: ** the total cost of performing operations with O(logN) or O(NlogN)
104091: ** complexity. Because N is just a guess, it is no great tragedy if
104092: ** logN is a little off.
104093: */
104094: static double estLog(double N){
104095: double logN = 1;
104096: double x = 10;
104097: while( N>x ){
104098: logN += 1;
104099: x *= 10;
104100: }
104101: return logN;
104102: }
104103:
104104: /*
104105: ** Two routines for printing the content of an sqlite3_index_info
104106: ** structure. Used for testing and debugging only. If neither
104107: ** SQLITE_TEST or SQLITE_DEBUG are defined, then these routines
104108: ** are no-ops.
104109: */
104110: #if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_DEBUG)
104111: static void TRACE_IDX_INPUTS(sqlite3_index_info *p){
104112: int i;
104113: if( !sqlite3WhereTrace ) return;
104114: for(i=0; i<p->nConstraint; i++){
104115: sqlite3DebugPrintf(" constraint[%d]: col=%d termid=%d op=%d usabled=%d\n",
104116: i,
104117: p->aConstraint[i].iColumn,
104118: p->aConstraint[i].iTermOffset,
104119: p->aConstraint[i].op,
104120: p->aConstraint[i].usable);
104121: }
104122: for(i=0; i<p->nOrderBy; i++){
104123: sqlite3DebugPrintf(" orderby[%d]: col=%d desc=%d\n",
104124: i,
104125: p->aOrderBy[i].iColumn,
104126: p->aOrderBy[i].desc);
104127: }
104128: }
104129: static void TRACE_IDX_OUTPUTS(sqlite3_index_info *p){
104130: int i;
104131: if( !sqlite3WhereTrace ) return;
104132: for(i=0; i<p->nConstraint; i++){
104133: sqlite3DebugPrintf(" usage[%d]: argvIdx=%d omit=%d\n",
104134: i,
104135: p->aConstraintUsage[i].argvIndex,
104136: p->aConstraintUsage[i].omit);
104137: }
104138: sqlite3DebugPrintf(" idxNum=%d\n", p->idxNum);
104139: sqlite3DebugPrintf(" idxStr=%s\n", p->idxStr);
104140: sqlite3DebugPrintf(" orderByConsumed=%d\n", p->orderByConsumed);
104141: sqlite3DebugPrintf(" estimatedCost=%g\n", p->estimatedCost);
104142: }
104143: #else
104144: #define TRACE_IDX_INPUTS(A)
104145: #define TRACE_IDX_OUTPUTS(A)
104146: #endif
104147:
104148: /*
104149: ** Required because bestIndex() is called by bestOrClauseIndex()
104150: */
104151: static void bestIndex(
104152: Parse*, WhereClause*, struct SrcList_item*,
104153: Bitmask, Bitmask, ExprList*, WhereCost*);
104154:
104155: /*
104156: ** This routine attempts to find an scanning strategy that can be used
104157: ** to optimize an 'OR' expression that is part of a WHERE clause.
104158: **
104159: ** The table associated with FROM clause term pSrc may be either a
104160: ** regular B-Tree table or a virtual table.
104161: */
104162: static void bestOrClauseIndex(
104163: Parse *pParse, /* The parsing context */
104164: WhereClause *pWC, /* The WHERE clause */
104165: struct SrcList_item *pSrc, /* The FROM clause term to search */
104166: Bitmask notReady, /* Mask of cursors not available for indexing */
104167: Bitmask notValid, /* Cursors not available for any purpose */
104168: ExprList *pOrderBy, /* The ORDER BY clause */
104169: WhereCost *pCost /* Lowest cost query plan */
104170: ){
104171: #ifndef SQLITE_OMIT_OR_OPTIMIZATION
104172: const int iCur = pSrc->iCursor; /* The cursor of the table to be accessed */
104173: const Bitmask maskSrc = getMask(pWC->pMaskSet, iCur); /* Bitmask for pSrc */
104174: WhereTerm * const pWCEnd = &pWC->a[pWC->nTerm]; /* End of pWC->a[] */
104175: WhereTerm *pTerm; /* A single term of the WHERE clause */
104176:
104177: /* The OR-clause optimization is disallowed if the INDEXED BY or
104178: ** NOT INDEXED clauses are used or if the WHERE_AND_ONLY bit is set. */
104179: if( pSrc->notIndexed || pSrc->pIndex!=0 ){
104180: return;
104181: }
104182: if( pWC->wctrlFlags & WHERE_AND_ONLY ){
104183: return;
104184: }
104185:
104186: /* Search the WHERE clause terms for a usable WO_OR term. */
104187: for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
104188: if( pTerm->eOperator==WO_OR
104189: && ((pTerm->prereqAll & ~maskSrc) & notReady)==0
104190: && (pTerm->u.pOrInfo->indexable & maskSrc)!=0
104191: ){
104192: WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc;
104193: WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm];
104194: WhereTerm *pOrTerm;
104195: int flags = WHERE_MULTI_OR;
104196: double rTotal = 0;
104197: double nRow = 0;
104198: Bitmask used = 0;
104199:
104200: for(pOrTerm=pOrWC->a; pOrTerm<pOrWCEnd; pOrTerm++){
104201: WhereCost sTermCost;
104202: WHERETRACE(("... Multi-index OR testing for term %d of %d....\n",
104203: (pOrTerm - pOrWC->a), (pTerm - pWC->a)
104204: ));
104205: if( pOrTerm->eOperator==WO_AND ){
104206: WhereClause *pAndWC = &pOrTerm->u.pAndInfo->wc;
104207: bestIndex(pParse, pAndWC, pSrc, notReady, notValid, 0, &sTermCost);
104208: }else if( pOrTerm->leftCursor==iCur ){
104209: WhereClause tempWC;
104210: tempWC.pParse = pWC->pParse;
104211: tempWC.pMaskSet = pWC->pMaskSet;
104212: tempWC.pOuter = pWC;
104213: tempWC.op = TK_AND;
104214: tempWC.a = pOrTerm;
104215: tempWC.wctrlFlags = 0;
104216: tempWC.nTerm = 1;
104217: bestIndex(pParse, &tempWC, pSrc, notReady, notValid, 0, &sTermCost);
104218: }else{
104219: continue;
104220: }
104221: rTotal += sTermCost.rCost;
104222: nRow += sTermCost.plan.nRow;
104223: used |= sTermCost.used;
104224: if( rTotal>=pCost->rCost ) break;
104225: }
104226:
104227: /* If there is an ORDER BY clause, increase the scan cost to account
104228: ** for the cost of the sort. */
104229: if( pOrderBy!=0 ){
104230: WHERETRACE(("... sorting increases OR cost %.9g to %.9g\n",
104231: rTotal, rTotal+nRow*estLog(nRow)));
104232: rTotal += nRow*estLog(nRow);
104233: }
104234:
104235: /* If the cost of scanning using this OR term for optimization is
104236: ** less than the current cost stored in pCost, replace the contents
104237: ** of pCost. */
104238: WHERETRACE(("... multi-index OR cost=%.9g nrow=%.9g\n", rTotal, nRow));
104239: if( rTotal<pCost->rCost ){
104240: pCost->rCost = rTotal;
104241: pCost->used = used;
104242: pCost->plan.nRow = nRow;
104243: pCost->plan.wsFlags = flags;
104244: pCost->plan.u.pTerm = pTerm;
104245: }
104246: }
104247: }
104248: #endif /* SQLITE_OMIT_OR_OPTIMIZATION */
104249: }
104250:
104251: #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
104252: /*
104253: ** Return TRUE if the WHERE clause term pTerm is of a form where it
104254: ** could be used with an index to access pSrc, assuming an appropriate
104255: ** index existed.
104256: */
104257: static int termCanDriveIndex(
104258: WhereTerm *pTerm, /* WHERE clause term to check */
104259: struct SrcList_item *pSrc, /* Table we are trying to access */
104260: Bitmask notReady /* Tables in outer loops of the join */
104261: ){
104262: char aff;
104263: if( pTerm->leftCursor!=pSrc->iCursor ) return 0;
104264: if( pTerm->eOperator!=WO_EQ ) return 0;
104265: if( (pTerm->prereqRight & notReady)!=0 ) return 0;
104266: aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity;
104267: if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0;
104268: return 1;
104269: }
104270: #endif
104271:
104272: #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
104273: /*
104274: ** If the query plan for pSrc specified in pCost is a full table scan
104275: ** and indexing is allows (if there is no NOT INDEXED clause) and it
104276: ** possible to construct a transient index that would perform better
104277: ** than a full table scan even when the cost of constructing the index
104278: ** is taken into account, then alter the query plan to use the
104279: ** transient index.
104280: */
104281: static void bestAutomaticIndex(
104282: Parse *pParse, /* The parsing context */
104283: WhereClause *pWC, /* The WHERE clause */
104284: struct SrcList_item *pSrc, /* The FROM clause term to search */
104285: Bitmask notReady, /* Mask of cursors that are not available */
104286: WhereCost *pCost /* Lowest cost query plan */
104287: ){
104288: double nTableRow; /* Rows in the input table */
104289: double logN; /* log(nTableRow) */
104290: double costTempIdx; /* per-query cost of the transient index */
104291: WhereTerm *pTerm; /* A single term of the WHERE clause */
104292: WhereTerm *pWCEnd; /* End of pWC->a[] */
104293: Table *pTable; /* Table tht might be indexed */
104294:
104295: if( pParse->nQueryLoop<=(double)1 ){
104296: /* There is no point in building an automatic index for a single scan */
104297: return;
104298: }
104299: if( (pParse->db->flags & SQLITE_AutoIndex)==0 ){
104300: /* Automatic indices are disabled at run-time */
104301: return;
104302: }
104303: if( (pCost->plan.wsFlags & WHERE_NOT_FULLSCAN)!=0 ){
104304: /* We already have some kind of index in use for this query. */
104305: return;
104306: }
104307: if( pSrc->notIndexed ){
104308: /* The NOT INDEXED clause appears in the SQL. */
104309: return;
104310: }
104311: if( pSrc->isCorrelated ){
104312: /* The source is a correlated sub-query. No point in indexing it. */
104313: return;
104314: }
104315:
104316: assert( pParse->nQueryLoop >= (double)1 );
104317: pTable = pSrc->pTab;
104318: nTableRow = pTable->nRowEst;
104319: logN = estLog(nTableRow);
104320: costTempIdx = 2*logN*(nTableRow/pParse->nQueryLoop + 1);
104321: if( costTempIdx>=pCost->rCost ){
104322: /* The cost of creating the transient table would be greater than
104323: ** doing the full table scan */
104324: return;
104325: }
104326:
104327: /* Search for any equality comparison term */
104328: pWCEnd = &pWC->a[pWC->nTerm];
104329: for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
104330: if( termCanDriveIndex(pTerm, pSrc, notReady) ){
104331: WHERETRACE(("auto-index reduces cost from %.1f to %.1f\n",
104332: pCost->rCost, costTempIdx));
104333: pCost->rCost = costTempIdx;
104334: pCost->plan.nRow = logN + 1;
104335: pCost->plan.wsFlags = WHERE_TEMP_INDEX;
104336: pCost->used = pTerm->prereqRight;
104337: break;
104338: }
104339: }
104340: }
104341: #else
104342: # define bestAutomaticIndex(A,B,C,D,E) /* no-op */
104343: #endif /* SQLITE_OMIT_AUTOMATIC_INDEX */
104344:
104345:
104346: #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
104347: /*
104348: ** Generate code to construct the Index object for an automatic index
104349: ** and to set up the WhereLevel object pLevel so that the code generator
104350: ** makes use of the automatic index.
104351: */
104352: static void constructAutomaticIndex(
104353: Parse *pParse, /* The parsing context */
104354: WhereClause *pWC, /* The WHERE clause */
104355: struct SrcList_item *pSrc, /* The FROM clause term to get the next index */
104356: Bitmask notReady, /* Mask of cursors that are not available */
104357: WhereLevel *pLevel /* Write new index here */
104358: ){
104359: int nColumn; /* Number of columns in the constructed index */
104360: WhereTerm *pTerm; /* A single term of the WHERE clause */
104361: WhereTerm *pWCEnd; /* End of pWC->a[] */
104362: int nByte; /* Byte of memory needed for pIdx */
104363: Index *pIdx; /* Object describing the transient index */
104364: Vdbe *v; /* Prepared statement under construction */
104365: int addrInit; /* Address of the initialization bypass jump */
104366: Table *pTable; /* The table being indexed */
104367: KeyInfo *pKeyinfo; /* Key information for the index */
104368: int addrTop; /* Top of the index fill loop */
104369: int regRecord; /* Register holding an index record */
104370: int n; /* Column counter */
104371: int i; /* Loop counter */
104372: int mxBitCol; /* Maximum column in pSrc->colUsed */
104373: CollSeq *pColl; /* Collating sequence to on a column */
104374: Bitmask idxCols; /* Bitmap of columns used for indexing */
104375: Bitmask extraCols; /* Bitmap of additional columns */
104376:
104377: /* Generate code to skip over the creation and initialization of the
104378: ** transient index on 2nd and subsequent iterations of the loop. */
104379: v = pParse->pVdbe;
104380: assert( v!=0 );
104381: addrInit = sqlite3CodeOnce(pParse);
104382:
104383: /* Count the number of columns that will be added to the index
104384: ** and used to match WHERE clause constraints */
104385: nColumn = 0;
104386: pTable = pSrc->pTab;
104387: pWCEnd = &pWC->a[pWC->nTerm];
104388: idxCols = 0;
104389: for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
104390: if( termCanDriveIndex(pTerm, pSrc, notReady) ){
104391: int iCol = pTerm->u.leftColumn;
104392: Bitmask cMask = iCol>=BMS ? ((Bitmask)1)<<(BMS-1) : ((Bitmask)1)<<iCol;
104393: testcase( iCol==BMS );
104394: testcase( iCol==BMS-1 );
104395: if( (idxCols & cMask)==0 ){
104396: nColumn++;
104397: idxCols |= cMask;
104398: }
104399: }
104400: }
104401: assert( nColumn>0 );
104402: pLevel->plan.nEq = nColumn;
104403:
104404: /* Count the number of additional columns needed to create a
104405: ** covering index. A "covering index" is an index that contains all
104406: ** columns that are needed by the query. With a covering index, the
104407: ** original table never needs to be accessed. Automatic indices must
104408: ** be a covering index because the index will not be updated if the
104409: ** original table changes and the index and table cannot both be used
104410: ** if they go out of sync.
104411: */
104412: extraCols = pSrc->colUsed & (~idxCols | (((Bitmask)1)<<(BMS-1)));
104413: mxBitCol = (pTable->nCol >= BMS-1) ? BMS-1 : pTable->nCol;
104414: testcase( pTable->nCol==BMS-1 );
104415: testcase( pTable->nCol==BMS-2 );
104416: for(i=0; i<mxBitCol; i++){
104417: if( extraCols & (((Bitmask)1)<<i) ) nColumn++;
104418: }
104419: if( pSrc->colUsed & (((Bitmask)1)<<(BMS-1)) ){
104420: nColumn += pTable->nCol - BMS + 1;
104421: }
104422: pLevel->plan.wsFlags |= WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WO_EQ;
104423:
104424: /* Construct the Index object to describe this index */
104425: nByte = sizeof(Index);
104426: nByte += nColumn*sizeof(int); /* Index.aiColumn */
104427: nByte += nColumn*sizeof(char*); /* Index.azColl */
104428: nByte += nColumn; /* Index.aSortOrder */
104429: pIdx = sqlite3DbMallocZero(pParse->db, nByte);
104430: if( pIdx==0 ) return;
104431: pLevel->plan.u.pIdx = pIdx;
104432: pIdx->azColl = (char**)&pIdx[1];
104433: pIdx->aiColumn = (int*)&pIdx->azColl[nColumn];
104434: pIdx->aSortOrder = (u8*)&pIdx->aiColumn[nColumn];
104435: pIdx->zName = "auto-index";
104436: pIdx->nColumn = nColumn;
104437: pIdx->pTable = pTable;
104438: n = 0;
104439: idxCols = 0;
104440: for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){
104441: if( termCanDriveIndex(pTerm, pSrc, notReady) ){
104442: int iCol = pTerm->u.leftColumn;
104443: Bitmask cMask = iCol>=BMS ? ((Bitmask)1)<<(BMS-1) : ((Bitmask)1)<<iCol;
104444: if( (idxCols & cMask)==0 ){
104445: Expr *pX = pTerm->pExpr;
104446: idxCols |= cMask;
104447: pIdx->aiColumn[n] = pTerm->u.leftColumn;
104448: pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
104449: pIdx->azColl[n] = ALWAYS(pColl) ? pColl->zName : "BINARY";
104450: n++;
104451: }
104452: }
104453: }
104454: assert( (u32)n==pLevel->plan.nEq );
104455:
104456: /* Add additional columns needed to make the automatic index into
104457: ** a covering index */
104458: for(i=0; i<mxBitCol; i++){
104459: if( extraCols & (((Bitmask)1)<<i) ){
104460: pIdx->aiColumn[n] = i;
104461: pIdx->azColl[n] = "BINARY";
104462: n++;
104463: }
104464: }
104465: if( pSrc->colUsed & (((Bitmask)1)<<(BMS-1)) ){
104466: for(i=BMS-1; i<pTable->nCol; i++){
104467: pIdx->aiColumn[n] = i;
104468: pIdx->azColl[n] = "BINARY";
104469: n++;
104470: }
104471: }
104472: assert( n==nColumn );
104473:
104474: /* Create the automatic index */
104475: pKeyinfo = sqlite3IndexKeyinfo(pParse, pIdx);
104476: assert( pLevel->iIdxCur>=0 );
104477: sqlite3VdbeAddOp4(v, OP_OpenAutoindex, pLevel->iIdxCur, nColumn+1, 0,
104478: (char*)pKeyinfo, P4_KEYINFO_HANDOFF);
104479: VdbeComment((v, "for %s", pTable->zName));
104480:
104481: /* Fill the automatic index with content */
104482: addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur);
104483: regRecord = sqlite3GetTempReg(pParse);
104484: sqlite3GenerateIndexKey(pParse, pIdx, pLevel->iTabCur, regRecord, 1);
104485: sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord);
104486: sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
104487: sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1);
104488: sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX);
104489: sqlite3VdbeJumpHere(v, addrTop);
104490: sqlite3ReleaseTempReg(pParse, regRecord);
104491:
104492: /* Jump here when skipping the initialization */
104493: sqlite3VdbeJumpHere(v, addrInit);
104494: }
104495: #endif /* SQLITE_OMIT_AUTOMATIC_INDEX */
104496:
104497: #ifndef SQLITE_OMIT_VIRTUALTABLE
104498: /*
104499: ** Allocate and populate an sqlite3_index_info structure. It is the
104500: ** responsibility of the caller to eventually release the structure
104501: ** by passing the pointer returned by this function to sqlite3_free().
104502: */
104503: static sqlite3_index_info *allocateIndexInfo(
104504: Parse *pParse,
104505: WhereClause *pWC,
104506: struct SrcList_item *pSrc,
104507: ExprList *pOrderBy
104508: ){
104509: int i, j;
104510: int nTerm;
104511: struct sqlite3_index_constraint *pIdxCons;
104512: struct sqlite3_index_orderby *pIdxOrderBy;
104513: struct sqlite3_index_constraint_usage *pUsage;
104514: WhereTerm *pTerm;
104515: int nOrderBy;
104516: sqlite3_index_info *pIdxInfo;
104517:
104518: WHERETRACE(("Recomputing index info for %s...\n", pSrc->pTab->zName));
104519:
104520: /* Count the number of possible WHERE clause constraints referring
104521: ** to this virtual table */
104522: for(i=nTerm=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
104523: if( pTerm->leftCursor != pSrc->iCursor ) continue;
104524: assert( (pTerm->eOperator&(pTerm->eOperator-1))==0 );
104525: testcase( pTerm->eOperator==WO_IN );
104526: testcase( pTerm->eOperator==WO_ISNULL );
104527: if( pTerm->eOperator & (WO_IN|WO_ISNULL) ) continue;
104528: if( pTerm->wtFlags & TERM_VNULL ) continue;
104529: nTerm++;
104530: }
104531:
104532: /* If the ORDER BY clause contains only columns in the current
104533: ** virtual table then allocate space for the aOrderBy part of
104534: ** the sqlite3_index_info structure.
104535: */
104536: nOrderBy = 0;
104537: if( pOrderBy ){
104538: for(i=0; i<pOrderBy->nExpr; i++){
104539: Expr *pExpr = pOrderBy->a[i].pExpr;
104540: if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
104541: }
104542: if( i==pOrderBy->nExpr ){
104543: nOrderBy = pOrderBy->nExpr;
104544: }
104545: }
104546:
104547: /* Allocate the sqlite3_index_info structure
104548: */
104549: pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
104550: + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm
104551: + sizeof(*pIdxOrderBy)*nOrderBy );
104552: if( pIdxInfo==0 ){
104553: sqlite3ErrorMsg(pParse, "out of memory");
104554: /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
104555: return 0;
104556: }
104557:
104558: /* Initialize the structure. The sqlite3_index_info structure contains
104559: ** many fields that are declared "const" to prevent xBestIndex from
104560: ** changing them. We have to do some funky casting in order to
104561: ** initialize those fields.
104562: */
104563: pIdxCons = (struct sqlite3_index_constraint*)&pIdxInfo[1];
104564: pIdxOrderBy = (struct sqlite3_index_orderby*)&pIdxCons[nTerm];
104565: pUsage = (struct sqlite3_index_constraint_usage*)&pIdxOrderBy[nOrderBy];
104566: *(int*)&pIdxInfo->nConstraint = nTerm;
104567: *(int*)&pIdxInfo->nOrderBy = nOrderBy;
104568: *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint = pIdxCons;
104569: *(struct sqlite3_index_orderby**)&pIdxInfo->aOrderBy = pIdxOrderBy;
104570: *(struct sqlite3_index_constraint_usage**)&pIdxInfo->aConstraintUsage =
104571: pUsage;
104572:
104573: for(i=j=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
104574: if( pTerm->leftCursor != pSrc->iCursor ) continue;
104575: assert( (pTerm->eOperator&(pTerm->eOperator-1))==0 );
104576: testcase( pTerm->eOperator==WO_IN );
104577: testcase( pTerm->eOperator==WO_ISNULL );
104578: if( pTerm->eOperator & (WO_IN|WO_ISNULL) ) continue;
104579: if( pTerm->wtFlags & TERM_VNULL ) continue;
104580: pIdxCons[j].iColumn = pTerm->u.leftColumn;
104581: pIdxCons[j].iTermOffset = i;
104582: pIdxCons[j].op = (u8)pTerm->eOperator;
104583: /* The direct assignment in the previous line is possible only because
104584: ** the WO_ and SQLITE_INDEX_CONSTRAINT_ codes are identical. The
104585: ** following asserts verify this fact. */
104586: assert( WO_EQ==SQLITE_INDEX_CONSTRAINT_EQ );
104587: assert( WO_LT==SQLITE_INDEX_CONSTRAINT_LT );
104588: assert( WO_LE==SQLITE_INDEX_CONSTRAINT_LE );
104589: assert( WO_GT==SQLITE_INDEX_CONSTRAINT_GT );
104590: assert( WO_GE==SQLITE_INDEX_CONSTRAINT_GE );
104591: assert( WO_MATCH==SQLITE_INDEX_CONSTRAINT_MATCH );
104592: assert( pTerm->eOperator & (WO_EQ|WO_LT|WO_LE|WO_GT|WO_GE|WO_MATCH) );
104593: j++;
104594: }
104595: for(i=0; i<nOrderBy; i++){
104596: Expr *pExpr = pOrderBy->a[i].pExpr;
104597: pIdxOrderBy[i].iColumn = pExpr->iColumn;
104598: pIdxOrderBy[i].desc = pOrderBy->a[i].sortOrder;
104599: }
104600:
104601: return pIdxInfo;
104602: }
104603:
104604: /*
104605: ** The table object reference passed as the second argument to this function
104606: ** must represent a virtual table. This function invokes the xBestIndex()
104607: ** method of the virtual table with the sqlite3_index_info pointer passed
104608: ** as the argument.
104609: **
104610: ** If an error occurs, pParse is populated with an error message and a
104611: ** non-zero value is returned. Otherwise, 0 is returned and the output
104612: ** part of the sqlite3_index_info structure is left populated.
104613: **
104614: ** Whether or not an error is returned, it is the responsibility of the
104615: ** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates
104616: ** that this is required.
104617: */
104618: static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
104619: sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
104620: int i;
104621: int rc;
104622:
104623: WHERETRACE(("xBestIndex for %s\n", pTab->zName));
104624: TRACE_IDX_INPUTS(p);
104625: rc = pVtab->pModule->xBestIndex(pVtab, p);
104626: TRACE_IDX_OUTPUTS(p);
104627:
104628: if( rc!=SQLITE_OK ){
104629: if( rc==SQLITE_NOMEM ){
104630: pParse->db->mallocFailed = 1;
104631: }else if( !pVtab->zErrMsg ){
104632: sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
104633: }else{
104634: sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
104635: }
104636: }
104637: sqlite3_free(pVtab->zErrMsg);
104638: pVtab->zErrMsg = 0;
104639:
104640: for(i=0; i<p->nConstraint; i++){
104641: if( !p->aConstraint[i].usable && p->aConstraintUsage[i].argvIndex>0 ){
104642: sqlite3ErrorMsg(pParse,
104643: "table %s: xBestIndex returned an invalid plan", pTab->zName);
104644: }
104645: }
104646:
104647: return pParse->nErr;
104648: }
104649:
104650:
104651: /*
104652: ** Compute the best index for a virtual table.
104653: **
104654: ** The best index is computed by the xBestIndex method of the virtual
104655: ** table module. This routine is really just a wrapper that sets up
104656: ** the sqlite3_index_info structure that is used to communicate with
104657: ** xBestIndex.
104658: **
104659: ** In a join, this routine might be called multiple times for the
104660: ** same virtual table. The sqlite3_index_info structure is created
104661: ** and initialized on the first invocation and reused on all subsequent
104662: ** invocations. The sqlite3_index_info structure is also used when
104663: ** code is generated to access the virtual table. The whereInfoDelete()
104664: ** routine takes care of freeing the sqlite3_index_info structure after
104665: ** everybody has finished with it.
104666: */
104667: static void bestVirtualIndex(
104668: Parse *pParse, /* The parsing context */
104669: WhereClause *pWC, /* The WHERE clause */
104670: struct SrcList_item *pSrc, /* The FROM clause term to search */
104671: Bitmask notReady, /* Mask of cursors not available for index */
104672: Bitmask notValid, /* Cursors not valid for any purpose */
104673: ExprList *pOrderBy, /* The order by clause */
104674: WhereCost *pCost, /* Lowest cost query plan */
104675: sqlite3_index_info **ppIdxInfo /* Index information passed to xBestIndex */
104676: ){
104677: Table *pTab = pSrc->pTab;
104678: sqlite3_index_info *pIdxInfo;
104679: struct sqlite3_index_constraint *pIdxCons;
104680: struct sqlite3_index_constraint_usage *pUsage;
104681: WhereTerm *pTerm;
104682: int i, j;
104683: int nOrderBy;
104684: double rCost;
104685:
104686: /* Make sure wsFlags is initialized to some sane value. Otherwise, if the
104687: ** malloc in allocateIndexInfo() fails and this function returns leaving
104688: ** wsFlags in an uninitialized state, the caller may behave unpredictably.
104689: */
104690: memset(pCost, 0, sizeof(*pCost));
104691: pCost->plan.wsFlags = WHERE_VIRTUALTABLE;
104692:
104693: /* If the sqlite3_index_info structure has not been previously
104694: ** allocated and initialized, then allocate and initialize it now.
104695: */
104696: pIdxInfo = *ppIdxInfo;
104697: if( pIdxInfo==0 ){
104698: *ppIdxInfo = pIdxInfo = allocateIndexInfo(pParse, pWC, pSrc, pOrderBy);
104699: }
104700: if( pIdxInfo==0 ){
104701: return;
104702: }
104703:
104704: /* At this point, the sqlite3_index_info structure that pIdxInfo points
104705: ** to will have been initialized, either during the current invocation or
104706: ** during some prior invocation. Now we just have to customize the
104707: ** details of pIdxInfo for the current invocation and pass it to
104708: ** xBestIndex.
104709: */
104710:
104711: /* The module name must be defined. Also, by this point there must
104712: ** be a pointer to an sqlite3_vtab structure. Otherwise
104713: ** sqlite3ViewGetColumnNames() would have picked up the error.
104714: */
104715: assert( pTab->azModuleArg && pTab->azModuleArg[0] );
104716: assert( sqlite3GetVTable(pParse->db, pTab) );
104717:
104718: /* Set the aConstraint[].usable fields and initialize all
104719: ** output variables to zero.
104720: **
104721: ** aConstraint[].usable is true for constraints where the right-hand
104722: ** side contains only references to tables to the left of the current
104723: ** table. In other words, if the constraint is of the form:
104724: **
104725: ** column = expr
104726: **
104727: ** and we are evaluating a join, then the constraint on column is
104728: ** only valid if all tables referenced in expr occur to the left
104729: ** of the table containing column.
104730: **
104731: ** The aConstraints[] array contains entries for all constraints
104732: ** on the current table. That way we only have to compute it once
104733: ** even though we might try to pick the best index multiple times.
104734: ** For each attempt at picking an index, the order of tables in the
104735: ** join might be different so we have to recompute the usable flag
104736: ** each time.
104737: */
104738: pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
104739: pUsage = pIdxInfo->aConstraintUsage;
104740: for(i=0; i<pIdxInfo->nConstraint; i++, pIdxCons++){
104741: j = pIdxCons->iTermOffset;
104742: pTerm = &pWC->a[j];
104743: pIdxCons->usable = (pTerm->prereqRight¬Ready) ? 0 : 1;
104744: }
104745: memset(pUsage, 0, sizeof(pUsage[0])*pIdxInfo->nConstraint);
104746: if( pIdxInfo->needToFreeIdxStr ){
104747: sqlite3_free(pIdxInfo->idxStr);
104748: }
104749: pIdxInfo->idxStr = 0;
104750: pIdxInfo->idxNum = 0;
104751: pIdxInfo->needToFreeIdxStr = 0;
104752: pIdxInfo->orderByConsumed = 0;
104753: /* ((double)2) In case of SQLITE_OMIT_FLOATING_POINT... */
104754: pIdxInfo->estimatedCost = SQLITE_BIG_DBL / ((double)2);
104755: nOrderBy = pIdxInfo->nOrderBy;
104756: if( !pOrderBy ){
104757: pIdxInfo->nOrderBy = 0;
104758: }
104759:
104760: if( vtabBestIndex(pParse, pTab, pIdxInfo) ){
104761: return;
104762: }
104763:
104764: pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint;
104765: for(i=0; i<pIdxInfo->nConstraint; i++){
104766: if( pUsage[i].argvIndex>0 ){
104767: pCost->used |= pWC->a[pIdxCons[i].iTermOffset].prereqRight;
104768: }
104769: }
104770:
104771: /* If there is an ORDER BY clause, and the selected virtual table index
104772: ** does not satisfy it, increase the cost of the scan accordingly. This
104773: ** matches the processing for non-virtual tables in bestBtreeIndex().
104774: */
104775: rCost = pIdxInfo->estimatedCost;
104776: if( pOrderBy && pIdxInfo->orderByConsumed==0 ){
104777: rCost += estLog(rCost)*rCost;
104778: }
104779:
104780: /* The cost is not allowed to be larger than SQLITE_BIG_DBL (the
104781: ** inital value of lowestCost in this loop. If it is, then the
104782: ** (cost<lowestCost) test below will never be true.
104783: **
104784: ** Use "(double)2" instead of "2.0" in case OMIT_FLOATING_POINT
104785: ** is defined.
104786: */
104787: if( (SQLITE_BIG_DBL/((double)2))<rCost ){
104788: pCost->rCost = (SQLITE_BIG_DBL/((double)2));
104789: }else{
104790: pCost->rCost = rCost;
104791: }
104792: pCost->plan.u.pVtabIdx = pIdxInfo;
104793: if( pIdxInfo->orderByConsumed ){
104794: pCost->plan.wsFlags |= WHERE_ORDERBY;
104795: }
104796: pCost->plan.nEq = 0;
104797: pIdxInfo->nOrderBy = nOrderBy;
104798:
104799: /* Try to find a more efficient access pattern by using multiple indexes
104800: ** to optimize an OR expression within the WHERE clause.
104801: */
104802: bestOrClauseIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost);
104803: }
104804: #endif /* SQLITE_OMIT_VIRTUALTABLE */
104805:
104806: #ifdef SQLITE_ENABLE_STAT3
104807: /*
104808: ** Estimate the location of a particular key among all keys in an
104809: ** index. Store the results in aStat as follows:
104810: **
104811: ** aStat[0] Est. number of rows less than pVal
104812: ** aStat[1] Est. number of rows equal to pVal
104813: **
104814: ** Return SQLITE_OK on success.
104815: */
104816: static int whereKeyStats(
104817: Parse *pParse, /* Database connection */
104818: Index *pIdx, /* Index to consider domain of */
104819: sqlite3_value *pVal, /* Value to consider */
104820: int roundUp, /* Round up if true. Round down if false */
104821: tRowcnt *aStat /* OUT: stats written here */
104822: ){
104823: tRowcnt n;
104824: IndexSample *aSample;
104825: int i, eType;
104826: int isEq = 0;
104827: i64 v;
104828: double r, rS;
104829:
104830: assert( roundUp==0 || roundUp==1 );
104831: assert( pIdx->nSample>0 );
104832: if( pVal==0 ) return SQLITE_ERROR;
104833: n = pIdx->aiRowEst[0];
104834: aSample = pIdx->aSample;
104835: eType = sqlite3_value_type(pVal);
104836:
104837: if( eType==SQLITE_INTEGER ){
104838: v = sqlite3_value_int64(pVal);
104839: r = (i64)v;
104840: for(i=0; i<pIdx->nSample; i++){
104841: if( aSample[i].eType==SQLITE_NULL ) continue;
104842: if( aSample[i].eType>=SQLITE_TEXT ) break;
104843: if( aSample[i].eType==SQLITE_INTEGER ){
104844: if( aSample[i].u.i>=v ){
104845: isEq = aSample[i].u.i==v;
104846: break;
104847: }
104848: }else{
104849: assert( aSample[i].eType==SQLITE_FLOAT );
104850: if( aSample[i].u.r>=r ){
104851: isEq = aSample[i].u.r==r;
104852: break;
104853: }
104854: }
104855: }
104856: }else if( eType==SQLITE_FLOAT ){
104857: r = sqlite3_value_double(pVal);
104858: for(i=0; i<pIdx->nSample; i++){
104859: if( aSample[i].eType==SQLITE_NULL ) continue;
104860: if( aSample[i].eType>=SQLITE_TEXT ) break;
104861: if( aSample[i].eType==SQLITE_FLOAT ){
104862: rS = aSample[i].u.r;
104863: }else{
104864: rS = aSample[i].u.i;
104865: }
104866: if( rS>=r ){
104867: isEq = rS==r;
104868: break;
104869: }
104870: }
104871: }else if( eType==SQLITE_NULL ){
104872: i = 0;
104873: if( aSample[0].eType==SQLITE_NULL ) isEq = 1;
104874: }else{
104875: assert( eType==SQLITE_TEXT || eType==SQLITE_BLOB );
104876: for(i=0; i<pIdx->nSample; i++){
104877: if( aSample[i].eType==SQLITE_TEXT || aSample[i].eType==SQLITE_BLOB ){
104878: break;
104879: }
104880: }
104881: if( i<pIdx->nSample ){
104882: sqlite3 *db = pParse->db;
104883: CollSeq *pColl;
104884: const u8 *z;
104885: if( eType==SQLITE_BLOB ){
104886: z = (const u8 *)sqlite3_value_blob(pVal);
104887: pColl = db->pDfltColl;
104888: assert( pColl->enc==SQLITE_UTF8 );
104889: }else{
104890: pColl = sqlite3GetCollSeq(db, SQLITE_UTF8, 0, *pIdx->azColl);
104891: if( pColl==0 ){
104892: sqlite3ErrorMsg(pParse, "no such collation sequence: %s",
104893: *pIdx->azColl);
104894: return SQLITE_ERROR;
104895: }
104896: z = (const u8 *)sqlite3ValueText(pVal, pColl->enc);
104897: if( !z ){
104898: return SQLITE_NOMEM;
104899: }
104900: assert( z && pColl && pColl->xCmp );
104901: }
104902: n = sqlite3ValueBytes(pVal, pColl->enc);
104903:
104904: for(; i<pIdx->nSample; i++){
104905: int c;
104906: int eSampletype = aSample[i].eType;
104907: if( eSampletype<eType ) continue;
104908: if( eSampletype!=eType ) break;
104909: #ifndef SQLITE_OMIT_UTF16
104910: if( pColl->enc!=SQLITE_UTF8 ){
104911: int nSample;
104912: char *zSample = sqlite3Utf8to16(
104913: db, pColl->enc, aSample[i].u.z, aSample[i].nByte, &nSample
104914: );
104915: if( !zSample ){
104916: assert( db->mallocFailed );
104917: return SQLITE_NOMEM;
104918: }
104919: c = pColl->xCmp(pColl->pUser, nSample, zSample, n, z);
104920: sqlite3DbFree(db, zSample);
104921: }else
104922: #endif
104923: {
104924: c = pColl->xCmp(pColl->pUser, aSample[i].nByte, aSample[i].u.z, n, z);
104925: }
104926: if( c>=0 ){
104927: if( c==0 ) isEq = 1;
104928: break;
104929: }
104930: }
104931: }
104932: }
104933:
104934: /* At this point, aSample[i] is the first sample that is greater than
104935: ** or equal to pVal. Or if i==pIdx->nSample, then all samples are less
104936: ** than pVal. If aSample[i]==pVal, then isEq==1.
104937: */
104938: if( isEq ){
104939: assert( i<pIdx->nSample );
104940: aStat[0] = aSample[i].nLt;
104941: aStat[1] = aSample[i].nEq;
104942: }else{
104943: tRowcnt iLower, iUpper, iGap;
104944: if( i==0 ){
104945: iLower = 0;
104946: iUpper = aSample[0].nLt;
104947: }else{
104948: iUpper = i>=pIdx->nSample ? n : aSample[i].nLt;
104949: iLower = aSample[i-1].nEq + aSample[i-1].nLt;
104950: }
104951: aStat[1] = pIdx->avgEq;
104952: if( iLower>=iUpper ){
104953: iGap = 0;
104954: }else{
104955: iGap = iUpper - iLower;
104956: }
104957: if( roundUp ){
104958: iGap = (iGap*2)/3;
104959: }else{
104960: iGap = iGap/3;
104961: }
104962: aStat[0] = iLower + iGap;
104963: }
104964: return SQLITE_OK;
104965: }
104966: #endif /* SQLITE_ENABLE_STAT3 */
104967:
104968: /*
104969: ** If expression pExpr represents a literal value, set *pp to point to
104970: ** an sqlite3_value structure containing the same value, with affinity
104971: ** aff applied to it, before returning. It is the responsibility of the
104972: ** caller to eventually release this structure by passing it to
104973: ** sqlite3ValueFree().
104974: **
104975: ** If the current parse is a recompile (sqlite3Reprepare()) and pExpr
104976: ** is an SQL variable that currently has a non-NULL value bound to it,
104977: ** create an sqlite3_value structure containing this value, again with
104978: ** affinity aff applied to it, instead.
104979: **
104980: ** If neither of the above apply, set *pp to NULL.
104981: **
104982: ** If an error occurs, return an error code. Otherwise, SQLITE_OK.
104983: */
104984: #ifdef SQLITE_ENABLE_STAT3
104985: static int valueFromExpr(
104986: Parse *pParse,
104987: Expr *pExpr,
104988: u8 aff,
104989: sqlite3_value **pp
104990: ){
104991: if( pExpr->op==TK_VARIABLE
104992: || (pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE)
104993: ){
104994: int iVar = pExpr->iColumn;
104995: sqlite3VdbeSetVarmask(pParse->pVdbe, iVar);
104996: *pp = sqlite3VdbeGetValue(pParse->pReprepare, iVar, aff);
104997: return SQLITE_OK;
104998: }
104999: return sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, aff, pp);
105000: }
105001: #endif
105002:
105003: /*
105004: ** This function is used to estimate the number of rows that will be visited
105005: ** by scanning an index for a range of values. The range may have an upper
105006: ** bound, a lower bound, or both. The WHERE clause terms that set the upper
105007: ** and lower bounds are represented by pLower and pUpper respectively. For
105008: ** example, assuming that index p is on t1(a):
105009: **
105010: ** ... FROM t1 WHERE a > ? AND a < ? ...
105011: ** |_____| |_____|
105012: ** | |
105013: ** pLower pUpper
105014: **
105015: ** If either of the upper or lower bound is not present, then NULL is passed in
105016: ** place of the corresponding WhereTerm.
105017: **
105018: ** The nEq parameter is passed the index of the index column subject to the
105019: ** range constraint. Or, equivalently, the number of equality constraints
105020: ** optimized by the proposed index scan. For example, assuming index p is
105021: ** on t1(a, b), and the SQL query is:
105022: **
105023: ** ... FROM t1 WHERE a = ? AND b > ? AND b < ? ...
105024: **
105025: ** then nEq should be passed the value 1 (as the range restricted column,
105026: ** b, is the second left-most column of the index). Or, if the query is:
105027: **
105028: ** ... FROM t1 WHERE a > ? AND a < ? ...
105029: **
105030: ** then nEq should be passed 0.
105031: **
105032: ** The returned value is an integer divisor to reduce the estimated
105033: ** search space. A return value of 1 means that range constraints are
105034: ** no help at all. A return value of 2 means range constraints are
105035: ** expected to reduce the search space by half. And so forth...
105036: **
105037: ** In the absence of sqlite_stat3 ANALYZE data, each range inequality
105038: ** reduces the search space by a factor of 4. Hence a single constraint (x>?)
105039: ** results in a return of 4 and a range constraint (x>? AND x<?) results
105040: ** in a return of 16.
105041: */
105042: static int whereRangeScanEst(
105043: Parse *pParse, /* Parsing & code generating context */
105044: Index *p, /* The index containing the range-compared column; "x" */
105045: int nEq, /* index into p->aCol[] of the range-compared column */
105046: WhereTerm *pLower, /* Lower bound on the range. ex: "x>123" Might be NULL */
105047: WhereTerm *pUpper, /* Upper bound on the range. ex: "x<455" Might be NULL */
105048: double *pRangeDiv /* OUT: Reduce search space by this divisor */
105049: ){
105050: int rc = SQLITE_OK;
105051:
105052: #ifdef SQLITE_ENABLE_STAT3
105053:
105054: if( nEq==0 && p->nSample ){
105055: sqlite3_value *pRangeVal;
105056: tRowcnt iLower = 0;
105057: tRowcnt iUpper = p->aiRowEst[0];
105058: tRowcnt a[2];
105059: u8 aff = p->pTable->aCol[p->aiColumn[0]].affinity;
105060:
105061: if( pLower ){
105062: Expr *pExpr = pLower->pExpr->pRight;
105063: rc = valueFromExpr(pParse, pExpr, aff, &pRangeVal);
105064: assert( pLower->eOperator==WO_GT || pLower->eOperator==WO_GE );
105065: if( rc==SQLITE_OK
105066: && whereKeyStats(pParse, p, pRangeVal, 0, a)==SQLITE_OK
105067: ){
105068: iLower = a[0];
105069: if( pLower->eOperator==WO_GT ) iLower += a[1];
105070: }
105071: sqlite3ValueFree(pRangeVal);
105072: }
105073: if( rc==SQLITE_OK && pUpper ){
105074: Expr *pExpr = pUpper->pExpr->pRight;
105075: rc = valueFromExpr(pParse, pExpr, aff, &pRangeVal);
105076: assert( pUpper->eOperator==WO_LT || pUpper->eOperator==WO_LE );
105077: if( rc==SQLITE_OK
105078: && whereKeyStats(pParse, p, pRangeVal, 1, a)==SQLITE_OK
105079: ){
105080: iUpper = a[0];
105081: if( pUpper->eOperator==WO_LE ) iUpper += a[1];
105082: }
105083: sqlite3ValueFree(pRangeVal);
105084: }
105085: if( rc==SQLITE_OK ){
105086: if( iUpper<=iLower ){
105087: *pRangeDiv = (double)p->aiRowEst[0];
105088: }else{
105089: *pRangeDiv = (double)p->aiRowEst[0]/(double)(iUpper - iLower);
105090: }
105091: WHERETRACE(("range scan regions: %u..%u div=%g\n",
105092: (u32)iLower, (u32)iUpper, *pRangeDiv));
105093: return SQLITE_OK;
105094: }
105095: }
105096: #else
105097: UNUSED_PARAMETER(pParse);
105098: UNUSED_PARAMETER(p);
105099: UNUSED_PARAMETER(nEq);
105100: #endif
105101: assert( pLower || pUpper );
105102: *pRangeDiv = (double)1;
105103: if( pLower && (pLower->wtFlags & TERM_VNULL)==0 ) *pRangeDiv *= (double)4;
105104: if( pUpper ) *pRangeDiv *= (double)4;
105105: return rc;
105106: }
105107:
105108: #ifdef SQLITE_ENABLE_STAT3
105109: /*
105110: ** Estimate the number of rows that will be returned based on
105111: ** an equality constraint x=VALUE and where that VALUE occurs in
105112: ** the histogram data. This only works when x is the left-most
105113: ** column of an index and sqlite_stat3 histogram data is available
105114: ** for that index. When pExpr==NULL that means the constraint is
105115: ** "x IS NULL" instead of "x=VALUE".
105116: **
105117: ** Write the estimated row count into *pnRow and return SQLITE_OK.
105118: ** If unable to make an estimate, leave *pnRow unchanged and return
105119: ** non-zero.
105120: **
105121: ** This routine can fail if it is unable to load a collating sequence
105122: ** required for string comparison, or if unable to allocate memory
105123: ** for a UTF conversion required for comparison. The error is stored
105124: ** in the pParse structure.
105125: */
105126: static int whereEqualScanEst(
105127: Parse *pParse, /* Parsing & code generating context */
105128: Index *p, /* The index whose left-most column is pTerm */
105129: Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */
105130: double *pnRow /* Write the revised row estimate here */
105131: ){
105132: sqlite3_value *pRhs = 0; /* VALUE on right-hand side of pTerm */
105133: u8 aff; /* Column affinity */
105134: int rc; /* Subfunction return code */
105135: tRowcnt a[2]; /* Statistics */
105136:
105137: assert( p->aSample!=0 );
105138: assert( p->nSample>0 );
105139: aff = p->pTable->aCol[p->aiColumn[0]].affinity;
105140: if( pExpr ){
105141: rc = valueFromExpr(pParse, pExpr, aff, &pRhs);
105142: if( rc ) goto whereEqualScanEst_cancel;
105143: }else{
105144: pRhs = sqlite3ValueNew(pParse->db);
105145: }
105146: if( pRhs==0 ) return SQLITE_NOTFOUND;
105147: rc = whereKeyStats(pParse, p, pRhs, 0, a);
105148: if( rc==SQLITE_OK ){
105149: WHERETRACE(("equality scan regions: %d\n", (int)a[1]));
105150: *pnRow = a[1];
105151: }
105152: whereEqualScanEst_cancel:
105153: sqlite3ValueFree(pRhs);
105154: return rc;
105155: }
105156: #endif /* defined(SQLITE_ENABLE_STAT3) */
105157:
105158: #ifdef SQLITE_ENABLE_STAT3
105159: /*
105160: ** Estimate the number of rows that will be returned based on
105161: ** an IN constraint where the right-hand side of the IN operator
105162: ** is a list of values. Example:
105163: **
105164: ** WHERE x IN (1,2,3,4)
105165: **
105166: ** Write the estimated row count into *pnRow and return SQLITE_OK.
105167: ** If unable to make an estimate, leave *pnRow unchanged and return
105168: ** non-zero.
105169: **
105170: ** This routine can fail if it is unable to load a collating sequence
105171: ** required for string comparison, or if unable to allocate memory
105172: ** for a UTF conversion required for comparison. The error is stored
105173: ** in the pParse structure.
105174: */
105175: static int whereInScanEst(
105176: Parse *pParse, /* Parsing & code generating context */
105177: Index *p, /* The index whose left-most column is pTerm */
105178: ExprList *pList, /* The value list on the RHS of "x IN (v1,v2,v3,...)" */
105179: double *pnRow /* Write the revised row estimate here */
105180: ){
105181: int rc = SQLITE_OK; /* Subfunction return code */
105182: double nEst; /* Number of rows for a single term */
105183: double nRowEst = (double)0; /* New estimate of the number of rows */
105184: int i; /* Loop counter */
105185:
105186: assert( p->aSample!=0 );
105187: for(i=0; rc==SQLITE_OK && i<pList->nExpr; i++){
105188: nEst = p->aiRowEst[0];
105189: rc = whereEqualScanEst(pParse, p, pList->a[i].pExpr, &nEst);
105190: nRowEst += nEst;
105191: }
105192: if( rc==SQLITE_OK ){
105193: if( nRowEst > p->aiRowEst[0] ) nRowEst = p->aiRowEst[0];
105194: *pnRow = nRowEst;
105195: WHERETRACE(("IN row estimate: est=%g\n", nRowEst));
105196: }
105197: return rc;
105198: }
105199: #endif /* defined(SQLITE_ENABLE_STAT3) */
105200:
105201:
105202: /*
105203: ** Find the best query plan for accessing a particular table. Write the
105204: ** best query plan and its cost into the WhereCost object supplied as the
105205: ** last parameter.
105206: **
105207: ** The lowest cost plan wins. The cost is an estimate of the amount of
105208: ** CPU and disk I/O needed to process the requested result.
105209: ** Factors that influence cost include:
105210: **
105211: ** * The estimated number of rows that will be retrieved. (The
105212: ** fewer the better.)
105213: **
105214: ** * Whether or not sorting must occur.
105215: **
105216: ** * Whether or not there must be separate lookups in the
105217: ** index and in the main table.
105218: **
105219: ** If there was an INDEXED BY clause (pSrc->pIndex) attached to the table in
105220: ** the SQL statement, then this function only considers plans using the
105221: ** named index. If no such plan is found, then the returned cost is
105222: ** SQLITE_BIG_DBL. If a plan is found that uses the named index,
105223: ** then the cost is calculated in the usual way.
105224: **
105225: ** If a NOT INDEXED clause (pSrc->notIndexed!=0) was attached to the table
105226: ** in the SELECT statement, then no indexes are considered. However, the
105227: ** selected plan may still take advantage of the built-in rowid primary key
105228: ** index.
105229: */
105230: static void bestBtreeIndex(
105231: Parse *pParse, /* The parsing context */
105232: WhereClause *pWC, /* The WHERE clause */
105233: struct SrcList_item *pSrc, /* The FROM clause term to search */
105234: Bitmask notReady, /* Mask of cursors not available for indexing */
105235: Bitmask notValid, /* Cursors not available for any purpose */
105236: ExprList *pOrderBy, /* The ORDER BY clause */
105237: ExprList *pDistinct, /* The select-list if query is DISTINCT */
105238: WhereCost *pCost /* Lowest cost query plan */
105239: ){
105240: int iCur = pSrc->iCursor; /* The cursor of the table to be accessed */
105241: Index *pProbe; /* An index we are evaluating */
105242: Index *pIdx; /* Copy of pProbe, or zero for IPK index */
105243: int eqTermMask; /* Current mask of valid equality operators */
105244: int idxEqTermMask; /* Index mask of valid equality operators */
105245: Index sPk; /* A fake index object for the primary key */
105246: tRowcnt aiRowEstPk[2]; /* The aiRowEst[] value for the sPk index */
105247: int aiColumnPk = -1; /* The aColumn[] value for the sPk index */
105248: int wsFlagMask; /* Allowed flags in pCost->plan.wsFlag */
105249:
105250: /* Initialize the cost to a worst-case value */
105251: memset(pCost, 0, sizeof(*pCost));
105252: pCost->rCost = SQLITE_BIG_DBL;
105253:
105254: /* If the pSrc table is the right table of a LEFT JOIN then we may not
105255: ** use an index to satisfy IS NULL constraints on that table. This is
105256: ** because columns might end up being NULL if the table does not match -
105257: ** a circumstance which the index cannot help us discover. Ticket #2177.
105258: */
105259: if( pSrc->jointype & JT_LEFT ){
105260: idxEqTermMask = WO_EQ|WO_IN;
105261: }else{
105262: idxEqTermMask = WO_EQ|WO_IN|WO_ISNULL;
105263: }
105264:
105265: if( pSrc->pIndex ){
105266: /* An INDEXED BY clause specifies a particular index to use */
105267: pIdx = pProbe = pSrc->pIndex;
105268: wsFlagMask = ~(WHERE_ROWID_EQ|WHERE_ROWID_RANGE);
105269: eqTermMask = idxEqTermMask;
105270: }else{
105271: /* There is no INDEXED BY clause. Create a fake Index object in local
105272: ** variable sPk to represent the rowid primary key index. Make this
105273: ** fake index the first in a chain of Index objects with all of the real
105274: ** indices to follow */
105275: Index *pFirst; /* First of real indices on the table */
105276: memset(&sPk, 0, sizeof(Index));
105277: sPk.nColumn = 1;
105278: sPk.aiColumn = &aiColumnPk;
105279: sPk.aiRowEst = aiRowEstPk;
105280: sPk.onError = OE_Replace;
105281: sPk.pTable = pSrc->pTab;
105282: aiRowEstPk[0] = pSrc->pTab->nRowEst;
105283: aiRowEstPk[1] = 1;
105284: pFirst = pSrc->pTab->pIndex;
105285: if( pSrc->notIndexed==0 ){
105286: /* The real indices of the table are only considered if the
105287: ** NOT INDEXED qualifier is omitted from the FROM clause */
105288: sPk.pNext = pFirst;
105289: }
105290: pProbe = &sPk;
105291: wsFlagMask = ~(
105292: WHERE_COLUMN_IN|WHERE_COLUMN_EQ|WHERE_COLUMN_NULL|WHERE_COLUMN_RANGE
105293: );
105294: eqTermMask = WO_EQ|WO_IN;
105295: pIdx = 0;
105296: }
105297:
105298: /* Loop over all indices looking for the best one to use
105299: */
105300: for(; pProbe; pIdx=pProbe=pProbe->pNext){
105301: const tRowcnt * const aiRowEst = pProbe->aiRowEst;
105302: double cost; /* Cost of using pProbe */
105303: double nRow; /* Estimated number of rows in result set */
105304: double log10N = (double)1; /* base-10 logarithm of nRow (inexact) */
105305: int rev; /* True to scan in reverse order */
105306: int wsFlags = 0;
105307: Bitmask used = 0;
105308:
105309: /* The following variables are populated based on the properties of
105310: ** index being evaluated. They are then used to determine the expected
105311: ** cost and number of rows returned.
105312: **
105313: ** nEq:
105314: ** Number of equality terms that can be implemented using the index.
105315: ** In other words, the number of initial fields in the index that
105316: ** are used in == or IN or NOT NULL constraints of the WHERE clause.
105317: **
105318: ** nInMul:
105319: ** The "in-multiplier". This is an estimate of how many seek operations
105320: ** SQLite must perform on the index in question. For example, if the
105321: ** WHERE clause is:
105322: **
105323: ** WHERE a IN (1, 2, 3) AND b IN (4, 5, 6)
105324: **
105325: ** SQLite must perform 9 lookups on an index on (a, b), so nInMul is
105326: ** set to 9. Given the same schema and either of the following WHERE
105327: ** clauses:
105328: **
105329: ** WHERE a = 1
105330: ** WHERE a >= 2
105331: **
105332: ** nInMul is set to 1.
105333: **
105334: ** If there exists a WHERE term of the form "x IN (SELECT ...)", then
105335: ** the sub-select is assumed to return 25 rows for the purposes of
105336: ** determining nInMul.
105337: **
105338: ** bInEst:
105339: ** Set to true if there was at least one "x IN (SELECT ...)" term used
105340: ** in determining the value of nInMul. Note that the RHS of the
105341: ** IN operator must be a SELECT, not a value list, for this variable
105342: ** to be true.
105343: **
105344: ** rangeDiv:
105345: ** An estimate of a divisor by which to reduce the search space due
105346: ** to inequality constraints. In the absence of sqlite_stat3 ANALYZE
105347: ** data, a single inequality reduces the search space to 1/4rd its
105348: ** original size (rangeDiv==4). Two inequalities reduce the search
105349: ** space to 1/16th of its original size (rangeDiv==16).
105350: **
105351: ** bSort:
105352: ** Boolean. True if there is an ORDER BY clause that will require an
105353: ** external sort (i.e. scanning the index being evaluated will not
105354: ** correctly order records).
105355: **
105356: ** bLookup:
105357: ** Boolean. True if a table lookup is required for each index entry
105358: ** visited. In other words, true if this is not a covering index.
105359: ** This is always false for the rowid primary key index of a table.
105360: ** For other indexes, it is true unless all the columns of the table
105361: ** used by the SELECT statement are present in the index (such an
105362: ** index is sometimes described as a covering index).
105363: ** For example, given the index on (a, b), the second of the following
105364: ** two queries requires table b-tree lookups in order to find the value
105365: ** of column c, but the first does not because columns a and b are
105366: ** both available in the index.
105367: **
105368: ** SELECT a, b FROM tbl WHERE a = 1;
105369: ** SELECT a, b, c FROM tbl WHERE a = 1;
105370: */
105371: int nEq; /* Number of == or IN terms matching index */
105372: int bInEst = 0; /* True if "x IN (SELECT...)" seen */
105373: int nInMul = 1; /* Number of distinct equalities to lookup */
105374: double rangeDiv = (double)1; /* Estimated reduction in search space */
105375: int nBound = 0; /* Number of range constraints seen */
105376: int bSort = !!pOrderBy; /* True if external sort required */
105377: int bDist = !!pDistinct; /* True if index cannot help with DISTINCT */
105378: int bLookup = 0; /* True if not a covering index */
105379: WhereTerm *pTerm; /* A single term of the WHERE clause */
105380: #ifdef SQLITE_ENABLE_STAT3
105381: WhereTerm *pFirstTerm = 0; /* First term matching the index */
105382: #endif
105383:
105384: /* Determine the values of nEq and nInMul */
105385: for(nEq=0; nEq<pProbe->nColumn; nEq++){
105386: int j = pProbe->aiColumn[nEq];
105387: pTerm = findTerm(pWC, iCur, j, notReady, eqTermMask, pIdx);
105388: if( pTerm==0 ) break;
105389: wsFlags |= (WHERE_COLUMN_EQ|WHERE_ROWID_EQ);
105390: testcase( pTerm->pWC!=pWC );
105391: if( pTerm->eOperator & WO_IN ){
105392: Expr *pExpr = pTerm->pExpr;
105393: wsFlags |= WHERE_COLUMN_IN;
105394: if( ExprHasProperty(pExpr, EP_xIsSelect) ){
105395: /* "x IN (SELECT ...)": Assume the SELECT returns 25 rows */
105396: nInMul *= 25;
105397: bInEst = 1;
105398: }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){
105399: /* "x IN (value, value, ...)" */
105400: nInMul *= pExpr->x.pList->nExpr;
105401: }
105402: }else if( pTerm->eOperator & WO_ISNULL ){
105403: wsFlags |= WHERE_COLUMN_NULL;
105404: }
105405: #ifdef SQLITE_ENABLE_STAT3
105406: if( nEq==0 && pProbe->aSample ) pFirstTerm = pTerm;
105407: #endif
105408: used |= pTerm->prereqRight;
105409: }
105410:
105411: /* If the index being considered is UNIQUE, and there is an equality
105412: ** constraint for all columns in the index, then this search will find
105413: ** at most a single row. In this case set the WHERE_UNIQUE flag to
105414: ** indicate this to the caller.
105415: **
105416: ** Otherwise, if the search may find more than one row, test to see if
105417: ** there is a range constraint on indexed column (nEq+1) that can be
105418: ** optimized using the index.
105419: */
105420: if( nEq==pProbe->nColumn && pProbe->onError!=OE_None ){
105421: testcase( wsFlags & WHERE_COLUMN_IN );
105422: testcase( wsFlags & WHERE_COLUMN_NULL );
105423: if( (wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_NULL))==0 ){
105424: wsFlags |= WHERE_UNIQUE;
105425: }
105426: }else if( pProbe->bUnordered==0 ){
105427: int j = (nEq==pProbe->nColumn ? -1 : pProbe->aiColumn[nEq]);
105428: if( findTerm(pWC, iCur, j, notReady, WO_LT|WO_LE|WO_GT|WO_GE, pIdx) ){
105429: WhereTerm *pTop = findTerm(pWC, iCur, j, notReady, WO_LT|WO_LE, pIdx);
105430: WhereTerm *pBtm = findTerm(pWC, iCur, j, notReady, WO_GT|WO_GE, pIdx);
105431: whereRangeScanEst(pParse, pProbe, nEq, pBtm, pTop, &rangeDiv);
105432: if( pTop ){
105433: nBound = 1;
105434: wsFlags |= WHERE_TOP_LIMIT;
105435: used |= pTop->prereqRight;
105436: testcase( pTop->pWC!=pWC );
105437: }
105438: if( pBtm ){
105439: nBound++;
105440: wsFlags |= WHERE_BTM_LIMIT;
105441: used |= pBtm->prereqRight;
105442: testcase( pBtm->pWC!=pWC );
105443: }
105444: wsFlags |= (WHERE_COLUMN_RANGE|WHERE_ROWID_RANGE);
105445: }
105446: }
105447:
105448: /* If there is an ORDER BY clause and the index being considered will
105449: ** naturally scan rows in the required order, set the appropriate flags
105450: ** in wsFlags. Otherwise, if there is an ORDER BY clause but the index
105451: ** will scan rows in a different order, set the bSort variable. */
105452: if( isSortingIndex(
105453: pParse, pWC->pMaskSet, pProbe, iCur, pOrderBy, nEq, wsFlags, &rev)
105454: ){
105455: bSort = 0;
105456: wsFlags |= WHERE_ROWID_RANGE|WHERE_COLUMN_RANGE|WHERE_ORDERBY;
105457: wsFlags |= (rev ? WHERE_REVERSE : 0);
105458: }
105459:
105460: /* If there is a DISTINCT qualifier and this index will scan rows in
105461: ** order of the DISTINCT expressions, clear bDist and set the appropriate
105462: ** flags in wsFlags. */
105463: if( isDistinctIndex(pParse, pWC, pProbe, iCur, pDistinct, nEq) ){
105464: bDist = 0;
105465: wsFlags |= WHERE_ROWID_RANGE|WHERE_COLUMN_RANGE|WHERE_DISTINCT;
105466: }
105467:
105468: /* If currently calculating the cost of using an index (not the IPK
105469: ** index), determine if all required column data may be obtained without
105470: ** using the main table (i.e. if the index is a covering
105471: ** index for this query). If it is, set the WHERE_IDX_ONLY flag in
105472: ** wsFlags. Otherwise, set the bLookup variable to true. */
105473: if( pIdx && wsFlags ){
105474: Bitmask m = pSrc->colUsed;
105475: int j;
105476: for(j=0; j<pIdx->nColumn; j++){
105477: int x = pIdx->aiColumn[j];
105478: if( x<BMS-1 ){
105479: m &= ~(((Bitmask)1)<<x);
105480: }
105481: }
105482: if( m==0 ){
105483: wsFlags |= WHERE_IDX_ONLY;
105484: }else{
105485: bLookup = 1;
105486: }
105487: }
105488:
105489: /*
105490: ** Estimate the number of rows of output. For an "x IN (SELECT...)"
105491: ** constraint, do not let the estimate exceed half the rows in the table.
105492: */
105493: nRow = (double)(aiRowEst[nEq] * nInMul);
105494: if( bInEst && nRow*2>aiRowEst[0] ){
105495: nRow = aiRowEst[0]/2;
105496: nInMul = (int)(nRow / aiRowEst[nEq]);
105497: }
105498:
105499: #ifdef SQLITE_ENABLE_STAT3
105500: /* If the constraint is of the form x=VALUE or x IN (E1,E2,...)
105501: ** and we do not think that values of x are unique and if histogram
105502: ** data is available for column x, then it might be possible
105503: ** to get a better estimate on the number of rows based on
105504: ** VALUE and how common that value is according to the histogram.
105505: */
105506: if( nRow>(double)1 && nEq==1 && pFirstTerm!=0 && aiRowEst[1]>1 ){
105507: assert( (pFirstTerm->eOperator & (WO_EQ|WO_ISNULL|WO_IN))!=0 );
105508: if( pFirstTerm->eOperator & (WO_EQ|WO_ISNULL) ){
105509: testcase( pFirstTerm->eOperator==WO_EQ );
105510: testcase( pFirstTerm->eOperator==WO_ISNULL );
105511: whereEqualScanEst(pParse, pProbe, pFirstTerm->pExpr->pRight, &nRow);
105512: }else if( bInEst==0 ){
105513: assert( pFirstTerm->eOperator==WO_IN );
105514: whereInScanEst(pParse, pProbe, pFirstTerm->pExpr->x.pList, &nRow);
105515: }
105516: }
105517: #endif /* SQLITE_ENABLE_STAT3 */
105518:
105519: /* Adjust the number of output rows and downward to reflect rows
105520: ** that are excluded by range constraints.
105521: */
105522: nRow = nRow/rangeDiv;
105523: if( nRow<1 ) nRow = 1;
105524:
105525: /* Experiments run on real SQLite databases show that the time needed
105526: ** to do a binary search to locate a row in a table or index is roughly
105527: ** log10(N) times the time to move from one row to the next row within
105528: ** a table or index. The actual times can vary, with the size of
105529: ** records being an important factor. Both moves and searches are
105530: ** slower with larger records, presumably because fewer records fit
105531: ** on one page and hence more pages have to be fetched.
105532: **
105533: ** The ANALYZE command and the sqlite_stat1 and sqlite_stat3 tables do
105534: ** not give us data on the relative sizes of table and index records.
105535: ** So this computation assumes table records are about twice as big
105536: ** as index records
105537: */
105538: if( (wsFlags & WHERE_NOT_FULLSCAN)==0 ){
105539: /* The cost of a full table scan is a number of move operations equal
105540: ** to the number of rows in the table.
105541: **
105542: ** We add an additional 4x penalty to full table scans. This causes
105543: ** the cost function to err on the side of choosing an index over
105544: ** choosing a full scan. This 4x full-scan penalty is an arguable
105545: ** decision and one which we expect to revisit in the future. But
105546: ** it seems to be working well enough at the moment.
105547: */
105548: cost = aiRowEst[0]*4;
105549: }else{
105550: log10N = estLog(aiRowEst[0]);
105551: cost = nRow;
105552: if( pIdx ){
105553: if( bLookup ){
105554: /* For an index lookup followed by a table lookup:
105555: ** nInMul index searches to find the start of each index range
105556: ** + nRow steps through the index
105557: ** + nRow table searches to lookup the table entry using the rowid
105558: */
105559: cost += (nInMul + nRow)*log10N;
105560: }else{
105561: /* For a covering index:
105562: ** nInMul index searches to find the initial entry
105563: ** + nRow steps through the index
105564: */
105565: cost += nInMul*log10N;
105566: }
105567: }else{
105568: /* For a rowid primary key lookup:
105569: ** nInMult table searches to find the initial entry for each range
105570: ** + nRow steps through the table
105571: */
105572: cost += nInMul*log10N;
105573: }
105574: }
105575:
105576: /* Add in the estimated cost of sorting the result. Actual experimental
105577: ** measurements of sorting performance in SQLite show that sorting time
105578: ** adds C*N*log10(N) to the cost, where N is the number of rows to be
105579: ** sorted and C is a factor between 1.95 and 4.3. We will split the
105580: ** difference and select C of 3.0.
105581: */
105582: if( bSort ){
105583: cost += nRow*estLog(nRow)*3;
105584: }
105585: if( bDist ){
105586: cost += nRow*estLog(nRow)*3;
105587: }
105588:
105589: /**** Cost of using this index has now been computed ****/
105590:
105591: /* If there are additional constraints on this table that cannot
105592: ** be used with the current index, but which might lower the number
105593: ** of output rows, adjust the nRow value accordingly. This only
105594: ** matters if the current index is the least costly, so do not bother
105595: ** with this step if we already know this index will not be chosen.
105596: ** Also, never reduce the output row count below 2 using this step.
105597: **
105598: ** It is critical that the notValid mask be used here instead of
105599: ** the notReady mask. When computing an "optimal" index, the notReady
105600: ** mask will only have one bit set - the bit for the current table.
105601: ** The notValid mask, on the other hand, always has all bits set for
105602: ** tables that are not in outer loops. If notReady is used here instead
105603: ** of notValid, then a optimal index that depends on inner joins loops
105604: ** might be selected even when there exists an optimal index that has
105605: ** no such dependency.
105606: */
105607: if( nRow>2 && cost<=pCost->rCost ){
105608: int k; /* Loop counter */
105609: int nSkipEq = nEq; /* Number of == constraints to skip */
105610: int nSkipRange = nBound; /* Number of < constraints to skip */
105611: Bitmask thisTab; /* Bitmap for pSrc */
105612:
105613: thisTab = getMask(pWC->pMaskSet, iCur);
105614: for(pTerm=pWC->a, k=pWC->nTerm; nRow>2 && k; k--, pTerm++){
105615: if( pTerm->wtFlags & TERM_VIRTUAL ) continue;
105616: if( (pTerm->prereqAll & notValid)!=thisTab ) continue;
105617: if( pTerm->eOperator & (WO_EQ|WO_IN|WO_ISNULL) ){
105618: if( nSkipEq ){
105619: /* Ignore the first nEq equality matches since the index
105620: ** has already accounted for these */
105621: nSkipEq--;
105622: }else{
105623: /* Assume each additional equality match reduces the result
105624: ** set size by a factor of 10 */
105625: nRow /= 10;
105626: }
105627: }else if( pTerm->eOperator & (WO_LT|WO_LE|WO_GT|WO_GE) ){
105628: if( nSkipRange ){
105629: /* Ignore the first nSkipRange range constraints since the index
105630: ** has already accounted for these */
105631: nSkipRange--;
105632: }else{
105633: /* Assume each additional range constraint reduces the result
105634: ** set size by a factor of 3. Indexed range constraints reduce
105635: ** the search space by a larger factor: 4. We make indexed range
105636: ** more selective intentionally because of the subjective
105637: ** observation that indexed range constraints really are more
105638: ** selective in practice, on average. */
105639: nRow /= 3;
105640: }
105641: }else if( pTerm->eOperator!=WO_NOOP ){
105642: /* Any other expression lowers the output row count by half */
105643: nRow /= 2;
105644: }
105645: }
105646: if( nRow<2 ) nRow = 2;
105647: }
105648:
105649:
105650: WHERETRACE((
105651: "%s(%s): nEq=%d nInMul=%d rangeDiv=%d bSort=%d bLookup=%d wsFlags=0x%x\n"
105652: " notReady=0x%llx log10N=%.1f nRow=%.1f cost=%.1f used=0x%llx\n",
105653: pSrc->pTab->zName, (pIdx ? pIdx->zName : "ipk"),
105654: nEq, nInMul, (int)rangeDiv, bSort, bLookup, wsFlags,
105655: notReady, log10N, nRow, cost, used
105656: ));
105657:
105658: /* If this index is the best we have seen so far, then record this
105659: ** index and its cost in the pCost structure.
105660: */
105661: if( (!pIdx || wsFlags)
105662: && (cost<pCost->rCost || (cost<=pCost->rCost && nRow<pCost->plan.nRow))
105663: ){
105664: pCost->rCost = cost;
105665: pCost->used = used;
105666: pCost->plan.nRow = nRow;
105667: pCost->plan.wsFlags = (wsFlags&wsFlagMask);
105668: pCost->plan.nEq = nEq;
105669: pCost->plan.u.pIdx = pIdx;
105670: }
105671:
105672: /* If there was an INDEXED BY clause, then only that one index is
105673: ** considered. */
105674: if( pSrc->pIndex ) break;
105675:
105676: /* Reset masks for the next index in the loop */
105677: wsFlagMask = ~(WHERE_ROWID_EQ|WHERE_ROWID_RANGE);
105678: eqTermMask = idxEqTermMask;
105679: }
105680:
105681: /* If there is no ORDER BY clause and the SQLITE_ReverseOrder flag
105682: ** is set, then reverse the order that the index will be scanned
105683: ** in. This is used for application testing, to help find cases
105684: ** where application behaviour depends on the (undefined) order that
105685: ** SQLite outputs rows in in the absence of an ORDER BY clause. */
105686: if( !pOrderBy && pParse->db->flags & SQLITE_ReverseOrder ){
105687: pCost->plan.wsFlags |= WHERE_REVERSE;
105688: }
105689:
105690: assert( pOrderBy || (pCost->plan.wsFlags&WHERE_ORDERBY)==0 );
105691: assert( pCost->plan.u.pIdx==0 || (pCost->plan.wsFlags&WHERE_ROWID_EQ)==0 );
105692: assert( pSrc->pIndex==0
105693: || pCost->plan.u.pIdx==0
105694: || pCost->plan.u.pIdx==pSrc->pIndex
105695: );
105696:
105697: WHERETRACE(("best index is: %s\n",
105698: ((pCost->plan.wsFlags & WHERE_NOT_FULLSCAN)==0 ? "none" :
105699: pCost->plan.u.pIdx ? pCost->plan.u.pIdx->zName : "ipk")
105700: ));
105701:
105702: bestOrClauseIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost);
105703: bestAutomaticIndex(pParse, pWC, pSrc, notReady, pCost);
105704: pCost->plan.wsFlags |= eqTermMask;
105705: }
105706:
105707: /*
105708: ** Find the query plan for accessing table pSrc->pTab. Write the
105709: ** best query plan and its cost into the WhereCost object supplied
105710: ** as the last parameter. This function may calculate the cost of
105711: ** both real and virtual table scans.
105712: */
105713: static void bestIndex(
105714: Parse *pParse, /* The parsing context */
105715: WhereClause *pWC, /* The WHERE clause */
105716: struct SrcList_item *pSrc, /* The FROM clause term to search */
105717: Bitmask notReady, /* Mask of cursors not available for indexing */
105718: Bitmask notValid, /* Cursors not available for any purpose */
105719: ExprList *pOrderBy, /* The ORDER BY clause */
105720: WhereCost *pCost /* Lowest cost query plan */
105721: ){
105722: #ifndef SQLITE_OMIT_VIRTUALTABLE
105723: if( IsVirtual(pSrc->pTab) ){
105724: sqlite3_index_info *p = 0;
105725: bestVirtualIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost,&p);
105726: if( p->needToFreeIdxStr ){
105727: sqlite3_free(p->idxStr);
105728: }
105729: sqlite3DbFree(pParse->db, p);
105730: }else
105731: #endif
105732: {
105733: bestBtreeIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, 0, pCost);
105734: }
105735: }
105736:
105737: /*
105738: ** Disable a term in the WHERE clause. Except, do not disable the term
105739: ** if it controls a LEFT OUTER JOIN and it did not originate in the ON
105740: ** or USING clause of that join.
105741: **
105742: ** Consider the term t2.z='ok' in the following queries:
105743: **
105744: ** (1) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x WHERE t2.z='ok'
105745: ** (2) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x AND t2.z='ok'
105746: ** (3) SELECT * FROM t1, t2 WHERE t1.a=t2.x AND t2.z='ok'
105747: **
105748: ** The t2.z='ok' is disabled in the in (2) because it originates
105749: ** in the ON clause. The term is disabled in (3) because it is not part
105750: ** of a LEFT OUTER JOIN. In (1), the term is not disabled.
105751: **
105752: ** IMPLEMENTATION-OF: R-24597-58655 No tests are done for terms that are
105753: ** completely satisfied by indices.
105754: **
105755: ** Disabling a term causes that term to not be tested in the inner loop
105756: ** of the join. Disabling is an optimization. When terms are satisfied
105757: ** by indices, we disable them to prevent redundant tests in the inner
105758: ** loop. We would get the correct results if nothing were ever disabled,
105759: ** but joins might run a little slower. The trick is to disable as much
105760: ** as we can without disabling too much. If we disabled in (1), we'd get
105761: ** the wrong answer. See ticket #813.
105762: */
105763: static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){
105764: if( pTerm
105765: && (pTerm->wtFlags & TERM_CODED)==0
105766: && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin))
105767: ){
105768: pTerm->wtFlags |= TERM_CODED;
105769: if( pTerm->iParent>=0 ){
105770: WhereTerm *pOther = &pTerm->pWC->a[pTerm->iParent];
105771: if( (--pOther->nChild)==0 ){
105772: disableTerm(pLevel, pOther);
105773: }
105774: }
105775: }
105776: }
105777:
105778: /*
105779: ** Code an OP_Affinity opcode to apply the column affinity string zAff
105780: ** to the n registers starting at base.
105781: **
105782: ** As an optimization, SQLITE_AFF_NONE entries (which are no-ops) at the
105783: ** beginning and end of zAff are ignored. If all entries in zAff are
105784: ** SQLITE_AFF_NONE, then no code gets generated.
105785: **
105786: ** This routine makes its own copy of zAff so that the caller is free
105787: ** to modify zAff after this routine returns.
105788: */
105789: static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
105790: Vdbe *v = pParse->pVdbe;
105791: if( zAff==0 ){
105792: assert( pParse->db->mallocFailed );
105793: return;
105794: }
105795: assert( v!=0 );
105796:
105797: /* Adjust base and n to skip over SQLITE_AFF_NONE entries at the beginning
105798: ** and end of the affinity string.
105799: */
105800: while( n>0 && zAff[0]==SQLITE_AFF_NONE ){
105801: n--;
105802: base++;
105803: zAff++;
105804: }
105805: while( n>1 && zAff[n-1]==SQLITE_AFF_NONE ){
105806: n--;
105807: }
105808:
105809: /* Code the OP_Affinity opcode if there is anything left to do. */
105810: if( n>0 ){
105811: sqlite3VdbeAddOp2(v, OP_Affinity, base, n);
105812: sqlite3VdbeChangeP4(v, -1, zAff, n);
105813: sqlite3ExprCacheAffinityChange(pParse, base, n);
105814: }
105815: }
105816:
105817:
105818: /*
105819: ** Generate code for a single equality term of the WHERE clause. An equality
105820: ** term can be either X=expr or X IN (...). pTerm is the term to be
105821: ** coded.
105822: **
105823: ** The current value for the constraint is left in register iReg.
105824: **
105825: ** For a constraint of the form X=expr, the expression is evaluated and its
105826: ** result is left on the stack. For constraints of the form X IN (...)
105827: ** this routine sets up a loop that will iterate over all values of X.
105828: */
105829: static int codeEqualityTerm(
105830: Parse *pParse, /* The parsing context */
105831: WhereTerm *pTerm, /* The term of the WHERE clause to be coded */
105832: WhereLevel *pLevel, /* When level of the FROM clause we are working on */
105833: int iTarget /* Attempt to leave results in this register */
105834: ){
105835: Expr *pX = pTerm->pExpr;
105836: Vdbe *v = pParse->pVdbe;
105837: int iReg; /* Register holding results */
105838:
105839: assert( iTarget>0 );
105840: if( pX->op==TK_EQ ){
105841: iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget);
105842: }else if( pX->op==TK_ISNULL ){
105843: iReg = iTarget;
105844: sqlite3VdbeAddOp2(v, OP_Null, 0, iReg);
105845: #ifndef SQLITE_OMIT_SUBQUERY
105846: }else{
105847: int eType;
105848: int iTab;
105849: struct InLoop *pIn;
105850:
105851: assert( pX->op==TK_IN );
105852: iReg = iTarget;
105853: eType = sqlite3FindInIndex(pParse, pX, 0);
105854: iTab = pX->iTable;
105855: sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0);
105856: assert( pLevel->plan.wsFlags & WHERE_IN_ABLE );
105857: if( pLevel->u.in.nIn==0 ){
105858: pLevel->addrNxt = sqlite3VdbeMakeLabel(v);
105859: }
105860: pLevel->u.in.nIn++;
105861: pLevel->u.in.aInLoop =
105862: sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop,
105863: sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn);
105864: pIn = pLevel->u.in.aInLoop;
105865: if( pIn ){
105866: pIn += pLevel->u.in.nIn - 1;
105867: pIn->iCur = iTab;
105868: if( eType==IN_INDEX_ROWID ){
105869: pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iReg);
105870: }else{
105871: pIn->addrInTop = sqlite3VdbeAddOp3(v, OP_Column, iTab, 0, iReg);
105872: }
105873: sqlite3VdbeAddOp1(v, OP_IsNull, iReg);
105874: }else{
105875: pLevel->u.in.nIn = 0;
105876: }
105877: #endif
105878: }
105879: disableTerm(pLevel, pTerm);
105880: return iReg;
105881: }
105882:
105883: /*
105884: ** Generate code that will evaluate all == and IN constraints for an
105885: ** index.
105886: **
105887: ** For example, consider table t1(a,b,c,d,e,f) with index i1(a,b,c).
105888: ** Suppose the WHERE clause is this: a==5 AND b IN (1,2,3) AND c>5 AND c<10
105889: ** The index has as many as three equality constraints, but in this
105890: ** example, the third "c" value is an inequality. So only two
105891: ** constraints are coded. This routine will generate code to evaluate
105892: ** a==5 and b IN (1,2,3). The current values for a and b will be stored
105893: ** in consecutive registers and the index of the first register is returned.
105894: **
105895: ** In the example above nEq==2. But this subroutine works for any value
105896: ** of nEq including 0. If nEq==0, this routine is nearly a no-op.
105897: ** The only thing it does is allocate the pLevel->iMem memory cell and
105898: ** compute the affinity string.
105899: **
105900: ** This routine always allocates at least one memory cell and returns
105901: ** the index of that memory cell. The code that
105902: ** calls this routine will use that memory cell to store the termination
105903: ** key value of the loop. If one or more IN operators appear, then
105904: ** this routine allocates an additional nEq memory cells for internal
105905: ** use.
105906: **
105907: ** Before returning, *pzAff is set to point to a buffer containing a
105908: ** copy of the column affinity string of the index allocated using
105909: ** sqlite3DbMalloc(). Except, entries in the copy of the string associated
105910: ** with equality constraints that use NONE affinity are set to
105911: ** SQLITE_AFF_NONE. This is to deal with SQL such as the following:
105912: **
105913: ** CREATE TABLE t1(a TEXT PRIMARY KEY, b);
105914: ** SELECT ... FROM t1 AS t2, t1 WHERE t1.a = t2.b;
105915: **
105916: ** In the example above, the index on t1(a) has TEXT affinity. But since
105917: ** the right hand side of the equality constraint (t2.b) has NONE affinity,
105918: ** no conversion should be attempted before using a t2.b value as part of
105919: ** a key to search the index. Hence the first byte in the returned affinity
105920: ** string in this example would be set to SQLITE_AFF_NONE.
105921: */
105922: static int codeAllEqualityTerms(
105923: Parse *pParse, /* Parsing context */
105924: WhereLevel *pLevel, /* Which nested loop of the FROM we are coding */
105925: WhereClause *pWC, /* The WHERE clause */
105926: Bitmask notReady, /* Which parts of FROM have not yet been coded */
105927: int nExtraReg, /* Number of extra registers to allocate */
105928: char **pzAff /* OUT: Set to point to affinity string */
105929: ){
105930: int nEq = pLevel->plan.nEq; /* The number of == or IN constraints to code */
105931: Vdbe *v = pParse->pVdbe; /* The vm under construction */
105932: Index *pIdx; /* The index being used for this loop */
105933: int iCur = pLevel->iTabCur; /* The cursor of the table */
105934: WhereTerm *pTerm; /* A single constraint term */
105935: int j; /* Loop counter */
105936: int regBase; /* Base register */
105937: int nReg; /* Number of registers to allocate */
105938: char *zAff; /* Affinity string to return */
105939:
105940: /* This module is only called on query plans that use an index. */
105941: assert( pLevel->plan.wsFlags & WHERE_INDEXED );
105942: pIdx = pLevel->plan.u.pIdx;
105943:
105944: /* Figure out how many memory cells we will need then allocate them.
105945: */
105946: regBase = pParse->nMem + 1;
105947: nReg = pLevel->plan.nEq + nExtraReg;
105948: pParse->nMem += nReg;
105949:
105950: zAff = sqlite3DbStrDup(pParse->db, sqlite3IndexAffinityStr(v, pIdx));
105951: if( !zAff ){
105952: pParse->db->mallocFailed = 1;
105953: }
105954:
105955: /* Evaluate the equality constraints
105956: */
105957: assert( pIdx->nColumn>=nEq );
105958: for(j=0; j<nEq; j++){
105959: int r1;
105960: int k = pIdx->aiColumn[j];
105961: pTerm = findTerm(pWC, iCur, k, notReady, pLevel->plan.wsFlags, pIdx);
105962: if( NEVER(pTerm==0) ) break;
105963: /* The following true for indices with redundant columns.
105964: ** Ex: CREATE INDEX i1 ON t1(a,b,a); SELECT * FROM t1 WHERE a=0 AND b=0; */
105965: testcase( (pTerm->wtFlags & TERM_CODED)!=0 );
105966: testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
105967: r1 = codeEqualityTerm(pParse, pTerm, pLevel, regBase+j);
105968: if( r1!=regBase+j ){
105969: if( nReg==1 ){
105970: sqlite3ReleaseTempReg(pParse, regBase);
105971: regBase = r1;
105972: }else{
105973: sqlite3VdbeAddOp2(v, OP_SCopy, r1, regBase+j);
105974: }
105975: }
105976: testcase( pTerm->eOperator & WO_ISNULL );
105977: testcase( pTerm->eOperator & WO_IN );
105978: if( (pTerm->eOperator & (WO_ISNULL|WO_IN))==0 ){
105979: Expr *pRight = pTerm->pExpr->pRight;
105980: sqlite3ExprCodeIsNullJump(v, pRight, regBase+j, pLevel->addrBrk);
105981: if( zAff ){
105982: if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_NONE ){
105983: zAff[j] = SQLITE_AFF_NONE;
105984: }
105985: if( sqlite3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){
105986: zAff[j] = SQLITE_AFF_NONE;
105987: }
105988: }
105989: }
105990: }
105991: *pzAff = zAff;
105992: return regBase;
105993: }
105994:
105995: #ifndef SQLITE_OMIT_EXPLAIN
105996: /*
105997: ** This routine is a helper for explainIndexRange() below
105998: **
105999: ** pStr holds the text of an expression that we are building up one term
106000: ** at a time. This routine adds a new term to the end of the expression.
106001: ** Terms are separated by AND so add the "AND" text for second and subsequent
106002: ** terms only.
106003: */
106004: static void explainAppendTerm(
106005: StrAccum *pStr, /* The text expression being built */
106006: int iTerm, /* Index of this term. First is zero */
106007: const char *zColumn, /* Name of the column */
106008: const char *zOp /* Name of the operator */
106009: ){
106010: if( iTerm ) sqlite3StrAccumAppend(pStr, " AND ", 5);
106011: sqlite3StrAccumAppend(pStr, zColumn, -1);
106012: sqlite3StrAccumAppend(pStr, zOp, 1);
106013: sqlite3StrAccumAppend(pStr, "?", 1);
106014: }
106015:
106016: /*
106017: ** Argument pLevel describes a strategy for scanning table pTab. This
106018: ** function returns a pointer to a string buffer containing a description
106019: ** of the subset of table rows scanned by the strategy in the form of an
106020: ** SQL expression. Or, if all rows are scanned, NULL is returned.
106021: **
106022: ** For example, if the query:
106023: **
106024: ** SELECT * FROM t1 WHERE a=1 AND b>2;
106025: **
106026: ** is run and there is an index on (a, b), then this function returns a
106027: ** string similar to:
106028: **
106029: ** "a=? AND b>?"
106030: **
106031: ** The returned pointer points to memory obtained from sqlite3DbMalloc().
106032: ** It is the responsibility of the caller to free the buffer when it is
106033: ** no longer required.
106034: */
106035: static char *explainIndexRange(sqlite3 *db, WhereLevel *pLevel, Table *pTab){
106036: WherePlan *pPlan = &pLevel->plan;
106037: Index *pIndex = pPlan->u.pIdx;
106038: int nEq = pPlan->nEq;
106039: int i, j;
106040: Column *aCol = pTab->aCol;
106041: int *aiColumn = pIndex->aiColumn;
106042: StrAccum txt;
106043:
106044: if( nEq==0 && (pPlan->wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ){
106045: return 0;
106046: }
106047: sqlite3StrAccumInit(&txt, 0, 0, SQLITE_MAX_LENGTH);
106048: txt.db = db;
106049: sqlite3StrAccumAppend(&txt, " (", 2);
106050: for(i=0; i<nEq; i++){
106051: explainAppendTerm(&txt, i, aCol[aiColumn[i]].zName, "=");
106052: }
106053:
106054: j = i;
106055: if( pPlan->wsFlags&WHERE_BTM_LIMIT ){
106056: char *z = (j==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[j]].zName;
106057: explainAppendTerm(&txt, i++, z, ">");
106058: }
106059: if( pPlan->wsFlags&WHERE_TOP_LIMIT ){
106060: char *z = (j==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[j]].zName;
106061: explainAppendTerm(&txt, i, z, "<");
106062: }
106063: sqlite3StrAccumAppend(&txt, ")", 1);
106064: return sqlite3StrAccumFinish(&txt);
106065: }
106066:
106067: /*
106068: ** This function is a no-op unless currently processing an EXPLAIN QUERY PLAN
106069: ** command. If the query being compiled is an EXPLAIN QUERY PLAN, a single
106070: ** record is added to the output to describe the table scan strategy in
106071: ** pLevel.
106072: */
106073: static void explainOneScan(
106074: Parse *pParse, /* Parse context */
106075: SrcList *pTabList, /* Table list this loop refers to */
106076: WhereLevel *pLevel, /* Scan to write OP_Explain opcode for */
106077: int iLevel, /* Value for "level" column of output */
106078: int iFrom, /* Value for "from" column of output */
106079: u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */
106080: ){
106081: if( pParse->explain==2 ){
106082: u32 flags = pLevel->plan.wsFlags;
106083: struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom];
106084: Vdbe *v = pParse->pVdbe; /* VM being constructed */
106085: sqlite3 *db = pParse->db; /* Database handle */
106086: char *zMsg; /* Text to add to EQP output */
106087: sqlite3_int64 nRow; /* Expected number of rows visited by scan */
106088: int iId = pParse->iSelectId; /* Select id (left-most output column) */
106089: int isSearch; /* True for a SEARCH. False for SCAN. */
106090:
106091: if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_ONETABLE_ONLY) ) return;
106092:
106093: isSearch = (pLevel->plan.nEq>0)
106094: || (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0
106095: || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX));
106096:
106097: zMsg = sqlite3MPrintf(db, "%s", isSearch?"SEARCH":"SCAN");
106098: if( pItem->pSelect ){
106099: zMsg = sqlite3MAppendf(db, zMsg, "%s SUBQUERY %d", zMsg,pItem->iSelectId);
106100: }else{
106101: zMsg = sqlite3MAppendf(db, zMsg, "%s TABLE %s", zMsg, pItem->zName);
106102: }
106103:
106104: if( pItem->zAlias ){
106105: zMsg = sqlite3MAppendf(db, zMsg, "%s AS %s", zMsg, pItem->zAlias);
106106: }
106107: if( (flags & WHERE_INDEXED)!=0 ){
106108: char *zWhere = explainIndexRange(db, pLevel, pItem->pTab);
106109: zMsg = sqlite3MAppendf(db, zMsg, "%s USING %s%sINDEX%s%s%s", zMsg,
106110: ((flags & WHERE_TEMP_INDEX)?"AUTOMATIC ":""),
106111: ((flags & WHERE_IDX_ONLY)?"COVERING ":""),
106112: ((flags & WHERE_TEMP_INDEX)?"":" "),
106113: ((flags & WHERE_TEMP_INDEX)?"": pLevel->plan.u.pIdx->zName),
106114: zWhere
106115: );
106116: sqlite3DbFree(db, zWhere);
106117: }else if( flags & (WHERE_ROWID_EQ|WHERE_ROWID_RANGE) ){
106118: zMsg = sqlite3MAppendf(db, zMsg, "%s USING INTEGER PRIMARY KEY", zMsg);
106119:
106120: if( flags&WHERE_ROWID_EQ ){
106121: zMsg = sqlite3MAppendf(db, zMsg, "%s (rowid=?)", zMsg);
106122: }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){
106123: zMsg = sqlite3MAppendf(db, zMsg, "%s (rowid>? AND rowid<?)", zMsg);
106124: }else if( flags&WHERE_BTM_LIMIT ){
106125: zMsg = sqlite3MAppendf(db, zMsg, "%s (rowid>?)", zMsg);
106126: }else if( flags&WHERE_TOP_LIMIT ){
106127: zMsg = sqlite3MAppendf(db, zMsg, "%s (rowid<?)", zMsg);
106128: }
106129: }
106130: #ifndef SQLITE_OMIT_VIRTUALTABLE
106131: else if( (flags & WHERE_VIRTUALTABLE)!=0 ){
106132: sqlite3_index_info *pVtabIdx = pLevel->plan.u.pVtabIdx;
106133: zMsg = sqlite3MAppendf(db, zMsg, "%s VIRTUAL TABLE INDEX %d:%s", zMsg,
106134: pVtabIdx->idxNum, pVtabIdx->idxStr);
106135: }
106136: #endif
106137: if( wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX) ){
106138: testcase( wctrlFlags & WHERE_ORDERBY_MIN );
106139: nRow = 1;
106140: }else{
106141: nRow = (sqlite3_int64)pLevel->plan.nRow;
106142: }
106143: zMsg = sqlite3MAppendf(db, zMsg, "%s (~%lld rows)", zMsg, nRow);
106144: sqlite3VdbeAddOp4(v, OP_Explain, iId, iLevel, iFrom, zMsg, P4_DYNAMIC);
106145: }
106146: }
106147: #else
106148: # define explainOneScan(u,v,w,x,y,z)
106149: #endif /* SQLITE_OMIT_EXPLAIN */
106150:
106151:
106152: /*
106153: ** Generate code for the start of the iLevel-th loop in the WHERE clause
106154: ** implementation described by pWInfo.
106155: */
106156: static Bitmask codeOneLoopStart(
106157: WhereInfo *pWInfo, /* Complete information about the WHERE clause */
106158: int iLevel, /* Which level of pWInfo->a[] should be coded */
106159: u16 wctrlFlags, /* One of the WHERE_* flags defined in sqliteInt.h */
106160: Bitmask notReady, /* Which tables are currently available */
106161: Expr *pWhere /* Complete WHERE clause */
106162: ){
106163: int j, k; /* Loop counters */
106164: int iCur; /* The VDBE cursor for the table */
106165: int addrNxt; /* Where to jump to continue with the next IN case */
106166: int omitTable; /* True if we use the index only */
106167: int bRev; /* True if we need to scan in reverse order */
106168: WhereLevel *pLevel; /* The where level to be coded */
106169: WhereClause *pWC; /* Decomposition of the entire WHERE clause */
106170: WhereTerm *pTerm; /* A WHERE clause term */
106171: Parse *pParse; /* Parsing context */
106172: Vdbe *v; /* The prepared stmt under constructions */
106173: struct SrcList_item *pTabItem; /* FROM clause term being coded */
106174: int addrBrk; /* Jump here to break out of the loop */
106175: int addrCont; /* Jump here to continue with next cycle */
106176: int iRowidReg = 0; /* Rowid is stored in this register, if not zero */
106177: int iReleaseReg = 0; /* Temp register to free before returning */
106178:
106179: pParse = pWInfo->pParse;
106180: v = pParse->pVdbe;
106181: pWC = pWInfo->pWC;
106182: pLevel = &pWInfo->a[iLevel];
106183: pTabItem = &pWInfo->pTabList->a[pLevel->iFrom];
106184: iCur = pTabItem->iCursor;
106185: bRev = (pLevel->plan.wsFlags & WHERE_REVERSE)!=0;
106186: omitTable = (pLevel->plan.wsFlags & WHERE_IDX_ONLY)!=0
106187: && (wctrlFlags & WHERE_FORCE_TABLE)==0;
106188:
106189: /* Create labels for the "break" and "continue" instructions
106190: ** for the current loop. Jump to addrBrk to break out of a loop.
106191: ** Jump to cont to go immediately to the next iteration of the
106192: ** loop.
106193: **
106194: ** When there is an IN operator, we also have a "addrNxt" label that
106195: ** means to continue with the next IN value combination. When
106196: ** there are no IN operators in the constraints, the "addrNxt" label
106197: ** is the same as "addrBrk".
106198: */
106199: addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(v);
106200: addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(v);
106201:
106202: /* If this is the right table of a LEFT OUTER JOIN, allocate and
106203: ** initialize a memory cell that records if this table matches any
106204: ** row of the left table of the join.
106205: */
106206: if( pLevel->iFrom>0 && (pTabItem[0].jointype & JT_LEFT)!=0 ){
106207: pLevel->iLeftJoin = ++pParse->nMem;
106208: sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
106209: VdbeComment((v, "init LEFT JOIN no-match flag"));
106210: }
106211:
106212: #ifndef SQLITE_OMIT_VIRTUALTABLE
106213: if( (pLevel->plan.wsFlags & WHERE_VIRTUALTABLE)!=0 ){
106214: /* Case 0: The table is a virtual-table. Use the VFilter and VNext
106215: ** to access the data.
106216: */
106217: int iReg; /* P3 Value for OP_VFilter */
106218: sqlite3_index_info *pVtabIdx = pLevel->plan.u.pVtabIdx;
106219: int nConstraint = pVtabIdx->nConstraint;
106220: struct sqlite3_index_constraint_usage *aUsage =
106221: pVtabIdx->aConstraintUsage;
106222: const struct sqlite3_index_constraint *aConstraint =
106223: pVtabIdx->aConstraint;
106224:
106225: sqlite3ExprCachePush(pParse);
106226: iReg = sqlite3GetTempRange(pParse, nConstraint+2);
106227: for(j=1; j<=nConstraint; j++){
106228: for(k=0; k<nConstraint; k++){
106229: if( aUsage[k].argvIndex==j ){
106230: int iTerm = aConstraint[k].iTermOffset;
106231: sqlite3ExprCode(pParse, pWC->a[iTerm].pExpr->pRight, iReg+j+1);
106232: break;
106233: }
106234: }
106235: if( k==nConstraint ) break;
106236: }
106237: sqlite3VdbeAddOp2(v, OP_Integer, pVtabIdx->idxNum, iReg);
106238: sqlite3VdbeAddOp2(v, OP_Integer, j-1, iReg+1);
106239: sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrBrk, iReg, pVtabIdx->idxStr,
106240: pVtabIdx->needToFreeIdxStr ? P4_MPRINTF : P4_STATIC);
106241: pVtabIdx->needToFreeIdxStr = 0;
106242: for(j=0; j<nConstraint; j++){
106243: if( aUsage[j].omit ){
106244: int iTerm = aConstraint[j].iTermOffset;
106245: disableTerm(pLevel, &pWC->a[iTerm]);
106246: }
106247: }
106248: pLevel->op = OP_VNext;
106249: pLevel->p1 = iCur;
106250: pLevel->p2 = sqlite3VdbeCurrentAddr(v);
106251: sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2);
106252: sqlite3ExprCachePop(pParse, 1);
106253: }else
106254: #endif /* SQLITE_OMIT_VIRTUALTABLE */
106255:
106256: if( pLevel->plan.wsFlags & WHERE_ROWID_EQ ){
106257: /* Case 1: We can directly reference a single row using an
106258: ** equality comparison against the ROWID field. Or
106259: ** we reference multiple rows using a "rowid IN (...)"
106260: ** construct.
106261: */
106262: iReleaseReg = sqlite3GetTempReg(pParse);
106263: pTerm = findTerm(pWC, iCur, -1, notReady, WO_EQ|WO_IN, 0);
106264: assert( pTerm!=0 );
106265: assert( pTerm->pExpr!=0 );
106266: assert( pTerm->leftCursor==iCur );
106267: assert( omitTable==0 );
106268: testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106269: iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, iReleaseReg);
106270: addrNxt = pLevel->addrNxt;
106271: sqlite3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt);
106272: sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addrNxt, iRowidReg);
106273: sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
106274: VdbeComment((v, "pk"));
106275: pLevel->op = OP_Noop;
106276: }else if( pLevel->plan.wsFlags & WHERE_ROWID_RANGE ){
106277: /* Case 2: We have an inequality comparison against the ROWID field.
106278: */
106279: int testOp = OP_Noop;
106280: int start;
106281: int memEndValue = 0;
106282: WhereTerm *pStart, *pEnd;
106283:
106284: assert( omitTable==0 );
106285: pStart = findTerm(pWC, iCur, -1, notReady, WO_GT|WO_GE, 0);
106286: pEnd = findTerm(pWC, iCur, -1, notReady, WO_LT|WO_LE, 0);
106287: if( bRev ){
106288: pTerm = pStart;
106289: pStart = pEnd;
106290: pEnd = pTerm;
106291: }
106292: if( pStart ){
106293: Expr *pX; /* The expression that defines the start bound */
106294: int r1, rTemp; /* Registers for holding the start boundary */
106295:
106296: /* The following constant maps TK_xx codes into corresponding
106297: ** seek opcodes. It depends on a particular ordering of TK_xx
106298: */
106299: const u8 aMoveOp[] = {
106300: /* TK_GT */ OP_SeekGt,
106301: /* TK_LE */ OP_SeekLe,
106302: /* TK_LT */ OP_SeekLt,
106303: /* TK_GE */ OP_SeekGe
106304: };
106305: assert( TK_LE==TK_GT+1 ); /* Make sure the ordering.. */
106306: assert( TK_LT==TK_GT+2 ); /* ... of the TK_xx values... */
106307: assert( TK_GE==TK_GT+3 ); /* ... is correcct. */
106308:
106309: testcase( pStart->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106310: pX = pStart->pExpr;
106311: assert( pX!=0 );
106312: assert( pStart->leftCursor==iCur );
106313: r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp);
106314: sqlite3VdbeAddOp3(v, aMoveOp[pX->op-TK_GT], iCur, addrBrk, r1);
106315: VdbeComment((v, "pk"));
106316: sqlite3ExprCacheAffinityChange(pParse, r1, 1);
106317: sqlite3ReleaseTempReg(pParse, rTemp);
106318: disableTerm(pLevel, pStart);
106319: }else{
106320: sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrBrk);
106321: }
106322: if( pEnd ){
106323: Expr *pX;
106324: pX = pEnd->pExpr;
106325: assert( pX!=0 );
106326: assert( pEnd->leftCursor==iCur );
106327: testcase( pEnd->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106328: memEndValue = ++pParse->nMem;
106329: sqlite3ExprCode(pParse, pX->pRight, memEndValue);
106330: if( pX->op==TK_LT || pX->op==TK_GT ){
106331: testOp = bRev ? OP_Le : OP_Ge;
106332: }else{
106333: testOp = bRev ? OP_Lt : OP_Gt;
106334: }
106335: disableTerm(pLevel, pEnd);
106336: }
106337: start = sqlite3VdbeCurrentAddr(v);
106338: pLevel->op = bRev ? OP_Prev : OP_Next;
106339: pLevel->p1 = iCur;
106340: pLevel->p2 = start;
106341: if( pStart==0 && pEnd==0 ){
106342: pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
106343: }else{
106344: assert( pLevel->p5==0 );
106345: }
106346: if( testOp!=OP_Noop ){
106347: iRowidReg = iReleaseReg = sqlite3GetTempReg(pParse);
106348: sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg);
106349: sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
106350: sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg);
106351: sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL);
106352: }
106353: }else if( pLevel->plan.wsFlags & (WHERE_COLUMN_RANGE|WHERE_COLUMN_EQ) ){
106354: /* Case 3: A scan using an index.
106355: **
106356: ** The WHERE clause may contain zero or more equality
106357: ** terms ("==" or "IN" operators) that refer to the N
106358: ** left-most columns of the index. It may also contain
106359: ** inequality constraints (>, <, >= or <=) on the indexed
106360: ** column that immediately follows the N equalities. Only
106361: ** the right-most column can be an inequality - the rest must
106362: ** use the "==" and "IN" operators. For example, if the
106363: ** index is on (x,y,z), then the following clauses are all
106364: ** optimized:
106365: **
106366: ** x=5
106367: ** x=5 AND y=10
106368: ** x=5 AND y<10
106369: ** x=5 AND y>5 AND y<10
106370: ** x=5 AND y=5 AND z<=10
106371: **
106372: ** The z<10 term of the following cannot be used, only
106373: ** the x=5 term:
106374: **
106375: ** x=5 AND z<10
106376: **
106377: ** N may be zero if there are inequality constraints.
106378: ** If there are no inequality constraints, then N is at
106379: ** least one.
106380: **
106381: ** This case is also used when there are no WHERE clause
106382: ** constraints but an index is selected anyway, in order
106383: ** to force the output order to conform to an ORDER BY.
106384: */
106385: static const u8 aStartOp[] = {
106386: 0,
106387: 0,
106388: OP_Rewind, /* 2: (!start_constraints && startEq && !bRev) */
106389: OP_Last, /* 3: (!start_constraints && startEq && bRev) */
106390: OP_SeekGt, /* 4: (start_constraints && !startEq && !bRev) */
106391: OP_SeekLt, /* 5: (start_constraints && !startEq && bRev) */
106392: OP_SeekGe, /* 6: (start_constraints && startEq && !bRev) */
106393: OP_SeekLe /* 7: (start_constraints && startEq && bRev) */
106394: };
106395: static const u8 aEndOp[] = {
106396: OP_Noop, /* 0: (!end_constraints) */
106397: OP_IdxGE, /* 1: (end_constraints && !bRev) */
106398: OP_IdxLT /* 2: (end_constraints && bRev) */
106399: };
106400: int nEq = pLevel->plan.nEq; /* Number of == or IN terms */
106401: int isMinQuery = 0; /* If this is an optimized SELECT min(x).. */
106402: int regBase; /* Base register holding constraint values */
106403: int r1; /* Temp register */
106404: WhereTerm *pRangeStart = 0; /* Inequality constraint at range start */
106405: WhereTerm *pRangeEnd = 0; /* Inequality constraint at range end */
106406: int startEq; /* True if range start uses ==, >= or <= */
106407: int endEq; /* True if range end uses ==, >= or <= */
106408: int start_constraints; /* Start of range is constrained */
106409: int nConstraint; /* Number of constraint terms */
106410: Index *pIdx; /* The index we will be using */
106411: int iIdxCur; /* The VDBE cursor for the index */
106412: int nExtraReg = 0; /* Number of extra registers needed */
106413: int op; /* Instruction opcode */
106414: char *zStartAff; /* Affinity for start of range constraint */
106415: char *zEndAff; /* Affinity for end of range constraint */
106416:
106417: pIdx = pLevel->plan.u.pIdx;
106418: iIdxCur = pLevel->iIdxCur;
106419: k = (nEq==pIdx->nColumn ? -1 : pIdx->aiColumn[nEq]);
106420:
106421: /* If this loop satisfies a sort order (pOrderBy) request that
106422: ** was passed to this function to implement a "SELECT min(x) ..."
106423: ** query, then the caller will only allow the loop to run for
106424: ** a single iteration. This means that the first row returned
106425: ** should not have a NULL value stored in 'x'. If column 'x' is
106426: ** the first one after the nEq equality constraints in the index,
106427: ** this requires some special handling.
106428: */
106429: if( (wctrlFlags&WHERE_ORDERBY_MIN)!=0
106430: && (pLevel->plan.wsFlags&WHERE_ORDERBY)
106431: && (pIdx->nColumn>nEq)
106432: ){
106433: /* assert( pOrderBy->nExpr==1 ); */
106434: /* assert( pOrderBy->a[0].pExpr->iColumn==pIdx->aiColumn[nEq] ); */
106435: isMinQuery = 1;
106436: nExtraReg = 1;
106437: }
106438:
106439: /* Find any inequality constraint terms for the start and end
106440: ** of the range.
106441: */
106442: if( pLevel->plan.wsFlags & WHERE_TOP_LIMIT ){
106443: pRangeEnd = findTerm(pWC, iCur, k, notReady, (WO_LT|WO_LE), pIdx);
106444: nExtraReg = 1;
106445: }
106446: if( pLevel->plan.wsFlags & WHERE_BTM_LIMIT ){
106447: pRangeStart = findTerm(pWC, iCur, k, notReady, (WO_GT|WO_GE), pIdx);
106448: nExtraReg = 1;
106449: }
106450:
106451: /* Generate code to evaluate all constraint terms using == or IN
106452: ** and store the values of those terms in an array of registers
106453: ** starting at regBase.
106454: */
106455: regBase = codeAllEqualityTerms(
106456: pParse, pLevel, pWC, notReady, nExtraReg, &zStartAff
106457: );
106458: zEndAff = sqlite3DbStrDup(pParse->db, zStartAff);
106459: addrNxt = pLevel->addrNxt;
106460:
106461: /* If we are doing a reverse order scan on an ascending index, or
106462: ** a forward order scan on a descending index, interchange the
106463: ** start and end terms (pRangeStart and pRangeEnd).
106464: */
106465: if( (nEq<pIdx->nColumn && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC))
106466: || (bRev && pIdx->nColumn==nEq)
106467: ){
106468: SWAP(WhereTerm *, pRangeEnd, pRangeStart);
106469: }
106470:
106471: testcase( pRangeStart && pRangeStart->eOperator & WO_LE );
106472: testcase( pRangeStart && pRangeStart->eOperator & WO_GE );
106473: testcase( pRangeEnd && pRangeEnd->eOperator & WO_LE );
106474: testcase( pRangeEnd && pRangeEnd->eOperator & WO_GE );
106475: startEq = !pRangeStart || pRangeStart->eOperator & (WO_LE|WO_GE);
106476: endEq = !pRangeEnd || pRangeEnd->eOperator & (WO_LE|WO_GE);
106477: start_constraints = pRangeStart || nEq>0;
106478:
106479: /* Seek the index cursor to the start of the range. */
106480: nConstraint = nEq;
106481: if( pRangeStart ){
106482: Expr *pRight = pRangeStart->pExpr->pRight;
106483: sqlite3ExprCode(pParse, pRight, regBase+nEq);
106484: if( (pRangeStart->wtFlags & TERM_VNULL)==0 ){
106485: sqlite3ExprCodeIsNullJump(v, pRight, regBase+nEq, addrNxt);
106486: }
106487: if( zStartAff ){
106488: if( sqlite3CompareAffinity(pRight, zStartAff[nEq])==SQLITE_AFF_NONE){
106489: /* Since the comparison is to be performed with no conversions
106490: ** applied to the operands, set the affinity to apply to pRight to
106491: ** SQLITE_AFF_NONE. */
106492: zStartAff[nEq] = SQLITE_AFF_NONE;
106493: }
106494: if( sqlite3ExprNeedsNoAffinityChange(pRight, zStartAff[nEq]) ){
106495: zStartAff[nEq] = SQLITE_AFF_NONE;
106496: }
106497: }
106498: nConstraint++;
106499: testcase( pRangeStart->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106500: }else if( isMinQuery ){
106501: sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
106502: nConstraint++;
106503: startEq = 0;
106504: start_constraints = 1;
106505: }
106506: codeApplyAffinity(pParse, regBase, nConstraint, zStartAff);
106507: op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev];
106508: assert( op!=0 );
106509: testcase( op==OP_Rewind );
106510: testcase( op==OP_Last );
106511: testcase( op==OP_SeekGt );
106512: testcase( op==OP_SeekGe );
106513: testcase( op==OP_SeekLe );
106514: testcase( op==OP_SeekLt );
106515: sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
106516:
106517: /* Load the value for the inequality constraint at the end of the
106518: ** range (if any).
106519: */
106520: nConstraint = nEq;
106521: if( pRangeEnd ){
106522: Expr *pRight = pRangeEnd->pExpr->pRight;
106523: sqlite3ExprCacheRemove(pParse, regBase+nEq, 1);
106524: sqlite3ExprCode(pParse, pRight, regBase+nEq);
106525: if( (pRangeEnd->wtFlags & TERM_VNULL)==0 ){
106526: sqlite3ExprCodeIsNullJump(v, pRight, regBase+nEq, addrNxt);
106527: }
106528: if( zEndAff ){
106529: if( sqlite3CompareAffinity(pRight, zEndAff[nEq])==SQLITE_AFF_NONE){
106530: /* Since the comparison is to be performed with no conversions
106531: ** applied to the operands, set the affinity to apply to pRight to
106532: ** SQLITE_AFF_NONE. */
106533: zEndAff[nEq] = SQLITE_AFF_NONE;
106534: }
106535: if( sqlite3ExprNeedsNoAffinityChange(pRight, zEndAff[nEq]) ){
106536: zEndAff[nEq] = SQLITE_AFF_NONE;
106537: }
106538: }
106539: codeApplyAffinity(pParse, regBase, nEq+1, zEndAff);
106540: nConstraint++;
106541: testcase( pRangeEnd->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */
106542: }
106543: sqlite3DbFree(pParse->db, zStartAff);
106544: sqlite3DbFree(pParse->db, zEndAff);
106545:
106546: /* Top of the loop body */
106547: pLevel->p2 = sqlite3VdbeCurrentAddr(v);
106548:
106549: /* Check if the index cursor is past the end of the range. */
106550: op = aEndOp[(pRangeEnd || nEq) * (1 + bRev)];
106551: testcase( op==OP_Noop );
106552: testcase( op==OP_IdxGE );
106553: testcase( op==OP_IdxLT );
106554: if( op!=OP_Noop ){
106555: sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
106556: sqlite3VdbeChangeP5(v, endEq!=bRev ?1:0);
106557: }
106558:
106559: /* If there are inequality constraints, check that the value
106560: ** of the table column that the inequality contrains is not NULL.
106561: ** If it is, jump to the next iteration of the loop.
106562: */
106563: r1 = sqlite3GetTempReg(pParse);
106564: testcase( pLevel->plan.wsFlags & WHERE_BTM_LIMIT );
106565: testcase( pLevel->plan.wsFlags & WHERE_TOP_LIMIT );
106566: if( (pLevel->plan.wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 ){
106567: sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, nEq, r1);
106568: sqlite3VdbeAddOp2(v, OP_IsNull, r1, addrCont);
106569: }
106570: sqlite3ReleaseTempReg(pParse, r1);
106571:
106572: /* Seek the table cursor, if required */
106573: disableTerm(pLevel, pRangeStart);
106574: disableTerm(pLevel, pRangeEnd);
106575: if( !omitTable ){
106576: iRowidReg = iReleaseReg = sqlite3GetTempReg(pParse);
106577: sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, iRowidReg);
106578: sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
106579: sqlite3VdbeAddOp2(v, OP_Seek, iCur, iRowidReg); /* Deferred seek */
106580: }
106581:
106582: /* Record the instruction used to terminate the loop. Disable
106583: ** WHERE clause terms made redundant by the index range scan.
106584: */
106585: if( pLevel->plan.wsFlags & WHERE_UNIQUE ){
106586: pLevel->op = OP_Noop;
106587: }else if( bRev ){
106588: pLevel->op = OP_Prev;
106589: }else{
106590: pLevel->op = OP_Next;
106591: }
106592: pLevel->p1 = iIdxCur;
106593: }else
106594:
106595: #ifndef SQLITE_OMIT_OR_OPTIMIZATION
106596: if( pLevel->plan.wsFlags & WHERE_MULTI_OR ){
106597: /* Case 4: Two or more separately indexed terms connected by OR
106598: **
106599: ** Example:
106600: **
106601: ** CREATE TABLE t1(a,b,c,d);
106602: ** CREATE INDEX i1 ON t1(a);
106603: ** CREATE INDEX i2 ON t1(b);
106604: ** CREATE INDEX i3 ON t1(c);
106605: **
106606: ** SELECT * FROM t1 WHERE a=5 OR b=7 OR (c=11 AND d=13)
106607: **
106608: ** In the example, there are three indexed terms connected by OR.
106609: ** The top of the loop looks like this:
106610: **
106611: ** Null 1 # Zero the rowset in reg 1
106612: **
106613: ** Then, for each indexed term, the following. The arguments to
106614: ** RowSetTest are such that the rowid of the current row is inserted
106615: ** into the RowSet. If it is already present, control skips the
106616: ** Gosub opcode and jumps straight to the code generated by WhereEnd().
106617: **
106618: ** sqlite3WhereBegin(<term>)
106619: ** RowSetTest # Insert rowid into rowset
106620: ** Gosub 2 A
106621: ** sqlite3WhereEnd()
106622: **
106623: ** Following the above, code to terminate the loop. Label A, the target
106624: ** of the Gosub above, jumps to the instruction right after the Goto.
106625: **
106626: ** Null 1 # Zero the rowset in reg 1
106627: ** Goto B # The loop is finished.
106628: **
106629: ** A: <loop body> # Return data, whatever.
106630: **
106631: ** Return 2 # Jump back to the Gosub
106632: **
106633: ** B: <after the loop>
106634: **
106635: */
106636: WhereClause *pOrWc; /* The OR-clause broken out into subterms */
106637: SrcList *pOrTab; /* Shortened table list or OR-clause generation */
106638:
106639: int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */
106640: int regRowset = 0; /* Register for RowSet object */
106641: int regRowid = 0; /* Register holding rowid */
106642: int iLoopBody = sqlite3VdbeMakeLabel(v); /* Start of loop body */
106643: int iRetInit; /* Address of regReturn init */
106644: int untestedTerms = 0; /* Some terms not completely tested */
106645: int ii; /* Loop counter */
106646: Expr *pAndExpr = 0; /* An ".. AND (...)" expression */
106647:
106648: pTerm = pLevel->plan.u.pTerm;
106649: assert( pTerm!=0 );
106650: assert( pTerm->eOperator==WO_OR );
106651: assert( (pTerm->wtFlags & TERM_ORINFO)!=0 );
106652: pOrWc = &pTerm->u.pOrInfo->wc;
106653: pLevel->op = OP_Return;
106654: pLevel->p1 = regReturn;
106655:
106656: /* Set up a new SrcList ni pOrTab containing the table being scanned
106657: ** by this loop in the a[0] slot and all notReady tables in a[1..] slots.
106658: ** This becomes the SrcList in the recursive call to sqlite3WhereBegin().
106659: */
106660: if( pWInfo->nLevel>1 ){
106661: int nNotReady; /* The number of notReady tables */
106662: struct SrcList_item *origSrc; /* Original list of tables */
106663: nNotReady = pWInfo->nLevel - iLevel - 1;
106664: pOrTab = sqlite3StackAllocRaw(pParse->db,
106665: sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0]));
106666: if( pOrTab==0 ) return notReady;
106667: pOrTab->nAlloc = (i16)(nNotReady + 1);
106668: pOrTab->nSrc = pOrTab->nAlloc;
106669: memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem));
106670: origSrc = pWInfo->pTabList->a;
106671: for(k=1; k<=nNotReady; k++){
106672: memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k]));
106673: }
106674: }else{
106675: pOrTab = pWInfo->pTabList;
106676: }
106677:
106678: /* Initialize the rowset register to contain NULL. An SQL NULL is
106679: ** equivalent to an empty rowset.
106680: **
106681: ** Also initialize regReturn to contain the address of the instruction
106682: ** immediately following the OP_Return at the bottom of the loop. This
106683: ** is required in a few obscure LEFT JOIN cases where control jumps
106684: ** over the top of the loop into the body of it. In this case the
106685: ** correct response for the end-of-loop code (the OP_Return) is to
106686: ** fall through to the next instruction, just as an OP_Next does if
106687: ** called on an uninitialized cursor.
106688: */
106689: if( (wctrlFlags & WHERE_DUPLICATES_OK)==0 ){
106690: regRowset = ++pParse->nMem;
106691: regRowid = ++pParse->nMem;
106692: sqlite3VdbeAddOp2(v, OP_Null, 0, regRowset);
106693: }
106694: iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn);
106695:
106696: /* If the original WHERE clause is z of the form: (x1 OR x2 OR ...) AND y
106697: ** Then for every term xN, evaluate as the subexpression: xN AND z
106698: ** That way, terms in y that are factored into the disjunction will
106699: ** be picked up by the recursive calls to sqlite3WhereBegin() below.
106700: */
106701: if( pWC->nTerm>1 ){
106702: pAndExpr = sqlite3ExprAlloc(pParse->db, TK_AND, 0, 0);
106703: pAndExpr->pRight = pWhere;
106704: }
106705:
106706: for(ii=0; ii<pOrWc->nTerm; ii++){
106707: WhereTerm *pOrTerm = &pOrWc->a[ii];
106708: if( pOrTerm->leftCursor==iCur || pOrTerm->eOperator==WO_AND ){
106709: WhereInfo *pSubWInfo; /* Info for single OR-term scan */
106710: Expr *pOrExpr = pOrTerm->pExpr;
106711: if( pAndExpr ){
106712: pAndExpr->pLeft = pOrExpr;
106713: pOrExpr = pAndExpr;
106714: }
106715: /* Loop through table entries that match term pOrTerm. */
106716: pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0,
106717: WHERE_OMIT_OPEN_CLOSE | WHERE_AND_ONLY |
106718: WHERE_FORCE_TABLE | WHERE_ONETABLE_ONLY);
106719: if( pSubWInfo ){
106720: explainOneScan(
106721: pParse, pOrTab, &pSubWInfo->a[0], iLevel, pLevel->iFrom, 0
106722: );
106723: if( (wctrlFlags & WHERE_DUPLICATES_OK)==0 ){
106724: int iSet = ((ii==pOrWc->nTerm-1)?-1:ii);
106725: int r;
106726: r = sqlite3ExprCodeGetColumn(pParse, pTabItem->pTab, -1, iCur,
106727: regRowid);
106728: sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset,
106729: sqlite3VdbeCurrentAddr(v)+2, r, iSet);
106730: }
106731: sqlite3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody);
106732:
106733: /* The pSubWInfo->untestedTerms flag means that this OR term
106734: ** contained one or more AND term from a notReady table. The
106735: ** terms from the notReady table could not be tested and will
106736: ** need to be tested later.
106737: */
106738: if( pSubWInfo->untestedTerms ) untestedTerms = 1;
106739:
106740: /* Finish the loop through table entries that match term pOrTerm. */
106741: sqlite3WhereEnd(pSubWInfo);
106742: }
106743: }
106744: }
106745: sqlite3DbFree(pParse->db, pAndExpr);
106746: sqlite3VdbeChangeP1(v, iRetInit, sqlite3VdbeCurrentAddr(v));
106747: sqlite3VdbeAddOp2(v, OP_Goto, 0, pLevel->addrBrk);
106748: sqlite3VdbeResolveLabel(v, iLoopBody);
106749:
106750: if( pWInfo->nLevel>1 ) sqlite3StackFree(pParse->db, pOrTab);
106751: if( !untestedTerms ) disableTerm(pLevel, pTerm);
106752: }else
106753: #endif /* SQLITE_OMIT_OR_OPTIMIZATION */
106754:
106755: {
106756: /* Case 5: There is no usable index. We must do a complete
106757: ** scan of the entire table.
106758: */
106759: static const u8 aStep[] = { OP_Next, OP_Prev };
106760: static const u8 aStart[] = { OP_Rewind, OP_Last };
106761: assert( bRev==0 || bRev==1 );
106762: assert( omitTable==0 );
106763: pLevel->op = aStep[bRev];
106764: pLevel->p1 = iCur;
106765: pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk);
106766: pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP;
106767: }
106768: notReady &= ~getMask(pWC->pMaskSet, iCur);
106769:
106770: /* Insert code to test every subexpression that can be completely
106771: ** computed using the current set of tables.
106772: **
106773: ** IMPLEMENTATION-OF: R-49525-50935 Terms that cannot be satisfied through
106774: ** the use of indices become tests that are evaluated against each row of
106775: ** the relevant input tables.
106776: */
106777: for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){
106778: Expr *pE;
106779: testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* IMP: R-30575-11662 */
106780: testcase( pTerm->wtFlags & TERM_CODED );
106781: if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
106782: if( (pTerm->prereqAll & notReady)!=0 ){
106783: testcase( pWInfo->untestedTerms==0
106784: && (pWInfo->wctrlFlags & WHERE_ONETABLE_ONLY)!=0 );
106785: pWInfo->untestedTerms = 1;
106786: continue;
106787: }
106788: pE = pTerm->pExpr;
106789: assert( pE!=0 );
106790: if( pLevel->iLeftJoin && !ExprHasProperty(pE, EP_FromJoin) ){
106791: continue;
106792: }
106793: sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL);
106794: pTerm->wtFlags |= TERM_CODED;
106795: }
106796:
106797: /* For a LEFT OUTER JOIN, generate code that will record the fact that
106798: ** at least one row of the right table has matched the left table.
106799: */
106800: if( pLevel->iLeftJoin ){
106801: pLevel->addrFirst = sqlite3VdbeCurrentAddr(v);
106802: sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin);
106803: VdbeComment((v, "record LEFT JOIN hit"));
106804: sqlite3ExprCacheClear(pParse);
106805: for(pTerm=pWC->a, j=0; j<pWC->nTerm; j++, pTerm++){
106806: testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* IMP: R-30575-11662 */
106807: testcase( pTerm->wtFlags & TERM_CODED );
106808: if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue;
106809: if( (pTerm->prereqAll & notReady)!=0 ){
106810: assert( pWInfo->untestedTerms );
106811: continue;
106812: }
106813: assert( pTerm->pExpr );
106814: sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
106815: pTerm->wtFlags |= TERM_CODED;
106816: }
106817: }
106818: sqlite3ReleaseTempReg(pParse, iReleaseReg);
106819:
106820: return notReady;
106821: }
106822:
106823: #if defined(SQLITE_TEST)
106824: /*
106825: ** The following variable holds a text description of query plan generated
106826: ** by the most recent call to sqlite3WhereBegin(). Each call to WhereBegin
106827: ** overwrites the previous. This information is used for testing and
106828: ** analysis only.
106829: */
106830: SQLITE_API char sqlite3_query_plan[BMS*2*40]; /* Text of the join */
106831: static int nQPlan = 0; /* Next free slow in _query_plan[] */
106832:
106833: #endif /* SQLITE_TEST */
106834:
106835:
106836: /*
106837: ** Free a WhereInfo structure
106838: */
106839: static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){
106840: if( ALWAYS(pWInfo) ){
106841: int i;
106842: for(i=0; i<pWInfo->nLevel; i++){
106843: sqlite3_index_info *pInfo = pWInfo->a[i].pIdxInfo;
106844: if( pInfo ){
106845: /* assert( pInfo->needToFreeIdxStr==0 || db->mallocFailed ); */
106846: if( pInfo->needToFreeIdxStr ){
106847: sqlite3_free(pInfo->idxStr);
106848: }
106849: sqlite3DbFree(db, pInfo);
106850: }
106851: if( pWInfo->a[i].plan.wsFlags & WHERE_TEMP_INDEX ){
106852: Index *pIdx = pWInfo->a[i].plan.u.pIdx;
106853: if( pIdx ){
106854: sqlite3DbFree(db, pIdx->zColAff);
106855: sqlite3DbFree(db, pIdx);
106856: }
106857: }
106858: }
106859: whereClauseClear(pWInfo->pWC);
106860: sqlite3DbFree(db, pWInfo);
106861: }
106862: }
106863:
106864:
106865: /*
106866: ** Generate the beginning of the loop used for WHERE clause processing.
106867: ** The return value is a pointer to an opaque structure that contains
106868: ** information needed to terminate the loop. Later, the calling routine
106869: ** should invoke sqlite3WhereEnd() with the return value of this function
106870: ** in order to complete the WHERE clause processing.
106871: **
106872: ** If an error occurs, this routine returns NULL.
106873: **
106874: ** The basic idea is to do a nested loop, one loop for each table in
106875: ** the FROM clause of a select. (INSERT and UPDATE statements are the
106876: ** same as a SELECT with only a single table in the FROM clause.) For
106877: ** example, if the SQL is this:
106878: **
106879: ** SELECT * FROM t1, t2, t3 WHERE ...;
106880: **
106881: ** Then the code generated is conceptually like the following:
106882: **
106883: ** foreach row1 in t1 do \ Code generated
106884: ** foreach row2 in t2 do |-- by sqlite3WhereBegin()
106885: ** foreach row3 in t3 do /
106886: ** ...
106887: ** end \ Code generated
106888: ** end |-- by sqlite3WhereEnd()
106889: ** end /
106890: **
106891: ** Note that the loops might not be nested in the order in which they
106892: ** appear in the FROM clause if a different order is better able to make
106893: ** use of indices. Note also that when the IN operator appears in
106894: ** the WHERE clause, it might result in additional nested loops for
106895: ** scanning through all values on the right-hand side of the IN.
106896: **
106897: ** There are Btree cursors associated with each table. t1 uses cursor
106898: ** number pTabList->a[0].iCursor. t2 uses the cursor pTabList->a[1].iCursor.
106899: ** And so forth. This routine generates code to open those VDBE cursors
106900: ** and sqlite3WhereEnd() generates the code to close them.
106901: **
106902: ** The code that sqlite3WhereBegin() generates leaves the cursors named
106903: ** in pTabList pointing at their appropriate entries. The [...] code
106904: ** can use OP_Column and OP_Rowid opcodes on these cursors to extract
106905: ** data from the various tables of the loop.
106906: **
106907: ** If the WHERE clause is empty, the foreach loops must each scan their
106908: ** entire tables. Thus a three-way join is an O(N^3) operation. But if
106909: ** the tables have indices and there are terms in the WHERE clause that
106910: ** refer to those indices, a complete table scan can be avoided and the
106911: ** code will run much faster. Most of the work of this routine is checking
106912: ** to see if there are indices that can be used to speed up the loop.
106913: **
106914: ** Terms of the WHERE clause are also used to limit which rows actually
106915: ** make it to the "..." in the middle of the loop. After each "foreach",
106916: ** terms of the WHERE clause that use only terms in that loop and outer
106917: ** loops are evaluated and if false a jump is made around all subsequent
106918: ** inner loops (or around the "..." if the test occurs within the inner-
106919: ** most loop)
106920: **
106921: ** OUTER JOINS
106922: **
106923: ** An outer join of tables t1 and t2 is conceptally coded as follows:
106924: **
106925: ** foreach row1 in t1 do
106926: ** flag = 0
106927: ** foreach row2 in t2 do
106928: ** start:
106929: ** ...
106930: ** flag = 1
106931: ** end
106932: ** if flag==0 then
106933: ** move the row2 cursor to a null row
106934: ** goto start
106935: ** fi
106936: ** end
106937: **
106938: ** ORDER BY CLAUSE PROCESSING
106939: **
106940: ** *ppOrderBy is a pointer to the ORDER BY clause of a SELECT statement,
106941: ** if there is one. If there is no ORDER BY clause or if this routine
106942: ** is called from an UPDATE or DELETE statement, then ppOrderBy is NULL.
106943: **
106944: ** If an index can be used so that the natural output order of the table
106945: ** scan is correct for the ORDER BY clause, then that index is used and
106946: ** *ppOrderBy is set to NULL. This is an optimization that prevents an
106947: ** unnecessary sort of the result set if an index appropriate for the
106948: ** ORDER BY clause already exists.
106949: **
106950: ** If the where clause loops cannot be arranged to provide the correct
106951: ** output order, then the *ppOrderBy is unchanged.
106952: */
106953: SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
106954: Parse *pParse, /* The parser context */
106955: SrcList *pTabList, /* A list of all tables to be scanned */
106956: Expr *pWhere, /* The WHERE clause */
106957: ExprList **ppOrderBy, /* An ORDER BY clause, or NULL */
106958: ExprList *pDistinct, /* The select-list for DISTINCT queries - or NULL */
106959: u16 wctrlFlags /* One of the WHERE_* flags defined in sqliteInt.h */
106960: ){
106961: int i; /* Loop counter */
106962: int nByteWInfo; /* Num. bytes allocated for WhereInfo struct */
106963: int nTabList; /* Number of elements in pTabList */
106964: WhereInfo *pWInfo; /* Will become the return value of this function */
106965: Vdbe *v = pParse->pVdbe; /* The virtual database engine */
106966: Bitmask notReady; /* Cursors that are not yet positioned */
106967: WhereMaskSet *pMaskSet; /* The expression mask set */
106968: WhereClause *pWC; /* Decomposition of the WHERE clause */
106969: struct SrcList_item *pTabItem; /* A single entry from pTabList */
106970: WhereLevel *pLevel; /* A single level in the pWInfo list */
106971: int iFrom; /* First unused FROM clause element */
106972: int andFlags; /* AND-ed combination of all pWC->a[].wtFlags */
106973: sqlite3 *db; /* Database connection */
106974:
106975: /* The number of tables in the FROM clause is limited by the number of
106976: ** bits in a Bitmask
106977: */
106978: testcase( pTabList->nSrc==BMS );
106979: if( pTabList->nSrc>BMS ){
106980: sqlite3ErrorMsg(pParse, "at most %d tables in a join", BMS);
106981: return 0;
106982: }
106983:
106984: /* This function normally generates a nested loop for all tables in
106985: ** pTabList. But if the WHERE_ONETABLE_ONLY flag is set, then we should
106986: ** only generate code for the first table in pTabList and assume that
106987: ** any cursors associated with subsequent tables are uninitialized.
106988: */
106989: nTabList = (wctrlFlags & WHERE_ONETABLE_ONLY) ? 1 : pTabList->nSrc;
106990:
106991: /* Allocate and initialize the WhereInfo structure that will become the
106992: ** return value. A single allocation is used to store the WhereInfo
106993: ** struct, the contents of WhereInfo.a[], the WhereClause structure
106994: ** and the WhereMaskSet structure. Since WhereClause contains an 8-byte
106995: ** field (type Bitmask) it must be aligned on an 8-byte boundary on
106996: ** some architectures. Hence the ROUND8() below.
106997: */
106998: db = pParse->db;
106999: nByteWInfo = ROUND8(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel));
107000: pWInfo = sqlite3DbMallocZero(db,
107001: nByteWInfo +
107002: sizeof(WhereClause) +
107003: sizeof(WhereMaskSet)
107004: );
107005: if( db->mallocFailed ){
107006: sqlite3DbFree(db, pWInfo);
107007: pWInfo = 0;
107008: goto whereBeginError;
107009: }
107010: pWInfo->nLevel = nTabList;
107011: pWInfo->pParse = pParse;
107012: pWInfo->pTabList = pTabList;
107013: pWInfo->iBreak = sqlite3VdbeMakeLabel(v);
107014: pWInfo->pWC = pWC = (WhereClause *)&((u8 *)pWInfo)[nByteWInfo];
107015: pWInfo->wctrlFlags = wctrlFlags;
107016: pWInfo->savedNQueryLoop = pParse->nQueryLoop;
107017: pMaskSet = (WhereMaskSet*)&pWC[1];
107018:
107019: /* Disable the DISTINCT optimization if SQLITE_DistinctOpt is set via
107020: ** sqlite3_test_ctrl(SQLITE_TESTCTRL_OPTIMIZATIONS,...) */
107021: if( db->flags & SQLITE_DistinctOpt ) pDistinct = 0;
107022:
107023: /* Split the WHERE clause into separate subexpressions where each
107024: ** subexpression is separated by an AND operator.
107025: */
107026: initMaskSet(pMaskSet);
107027: whereClauseInit(pWC, pParse, pMaskSet, wctrlFlags);
107028: sqlite3ExprCodeConstants(pParse, pWhere);
107029: whereSplit(pWC, pWhere, TK_AND); /* IMP: R-15842-53296 */
107030:
107031: /* Special case: a WHERE clause that is constant. Evaluate the
107032: ** expression and either jump over all of the code or fall thru.
107033: */
107034: if( pWhere && (nTabList==0 || sqlite3ExprIsConstantNotJoin(pWhere)) ){
107035: sqlite3ExprIfFalse(pParse, pWhere, pWInfo->iBreak, SQLITE_JUMPIFNULL);
107036: pWhere = 0;
107037: }
107038:
107039: /* Assign a bit from the bitmask to every term in the FROM clause.
107040: **
107041: ** When assigning bitmask values to FROM clause cursors, it must be
107042: ** the case that if X is the bitmask for the N-th FROM clause term then
107043: ** the bitmask for all FROM clause terms to the left of the N-th term
107044: ** is (X-1). An expression from the ON clause of a LEFT JOIN can use
107045: ** its Expr.iRightJoinTable value to find the bitmask of the right table
107046: ** of the join. Subtracting one from the right table bitmask gives a
107047: ** bitmask for all tables to the left of the join. Knowing the bitmask
107048: ** for all tables to the left of a left join is important. Ticket #3015.
107049: **
107050: ** Configure the WhereClause.vmask variable so that bits that correspond
107051: ** to virtual table cursors are set. This is used to selectively disable
107052: ** the OR-to-IN transformation in exprAnalyzeOrTerm(). It is not helpful
107053: ** with virtual tables.
107054: **
107055: ** Note that bitmasks are created for all pTabList->nSrc tables in
107056: ** pTabList, not just the first nTabList tables. nTabList is normally
107057: ** equal to pTabList->nSrc but might be shortened to 1 if the
107058: ** WHERE_ONETABLE_ONLY flag is set.
107059: */
107060: assert( pWC->vmask==0 && pMaskSet->n==0 );
107061: for(i=0; i<pTabList->nSrc; i++){
107062: createMask(pMaskSet, pTabList->a[i].iCursor);
107063: #ifndef SQLITE_OMIT_VIRTUALTABLE
107064: if( ALWAYS(pTabList->a[i].pTab) && IsVirtual(pTabList->a[i].pTab) ){
107065: pWC->vmask |= ((Bitmask)1 << i);
107066: }
107067: #endif
107068: }
107069: #ifndef NDEBUG
107070: {
107071: Bitmask toTheLeft = 0;
107072: for(i=0; i<pTabList->nSrc; i++){
107073: Bitmask m = getMask(pMaskSet, pTabList->a[i].iCursor);
107074: assert( (m-1)==toTheLeft );
107075: toTheLeft |= m;
107076: }
107077: }
107078: #endif
107079:
107080: /* Analyze all of the subexpressions. Note that exprAnalyze() might
107081: ** add new virtual terms onto the end of the WHERE clause. We do not
107082: ** want to analyze these virtual terms, so start analyzing at the end
107083: ** and work forward so that the added virtual terms are never processed.
107084: */
107085: exprAnalyzeAll(pTabList, pWC);
107086: if( db->mallocFailed ){
107087: goto whereBeginError;
107088: }
107089:
107090: /* Check if the DISTINCT qualifier, if there is one, is redundant.
107091: ** If it is, then set pDistinct to NULL and WhereInfo.eDistinct to
107092: ** WHERE_DISTINCT_UNIQUE to tell the caller to ignore the DISTINCT.
107093: */
107094: if( pDistinct && isDistinctRedundant(pParse, pTabList, pWC, pDistinct) ){
107095: pDistinct = 0;
107096: pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
107097: }
107098:
107099: /* Chose the best index to use for each table in the FROM clause.
107100: **
107101: ** This loop fills in the following fields:
107102: **
107103: ** pWInfo->a[].pIdx The index to use for this level of the loop.
107104: ** pWInfo->a[].wsFlags WHERE_xxx flags associated with pIdx
107105: ** pWInfo->a[].nEq The number of == and IN constraints
107106: ** pWInfo->a[].iFrom Which term of the FROM clause is being coded
107107: ** pWInfo->a[].iTabCur The VDBE cursor for the database table
107108: ** pWInfo->a[].iIdxCur The VDBE cursor for the index
107109: ** pWInfo->a[].pTerm When wsFlags==WO_OR, the OR-clause term
107110: **
107111: ** This loop also figures out the nesting order of tables in the FROM
107112: ** clause.
107113: */
107114: notReady = ~(Bitmask)0;
107115: andFlags = ~0;
107116: WHERETRACE(("*** Optimizer Start ***\n"));
107117: for(i=iFrom=0, pLevel=pWInfo->a; i<nTabList; i++, pLevel++){
107118: WhereCost bestPlan; /* Most efficient plan seen so far */
107119: Index *pIdx; /* Index for FROM table at pTabItem */
107120: int j; /* For looping over FROM tables */
107121: int bestJ = -1; /* The value of j */
107122: Bitmask m; /* Bitmask value for j or bestJ */
107123: int isOptimal; /* Iterator for optimal/non-optimal search */
107124: int nUnconstrained; /* Number tables without INDEXED BY */
107125: Bitmask notIndexed; /* Mask of tables that cannot use an index */
107126:
107127: memset(&bestPlan, 0, sizeof(bestPlan));
107128: bestPlan.rCost = SQLITE_BIG_DBL;
107129: WHERETRACE(("*** Begin search for loop %d ***\n", i));
107130:
107131: /* Loop through the remaining entries in the FROM clause to find the
107132: ** next nested loop. The loop tests all FROM clause entries
107133: ** either once or twice.
107134: **
107135: ** The first test is always performed if there are two or more entries
107136: ** remaining and never performed if there is only one FROM clause entry
107137: ** to choose from. The first test looks for an "optimal" scan. In
107138: ** this context an optimal scan is one that uses the same strategy
107139: ** for the given FROM clause entry as would be selected if the entry
107140: ** were used as the innermost nested loop. In other words, a table
107141: ** is chosen such that the cost of running that table cannot be reduced
107142: ** by waiting for other tables to run first. This "optimal" test works
107143: ** by first assuming that the FROM clause is on the inner loop and finding
107144: ** its query plan, then checking to see if that query plan uses any
107145: ** other FROM clause terms that are notReady. If no notReady terms are
107146: ** used then the "optimal" query plan works.
107147: **
107148: ** Note that the WhereCost.nRow parameter for an optimal scan might
107149: ** not be as small as it would be if the table really were the innermost
107150: ** join. The nRow value can be reduced by WHERE clause constraints
107151: ** that do not use indices. But this nRow reduction only happens if the
107152: ** table really is the innermost join.
107153: **
107154: ** The second loop iteration is only performed if no optimal scan
107155: ** strategies were found by the first iteration. This second iteration
107156: ** is used to search for the lowest cost scan overall.
107157: **
107158: ** Previous versions of SQLite performed only the second iteration -
107159: ** the next outermost loop was always that with the lowest overall
107160: ** cost. However, this meant that SQLite could select the wrong plan
107161: ** for scripts such as the following:
107162: **
107163: ** CREATE TABLE t1(a, b);
107164: ** CREATE TABLE t2(c, d);
107165: ** SELECT * FROM t2, t1 WHERE t2.rowid = t1.a;
107166: **
107167: ** The best strategy is to iterate through table t1 first. However it
107168: ** is not possible to determine this with a simple greedy algorithm.
107169: ** Since the cost of a linear scan through table t2 is the same
107170: ** as the cost of a linear scan through table t1, a simple greedy
107171: ** algorithm may choose to use t2 for the outer loop, which is a much
107172: ** costlier approach.
107173: */
107174: nUnconstrained = 0;
107175: notIndexed = 0;
107176: for(isOptimal=(iFrom<nTabList-1); isOptimal>=0 && bestJ<0; isOptimal--){
107177: Bitmask mask; /* Mask of tables not yet ready */
107178: for(j=iFrom, pTabItem=&pTabList->a[j]; j<nTabList; j++, pTabItem++){
107179: int doNotReorder; /* True if this table should not be reordered */
107180: WhereCost sCost; /* Cost information from best[Virtual]Index() */
107181: ExprList *pOrderBy; /* ORDER BY clause for index to optimize */
107182: ExprList *pDist; /* DISTINCT clause for index to optimize */
107183:
107184: doNotReorder = (pTabItem->jointype & (JT_LEFT|JT_CROSS))!=0;
107185: if( j!=iFrom && doNotReorder ) break;
107186: m = getMask(pMaskSet, pTabItem->iCursor);
107187: if( (m & notReady)==0 ){
107188: if( j==iFrom ) iFrom++;
107189: continue;
107190: }
107191: mask = (isOptimal ? m : notReady);
107192: pOrderBy = ((i==0 && ppOrderBy )?*ppOrderBy:0);
107193: pDist = (i==0 ? pDistinct : 0);
107194: if( pTabItem->pIndex==0 ) nUnconstrained++;
107195:
107196: WHERETRACE(("=== trying table %d with isOptimal=%d ===\n",
107197: j, isOptimal));
107198: assert( pTabItem->pTab );
107199: #ifndef SQLITE_OMIT_VIRTUALTABLE
107200: if( IsVirtual(pTabItem->pTab) ){
107201: sqlite3_index_info **pp = &pWInfo->a[j].pIdxInfo;
107202: bestVirtualIndex(pParse, pWC, pTabItem, mask, notReady, pOrderBy,
107203: &sCost, pp);
107204: }else
107205: #endif
107206: {
107207: bestBtreeIndex(pParse, pWC, pTabItem, mask, notReady, pOrderBy,
107208: pDist, &sCost);
107209: }
107210: assert( isOptimal || (sCost.used¬Ready)==0 );
107211:
107212: /* If an INDEXED BY clause is present, then the plan must use that
107213: ** index if it uses any index at all */
107214: assert( pTabItem->pIndex==0
107215: || (sCost.plan.wsFlags & WHERE_NOT_FULLSCAN)==0
107216: || sCost.plan.u.pIdx==pTabItem->pIndex );
107217:
107218: if( isOptimal && (sCost.plan.wsFlags & WHERE_NOT_FULLSCAN)==0 ){
107219: notIndexed |= m;
107220: }
107221:
107222: /* Conditions under which this table becomes the best so far:
107223: **
107224: ** (1) The table must not depend on other tables that have not
107225: ** yet run.
107226: **
107227: ** (2) A full-table-scan plan cannot supercede indexed plan unless
107228: ** the full-table-scan is an "optimal" plan as defined above.
107229: **
107230: ** (3) All tables have an INDEXED BY clause or this table lacks an
107231: ** INDEXED BY clause or this table uses the specific
107232: ** index specified by its INDEXED BY clause. This rule ensures
107233: ** that a best-so-far is always selected even if an impossible
107234: ** combination of INDEXED BY clauses are given. The error
107235: ** will be detected and relayed back to the application later.
107236: ** The NEVER() comes about because rule (2) above prevents
107237: ** An indexable full-table-scan from reaching rule (3).
107238: **
107239: ** (4) The plan cost must be lower than prior plans or else the
107240: ** cost must be the same and the number of rows must be lower.
107241: */
107242: if( (sCost.used¬Ready)==0 /* (1) */
107243: && (bestJ<0 || (notIndexed&m)!=0 /* (2) */
107244: || (bestPlan.plan.wsFlags & WHERE_NOT_FULLSCAN)==0
107245: || (sCost.plan.wsFlags & WHERE_NOT_FULLSCAN)!=0)
107246: && (nUnconstrained==0 || pTabItem->pIndex==0 /* (3) */
107247: || NEVER((sCost.plan.wsFlags & WHERE_NOT_FULLSCAN)!=0))
107248: && (bestJ<0 || sCost.rCost<bestPlan.rCost /* (4) */
107249: || (sCost.rCost<=bestPlan.rCost
107250: && sCost.plan.nRow<bestPlan.plan.nRow))
107251: ){
107252: WHERETRACE(("=== table %d is best so far"
107253: " with cost=%g and nRow=%g\n",
107254: j, sCost.rCost, sCost.plan.nRow));
107255: bestPlan = sCost;
107256: bestJ = j;
107257: }
107258: if( doNotReorder ) break;
107259: }
107260: }
107261: assert( bestJ>=0 );
107262: assert( notReady & getMask(pMaskSet, pTabList->a[bestJ].iCursor) );
107263: WHERETRACE(("*** Optimizer selects table %d for loop %d"
107264: " with cost=%g and nRow=%g\n",
107265: bestJ, pLevel-pWInfo->a, bestPlan.rCost, bestPlan.plan.nRow));
107266: /* The ALWAYS() that follows was added to hush up clang scan-build */
107267: if( (bestPlan.plan.wsFlags & WHERE_ORDERBY)!=0 && ALWAYS(ppOrderBy) ){
107268: *ppOrderBy = 0;
107269: }
107270: if( (bestPlan.plan.wsFlags & WHERE_DISTINCT)!=0 ){
107271: assert( pWInfo->eDistinct==0 );
107272: pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
107273: }
107274: andFlags &= bestPlan.plan.wsFlags;
107275: pLevel->plan = bestPlan.plan;
107276: testcase( bestPlan.plan.wsFlags & WHERE_INDEXED );
107277: testcase( bestPlan.plan.wsFlags & WHERE_TEMP_INDEX );
107278: if( bestPlan.plan.wsFlags & (WHERE_INDEXED|WHERE_TEMP_INDEX) ){
107279: pLevel->iIdxCur = pParse->nTab++;
107280: }else{
107281: pLevel->iIdxCur = -1;
107282: }
107283: notReady &= ~getMask(pMaskSet, pTabList->a[bestJ].iCursor);
107284: pLevel->iFrom = (u8)bestJ;
107285: if( bestPlan.plan.nRow>=(double)1 ){
107286: pParse->nQueryLoop *= bestPlan.plan.nRow;
107287: }
107288:
107289: /* Check that if the table scanned by this loop iteration had an
107290: ** INDEXED BY clause attached to it, that the named index is being
107291: ** used for the scan. If not, then query compilation has failed.
107292: ** Return an error.
107293: */
107294: pIdx = pTabList->a[bestJ].pIndex;
107295: if( pIdx ){
107296: if( (bestPlan.plan.wsFlags & WHERE_INDEXED)==0 ){
107297: sqlite3ErrorMsg(pParse, "cannot use index: %s", pIdx->zName);
107298: goto whereBeginError;
107299: }else{
107300: /* If an INDEXED BY clause is used, the bestIndex() function is
107301: ** guaranteed to find the index specified in the INDEXED BY clause
107302: ** if it find an index at all. */
107303: assert( bestPlan.plan.u.pIdx==pIdx );
107304: }
107305: }
107306: }
107307: WHERETRACE(("*** Optimizer Finished ***\n"));
107308: if( pParse->nErr || db->mallocFailed ){
107309: goto whereBeginError;
107310: }
107311:
107312: /* If the total query only selects a single row, then the ORDER BY
107313: ** clause is irrelevant.
107314: */
107315: if( (andFlags & WHERE_UNIQUE)!=0 && ppOrderBy ){
107316: *ppOrderBy = 0;
107317: }
107318:
107319: /* If the caller is an UPDATE or DELETE statement that is requesting
107320: ** to use a one-pass algorithm, determine if this is appropriate.
107321: ** The one-pass algorithm only works if the WHERE clause constraints
107322: ** the statement to update a single row.
107323: */
107324: assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 );
107325: if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 && (andFlags & WHERE_UNIQUE)!=0 ){
107326: pWInfo->okOnePass = 1;
107327: pWInfo->a[0].plan.wsFlags &= ~WHERE_IDX_ONLY;
107328: }
107329:
107330: /* Open all tables in the pTabList and any indices selected for
107331: ** searching those tables.
107332: */
107333: sqlite3CodeVerifySchema(pParse, -1); /* Insert the cookie verifier Goto */
107334: notReady = ~(Bitmask)0;
107335: pWInfo->nRowOut = (double)1;
107336: for(i=0, pLevel=pWInfo->a; i<nTabList; i++, pLevel++){
107337: Table *pTab; /* Table to open */
107338: int iDb; /* Index of database containing table/index */
107339:
107340: pTabItem = &pTabList->a[pLevel->iFrom];
107341: pTab = pTabItem->pTab;
107342: pLevel->iTabCur = pTabItem->iCursor;
107343: pWInfo->nRowOut *= pLevel->plan.nRow;
107344: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
107345: if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){
107346: /* Do nothing */
107347: }else
107348: #ifndef SQLITE_OMIT_VIRTUALTABLE
107349: if( (pLevel->plan.wsFlags & WHERE_VIRTUALTABLE)!=0 ){
107350: const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
107351: int iCur = pTabItem->iCursor;
107352: sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB);
107353: }else
107354: #endif
107355: if( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0
107356: && (wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0 ){
107357: int op = pWInfo->okOnePass ? OP_OpenWrite : OP_OpenRead;
107358: sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
107359: testcase( pTab->nCol==BMS-1 );
107360: testcase( pTab->nCol==BMS );
107361: if( !pWInfo->okOnePass && pTab->nCol<BMS ){
107362: Bitmask b = pTabItem->colUsed;
107363: int n = 0;
107364: for(; b; b=b>>1, n++){}
107365: sqlite3VdbeChangeP4(v, sqlite3VdbeCurrentAddr(v)-1,
107366: SQLITE_INT_TO_PTR(n), P4_INT32);
107367: assert( n<=pTab->nCol );
107368: }
107369: }else{
107370: sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
107371: }
107372: #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
107373: if( (pLevel->plan.wsFlags & WHERE_TEMP_INDEX)!=0 ){
107374: constructAutomaticIndex(pParse, pWC, pTabItem, notReady, pLevel);
107375: }else
107376: #endif
107377: if( (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 ){
107378: Index *pIx = pLevel->plan.u.pIdx;
107379: KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIx);
107380: int iIdxCur = pLevel->iIdxCur;
107381: assert( pIx->pSchema==pTab->pSchema );
107382: assert( iIdxCur>=0 );
107383: sqlite3VdbeAddOp4(v, OP_OpenRead, iIdxCur, pIx->tnum, iDb,
107384: (char*)pKey, P4_KEYINFO_HANDOFF);
107385: VdbeComment((v, "%s", pIx->zName));
107386: }
107387: sqlite3CodeVerifySchema(pParse, iDb);
107388: notReady &= ~getMask(pWC->pMaskSet, pTabItem->iCursor);
107389: }
107390: pWInfo->iTop = sqlite3VdbeCurrentAddr(v);
107391: if( db->mallocFailed ) goto whereBeginError;
107392:
107393: /* Generate the code to do the search. Each iteration of the for
107394: ** loop below generates code for a single nested loop of the VM
107395: ** program.
107396: */
107397: notReady = ~(Bitmask)0;
107398: for(i=0; i<nTabList; i++){
107399: pLevel = &pWInfo->a[i];
107400: explainOneScan(pParse, pTabList, pLevel, i, pLevel->iFrom, wctrlFlags);
107401: notReady = codeOneLoopStart(pWInfo, i, wctrlFlags, notReady, pWhere);
107402: pWInfo->iContinue = pLevel->addrCont;
107403: }
107404:
107405: #ifdef SQLITE_TEST /* For testing and debugging use only */
107406: /* Record in the query plan information about the current table
107407: ** and the index used to access it (if any). If the table itself
107408: ** is not used, its name is just '{}'. If no index is used
107409: ** the index is listed as "{}". If the primary key is used the
107410: ** index name is '*'.
107411: */
107412: for(i=0; i<nTabList; i++){
107413: char *z;
107414: int n;
107415: pLevel = &pWInfo->a[i];
107416: pTabItem = &pTabList->a[pLevel->iFrom];
107417: z = pTabItem->zAlias;
107418: if( z==0 ) z = pTabItem->pTab->zName;
107419: n = sqlite3Strlen30(z);
107420: if( n+nQPlan < sizeof(sqlite3_query_plan)-10 ){
107421: if( pLevel->plan.wsFlags & WHERE_IDX_ONLY ){
107422: memcpy(&sqlite3_query_plan[nQPlan], "{}", 2);
107423: nQPlan += 2;
107424: }else{
107425: memcpy(&sqlite3_query_plan[nQPlan], z, n);
107426: nQPlan += n;
107427: }
107428: sqlite3_query_plan[nQPlan++] = ' ';
107429: }
107430: testcase( pLevel->plan.wsFlags & WHERE_ROWID_EQ );
107431: testcase( pLevel->plan.wsFlags & WHERE_ROWID_RANGE );
107432: if( pLevel->plan.wsFlags & (WHERE_ROWID_EQ|WHERE_ROWID_RANGE) ){
107433: memcpy(&sqlite3_query_plan[nQPlan], "* ", 2);
107434: nQPlan += 2;
107435: }else if( (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 ){
107436: n = sqlite3Strlen30(pLevel->plan.u.pIdx->zName);
107437: if( n+nQPlan < sizeof(sqlite3_query_plan)-2 ){
107438: memcpy(&sqlite3_query_plan[nQPlan], pLevel->plan.u.pIdx->zName, n);
107439: nQPlan += n;
107440: sqlite3_query_plan[nQPlan++] = ' ';
107441: }
107442: }else{
107443: memcpy(&sqlite3_query_plan[nQPlan], "{} ", 3);
107444: nQPlan += 3;
107445: }
107446: }
107447: while( nQPlan>0 && sqlite3_query_plan[nQPlan-1]==' ' ){
107448: sqlite3_query_plan[--nQPlan] = 0;
107449: }
107450: sqlite3_query_plan[nQPlan] = 0;
107451: nQPlan = 0;
107452: #endif /* SQLITE_TEST // Testing and debugging use only */
107453:
107454: /* Record the continuation address in the WhereInfo structure. Then
107455: ** clean up and return.
107456: */
107457: return pWInfo;
107458:
107459: /* Jump here if malloc fails */
107460: whereBeginError:
107461: if( pWInfo ){
107462: pParse->nQueryLoop = pWInfo->savedNQueryLoop;
107463: whereInfoFree(db, pWInfo);
107464: }
107465: return 0;
107466: }
107467:
107468: /*
107469: ** Generate the end of the WHERE loop. See comments on
107470: ** sqlite3WhereBegin() for additional information.
107471: */
107472: SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
107473: Parse *pParse = pWInfo->pParse;
107474: Vdbe *v = pParse->pVdbe;
107475: int i;
107476: WhereLevel *pLevel;
107477: SrcList *pTabList = pWInfo->pTabList;
107478: sqlite3 *db = pParse->db;
107479:
107480: /* Generate loop termination code.
107481: */
107482: sqlite3ExprCacheClear(pParse);
107483: for(i=pWInfo->nLevel-1; i>=0; i--){
107484: pLevel = &pWInfo->a[i];
107485: sqlite3VdbeResolveLabel(v, pLevel->addrCont);
107486: if( pLevel->op!=OP_Noop ){
107487: sqlite3VdbeAddOp2(v, pLevel->op, pLevel->p1, pLevel->p2);
107488: sqlite3VdbeChangeP5(v, pLevel->p5);
107489: }
107490: if( pLevel->plan.wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){
107491: struct InLoop *pIn;
107492: int j;
107493: sqlite3VdbeResolveLabel(v, pLevel->addrNxt);
107494: for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){
107495: sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
107496: sqlite3VdbeAddOp2(v, OP_Next, pIn->iCur, pIn->addrInTop);
107497: sqlite3VdbeJumpHere(v, pIn->addrInTop-1);
107498: }
107499: sqlite3DbFree(db, pLevel->u.in.aInLoop);
107500: }
107501: sqlite3VdbeResolveLabel(v, pLevel->addrBrk);
107502: if( pLevel->iLeftJoin ){
107503: int addr;
107504: addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin);
107505: assert( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0
107506: || (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 );
107507: if( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0 ){
107508: sqlite3VdbeAddOp1(v, OP_NullRow, pTabList->a[i].iCursor);
107509: }
107510: if( pLevel->iIdxCur>=0 ){
107511: sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur);
107512: }
107513: if( pLevel->op==OP_Return ){
107514: sqlite3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst);
107515: }else{
107516: sqlite3VdbeAddOp2(v, OP_Goto, 0, pLevel->addrFirst);
107517: }
107518: sqlite3VdbeJumpHere(v, addr);
107519: }
107520: }
107521:
107522: /* The "break" point is here, just past the end of the outer loop.
107523: ** Set it.
107524: */
107525: sqlite3VdbeResolveLabel(v, pWInfo->iBreak);
107526:
107527: /* Close all of the cursors that were opened by sqlite3WhereBegin.
107528: */
107529: assert( pWInfo->nLevel==1 || pWInfo->nLevel==pTabList->nSrc );
107530: for(i=0, pLevel=pWInfo->a; i<pWInfo->nLevel; i++, pLevel++){
107531: struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom];
107532: Table *pTab = pTabItem->pTab;
107533: assert( pTab!=0 );
107534: if( (pTab->tabFlags & TF_Ephemeral)==0
107535: && pTab->pSelect==0
107536: && (pWInfo->wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0
107537: ){
107538: int ws = pLevel->plan.wsFlags;
107539: if( !pWInfo->okOnePass && (ws & WHERE_IDX_ONLY)==0 ){
107540: sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
107541: }
107542: if( (ws & WHERE_INDEXED)!=0 && (ws & WHERE_TEMP_INDEX)==0 ){
107543: sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
107544: }
107545: }
107546:
107547: /* If this scan uses an index, make code substitutions to read data
107548: ** from the index in preference to the table. Sometimes, this means
107549: ** the table need never be read from. This is a performance boost,
107550: ** as the vdbe level waits until the table is read before actually
107551: ** seeking the table cursor to the record corresponding to the current
107552: ** position in the index.
107553: **
107554: ** Calls to the code generator in between sqlite3WhereBegin and
107555: ** sqlite3WhereEnd will have created code that references the table
107556: ** directly. This loop scans all that code looking for opcodes
107557: ** that reference the table and converts them into opcodes that
107558: ** reference the index.
107559: */
107560: if( (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 && !db->mallocFailed){
107561: int k, j, last;
107562: VdbeOp *pOp;
107563: Index *pIdx = pLevel->plan.u.pIdx;
107564:
107565: assert( pIdx!=0 );
107566: pOp = sqlite3VdbeGetOp(v, pWInfo->iTop);
107567: last = sqlite3VdbeCurrentAddr(v);
107568: for(k=pWInfo->iTop; k<last; k++, pOp++){
107569: if( pOp->p1!=pLevel->iTabCur ) continue;
107570: if( pOp->opcode==OP_Column ){
107571: for(j=0; j<pIdx->nColumn; j++){
107572: if( pOp->p2==pIdx->aiColumn[j] ){
107573: pOp->p2 = j;
107574: pOp->p1 = pLevel->iIdxCur;
107575: break;
107576: }
107577: }
107578: assert( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0
107579: || j<pIdx->nColumn );
107580: }else if( pOp->opcode==OP_Rowid ){
107581: pOp->p1 = pLevel->iIdxCur;
107582: pOp->opcode = OP_IdxRowid;
107583: }
107584: }
107585: }
107586: }
107587:
107588: /* Final cleanup
107589: */
107590: pParse->nQueryLoop = pWInfo->savedNQueryLoop;
107591: whereInfoFree(db, pWInfo);
107592: return;
107593: }
107594:
107595: /************** End of where.c ***********************************************/
107596: /************** Begin file parse.c *******************************************/
107597: /* Driver template for the LEMON parser generator.
107598: ** The author disclaims copyright to this source code.
107599: **
107600: ** This version of "lempar.c" is modified, slightly, for use by SQLite.
107601: ** The only modifications are the addition of a couple of NEVER()
107602: ** macros to disable tests that are needed in the case of a general
107603: ** LALR(1) grammar but which are always false in the
107604: ** specific grammar used by SQLite.
107605: */
107606: /* First off, code is included that follows the "include" declaration
107607: ** in the input grammar file. */
107608: /* #include <stdio.h> */
107609:
107610:
107611: /*
107612: ** Disable all error recovery processing in the parser push-down
107613: ** automaton.
107614: */
107615: #define YYNOERRORRECOVERY 1
107616:
107617: /*
107618: ** Make yytestcase() the same as testcase()
107619: */
107620: #define yytestcase(X) testcase(X)
107621:
107622: /*
107623: ** An instance of this structure holds information about the
107624: ** LIMIT clause of a SELECT statement.
107625: */
107626: struct LimitVal {
107627: Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */
107628: Expr *pOffset; /* The OFFSET expression. NULL if there is none */
107629: };
107630:
107631: /*
107632: ** An instance of this structure is used to store the LIKE,
107633: ** GLOB, NOT LIKE, and NOT GLOB operators.
107634: */
107635: struct LikeOp {
107636: Token eOperator; /* "like" or "glob" or "regexp" */
107637: int not; /* True if the NOT keyword is present */
107638: };
107639:
107640: /*
107641: ** An instance of the following structure describes the event of a
107642: ** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT,
107643: ** TK_DELETE, or TK_INSTEAD. If the event is of the form
107644: **
107645: ** UPDATE ON (a,b,c)
107646: **
107647: ** Then the "b" IdList records the list "a,b,c".
107648: */
107649: struct TrigEvent { int a; IdList * b; };
107650:
107651: /*
107652: ** An instance of this structure holds the ATTACH key and the key type.
107653: */
107654: struct AttachKey { int type; Token key; };
107655:
107656:
107657: /* This is a utility routine used to set the ExprSpan.zStart and
107658: ** ExprSpan.zEnd values of pOut so that the span covers the complete
107659: ** range of text beginning with pStart and going to the end of pEnd.
107660: */
107661: static void spanSet(ExprSpan *pOut, Token *pStart, Token *pEnd){
107662: pOut->zStart = pStart->z;
107663: pOut->zEnd = &pEnd->z[pEnd->n];
107664: }
107665:
107666: /* Construct a new Expr object from a single identifier. Use the
107667: ** new Expr to populate pOut. Set the span of pOut to be the identifier
107668: ** that created the expression.
107669: */
107670: static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
107671: pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue);
107672: pOut->zStart = pValue->z;
107673: pOut->zEnd = &pValue->z[pValue->n];
107674: }
107675:
107676: /* This routine constructs a binary expression node out of two ExprSpan
107677: ** objects and uses the result to populate a new ExprSpan object.
107678: */
107679: static void spanBinaryExpr(
107680: ExprSpan *pOut, /* Write the result here */
107681: Parse *pParse, /* The parsing context. Errors accumulate here */
107682: int op, /* The binary operation */
107683: ExprSpan *pLeft, /* The left operand */
107684: ExprSpan *pRight /* The right operand */
107685: ){
107686: pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
107687: pOut->zStart = pLeft->zStart;
107688: pOut->zEnd = pRight->zEnd;
107689: }
107690:
107691: /* Construct an expression node for a unary postfix operator
107692: */
107693: static void spanUnaryPostfix(
107694: ExprSpan *pOut, /* Write the new expression node here */
107695: Parse *pParse, /* Parsing context to record errors */
107696: int op, /* The operator */
107697: ExprSpan *pOperand, /* The operand */
107698: Token *pPostOp /* The operand token for setting the span */
107699: ){
107700: pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
107701: pOut->zStart = pOperand->zStart;
107702: pOut->zEnd = &pPostOp->z[pPostOp->n];
107703: }
107704:
107705: /* A routine to convert a binary TK_IS or TK_ISNOT expression into a
107706: ** unary TK_ISNULL or TK_NOTNULL expression. */
107707: static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
107708: sqlite3 *db = pParse->db;
107709: if( db->mallocFailed==0 && pY->op==TK_NULL ){
107710: pA->op = (u8)op;
107711: sqlite3ExprDelete(db, pA->pRight);
107712: pA->pRight = 0;
107713: }
107714: }
107715:
107716: /* Construct an expression node for a unary prefix operator
107717: */
107718: static void spanUnaryPrefix(
107719: ExprSpan *pOut, /* Write the new expression node here */
107720: Parse *pParse, /* Parsing context to record errors */
107721: int op, /* The operator */
107722: ExprSpan *pOperand, /* The operand */
107723: Token *pPreOp /* The operand token for setting the span */
107724: ){
107725: pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
107726: pOut->zStart = pPreOp->z;
107727: pOut->zEnd = pOperand->zEnd;
107728: }
107729: /* Next is all token values, in a form suitable for use by makeheaders.
107730: ** This section will be null unless lemon is run with the -m switch.
107731: */
107732: /*
107733: ** These constants (all generated automatically by the parser generator)
107734: ** specify the various kinds of tokens (terminals) that the parser
107735: ** understands.
107736: **
107737: ** Each symbol here is a terminal symbol in the grammar.
107738: */
107739: /* Make sure the INTERFACE macro is defined.
107740: */
107741: #ifndef INTERFACE
107742: # define INTERFACE 1
107743: #endif
107744: /* The next thing included is series of defines which control
107745: ** various aspects of the generated parser.
107746: ** YYCODETYPE is the data type used for storing terminal
107747: ** and nonterminal numbers. "unsigned char" is
107748: ** used if there are fewer than 250 terminals
107749: ** and nonterminals. "int" is used otherwise.
107750: ** YYNOCODE is a number of type YYCODETYPE which corresponds
107751: ** to no legal terminal or nonterminal number. This
107752: ** number is used to fill in empty slots of the hash
107753: ** table.
107754: ** YYFALLBACK If defined, this indicates that one or more tokens
107755: ** have fall-back values which should be used if the
107756: ** original value of the token will not parse.
107757: ** YYACTIONTYPE is the data type used for storing terminal
107758: ** and nonterminal numbers. "unsigned char" is
107759: ** used if there are fewer than 250 rules and
107760: ** states combined. "int" is used otherwise.
107761: ** sqlite3ParserTOKENTYPE is the data type used for minor tokens given
107762: ** directly to the parser from the tokenizer.
107763: ** YYMINORTYPE is the data type used for all minor tokens.
107764: ** This is typically a union of many types, one of
107765: ** which is sqlite3ParserTOKENTYPE. The entry in the union
107766: ** for base tokens is called "yy0".
107767: ** YYSTACKDEPTH is the maximum depth of the parser's stack. If
107768: ** zero the stack is dynamically sized using realloc()
107769: ** sqlite3ParserARG_SDECL A static variable declaration for the %extra_argument
107770: ** sqlite3ParserARG_PDECL A parameter declaration for the %extra_argument
107771: ** sqlite3ParserARG_STORE Code to store %extra_argument into yypParser
107772: ** sqlite3ParserARG_FETCH Code to extract %extra_argument from yypParser
107773: ** YYNSTATE the combined number of states.
107774: ** YYNRULE the number of rules in the grammar
107775: ** YYERRORSYMBOL is the code number of the error symbol. If not
107776: ** defined, then do no error processing.
107777: */
107778: #define YYCODETYPE unsigned char
107779: #define YYNOCODE 253
107780: #define YYACTIONTYPE unsigned short int
107781: #define YYWILDCARD 67
107782: #define sqlite3ParserTOKENTYPE Token
107783: typedef union {
107784: int yyinit;
107785: sqlite3ParserTOKENTYPE yy0;
107786: int yy4;
107787: struct TrigEvent yy90;
107788: ExprSpan yy118;
107789: TriggerStep* yy203;
107790: u8 yy210;
107791: struct {int value; int mask;} yy215;
107792: SrcList* yy259;
107793: struct LimitVal yy292;
107794: Expr* yy314;
107795: ExprList* yy322;
107796: struct LikeOp yy342;
107797: IdList* yy384;
107798: Select* yy387;
107799: } YYMINORTYPE;
107800: #ifndef YYSTACKDEPTH
107801: #define YYSTACKDEPTH 100
107802: #endif
107803: #define sqlite3ParserARG_SDECL Parse *pParse;
107804: #define sqlite3ParserARG_PDECL ,Parse *pParse
107805: #define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
107806: #define sqlite3ParserARG_STORE yypParser->pParse = pParse
107807: #define YYNSTATE 630
107808: #define YYNRULE 329
107809: #define YYFALLBACK 1
107810: #define YY_NO_ACTION (YYNSTATE+YYNRULE+2)
107811: #define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1)
107812: #define YY_ERROR_ACTION (YYNSTATE+YYNRULE)
107813:
107814: /* The yyzerominor constant is used to initialize instances of
107815: ** YYMINORTYPE objects to zero. */
107816: static const YYMINORTYPE yyzerominor = { 0 };
107817:
107818: /* Define the yytestcase() macro to be a no-op if is not already defined
107819: ** otherwise.
107820: **
107821: ** Applications can choose to define yytestcase() in the %include section
107822: ** to a macro that can assist in verifying code coverage. For production
107823: ** code the yytestcase() macro should be turned off. But it is useful
107824: ** for testing.
107825: */
107826: #ifndef yytestcase
107827: # define yytestcase(X)
107828: #endif
107829:
107830:
107831: /* Next are the tables used to determine what action to take based on the
107832: ** current state and lookahead token. These tables are used to implement
107833: ** functions that take a state number and lookahead value and return an
107834: ** action integer.
107835: **
107836: ** Suppose the action integer is N. Then the action is determined as
107837: ** follows
107838: **
107839: ** 0 <= N < YYNSTATE Shift N. That is, push the lookahead
107840: ** token onto the stack and goto state N.
107841: **
107842: ** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE.
107843: **
107844: ** N == YYNSTATE+YYNRULE A syntax error has occurred.
107845: **
107846: ** N == YYNSTATE+YYNRULE+1 The parser accepts its input.
107847: **
107848: ** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused
107849: ** slots in the yy_action[] table.
107850: **
107851: ** The action table is constructed as a single large table named yy_action[].
107852: ** Given state S and lookahead X, the action is computed as
107853: **
107854: ** yy_action[ yy_shift_ofst[S] + X ]
107855: **
107856: ** If the index value yy_shift_ofst[S]+X is out of range or if the value
107857: ** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S]
107858: ** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table
107859: ** and that yy_default[S] should be used instead.
107860: **
107861: ** The formula above is for computing the action when the lookahead is
107862: ** a terminal symbol. If the lookahead is a non-terminal (as occurs after
107863: ** a reduce action) then the yy_reduce_ofst[] array is used in place of
107864: ** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of
107865: ** YY_SHIFT_USE_DFLT.
107866: **
107867: ** The following are the tables generated in this section:
107868: **
107869: ** yy_action[] A single table containing all actions.
107870: ** yy_lookahead[] A table containing the lookahead for each entry in
107871: ** yy_action. Used to detect hash collisions.
107872: ** yy_shift_ofst[] For each state, the offset into yy_action for
107873: ** shifting terminals.
107874: ** yy_reduce_ofst[] For each state, the offset into yy_action for
107875: ** shifting non-terminals after a reduce.
107876: ** yy_default[] Default action for each state.
107877: */
107878: #define YY_ACTTAB_COUNT (1557)
107879: static const YYACTIONTYPE yy_action[] = {
107880: /* 0 */ 313, 960, 186, 419, 2, 172, 627, 597, 55, 55,
107881: /* 10 */ 55, 55, 48, 53, 53, 53, 53, 52, 52, 51,
107882: /* 20 */ 51, 51, 50, 238, 302, 283, 623, 622, 516, 515,
107883: /* 30 */ 590, 584, 55, 55, 55, 55, 282, 53, 53, 53,
107884: /* 40 */ 53, 52, 52, 51, 51, 51, 50, 238, 6, 56,
107885: /* 50 */ 57, 47, 582, 581, 583, 583, 54, 54, 55, 55,
107886: /* 60 */ 55, 55, 608, 53, 53, 53, 53, 52, 52, 51,
107887: /* 70 */ 51, 51, 50, 238, 313, 597, 409, 330, 579, 579,
107888: /* 80 */ 32, 53, 53, 53, 53, 52, 52, 51, 51, 51,
107889: /* 90 */ 50, 238, 330, 217, 620, 619, 166, 411, 624, 382,
107890: /* 100 */ 379, 378, 7, 491, 590, 584, 200, 199, 198, 58,
107891: /* 110 */ 377, 300, 414, 621, 481, 66, 623, 622, 621, 580,
107892: /* 120 */ 254, 601, 94, 56, 57, 47, 582, 581, 583, 583,
107893: /* 130 */ 54, 54, 55, 55, 55, 55, 671, 53, 53, 53,
107894: /* 140 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 532,
107895: /* 150 */ 226, 506, 507, 133, 177, 139, 284, 385, 279, 384,
107896: /* 160 */ 169, 197, 342, 398, 251, 226, 253, 275, 388, 167,
107897: /* 170 */ 139, 284, 385, 279, 384, 169, 570, 236, 590, 584,
107898: /* 180 */ 672, 240, 275, 157, 620, 619, 554, 437, 51, 51,
107899: /* 190 */ 51, 50, 238, 343, 439, 553, 438, 56, 57, 47,
107900: /* 200 */ 582, 581, 583, 583, 54, 54, 55, 55, 55, 55,
107901: /* 210 */ 465, 53, 53, 53, 53, 52, 52, 51, 51, 51,
107902: /* 220 */ 50, 238, 313, 390, 52, 52, 51, 51, 51, 50,
107903: /* 230 */ 238, 391, 166, 491, 566, 382, 379, 378, 409, 440,
107904: /* 240 */ 579, 579, 252, 440, 607, 66, 377, 513, 621, 49,
107905: /* 250 */ 46, 147, 590, 584, 621, 16, 466, 189, 621, 441,
107906: /* 260 */ 442, 673, 526, 441, 340, 577, 595, 64, 194, 482,
107907: /* 270 */ 434, 56, 57, 47, 582, 581, 583, 583, 54, 54,
107908: /* 280 */ 55, 55, 55, 55, 30, 53, 53, 53, 53, 52,
107909: /* 290 */ 52, 51, 51, 51, 50, 238, 313, 593, 593, 593,
107910: /* 300 */ 387, 578, 606, 493, 259, 351, 258, 411, 1, 623,
107911: /* 310 */ 622, 496, 623, 622, 65, 240, 623, 622, 597, 443,
107912: /* 320 */ 237, 239, 414, 341, 237, 602, 590, 584, 18, 603,
107913: /* 330 */ 166, 601, 87, 382, 379, 378, 67, 623, 622, 38,
107914: /* 340 */ 623, 622, 176, 270, 377, 56, 57, 47, 582, 581,
107915: /* 350 */ 583, 583, 54, 54, 55, 55, 55, 55, 175, 53,
107916: /* 360 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
107917: /* 370 */ 313, 396, 233, 411, 531, 565, 317, 620, 619, 44,
107918: /* 380 */ 620, 619, 240, 206, 620, 619, 597, 266, 414, 268,
107919: /* 390 */ 409, 597, 579, 579, 352, 184, 505, 601, 73, 533,
107920: /* 400 */ 590, 584, 466, 548, 190, 620, 619, 576, 620, 619,
107921: /* 410 */ 547, 383, 551, 35, 332, 575, 574, 600, 504, 56,
107922: /* 420 */ 57, 47, 582, 581, 583, 583, 54, 54, 55, 55,
107923: /* 430 */ 55, 55, 567, 53, 53, 53, 53, 52, 52, 51,
107924: /* 440 */ 51, 51, 50, 238, 313, 411, 561, 561, 528, 364,
107925: /* 450 */ 259, 351, 258, 183, 361, 549, 524, 374, 411, 597,
107926: /* 460 */ 414, 240, 560, 560, 409, 604, 579, 579, 328, 601,
107927: /* 470 */ 93, 623, 622, 414, 590, 584, 237, 564, 559, 559,
107928: /* 480 */ 520, 402, 601, 87, 409, 210, 579, 579, 168, 421,
107929: /* 490 */ 950, 519, 950, 56, 57, 47, 582, 581, 583, 583,
107930: /* 500 */ 54, 54, 55, 55, 55, 55, 192, 53, 53, 53,
107931: /* 510 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 600,
107932: /* 520 */ 293, 563, 511, 234, 357, 146, 475, 475, 367, 411,
107933: /* 530 */ 562, 411, 358, 542, 425, 171, 411, 215, 144, 620,
107934: /* 540 */ 619, 544, 318, 353, 414, 203, 414, 275, 590, 584,
107935: /* 550 */ 549, 414, 174, 601, 94, 601, 79, 558, 471, 61,
107936: /* 560 */ 601, 79, 421, 949, 350, 949, 34, 56, 57, 47,
107937: /* 570 */ 582, 581, 583, 583, 54, 54, 55, 55, 55, 55,
107938: /* 580 */ 535, 53, 53, 53, 53, 52, 52, 51, 51, 51,
107939: /* 590 */ 50, 238, 313, 307, 424, 394, 272, 49, 46, 147,
107940: /* 600 */ 349, 322, 4, 411, 491, 312, 321, 425, 568, 492,
107941: /* 610 */ 216, 264, 407, 575, 574, 429, 66, 549, 414, 621,
107942: /* 620 */ 540, 602, 590, 584, 13, 603, 621, 601, 72, 12,
107943: /* 630 */ 618, 617, 616, 202, 210, 621, 546, 469, 422, 319,
107944: /* 640 */ 148, 56, 57, 47, 582, 581, 583, 583, 54, 54,
107945: /* 650 */ 55, 55, 55, 55, 338, 53, 53, 53, 53, 52,
107946: /* 660 */ 52, 51, 51, 51, 50, 238, 313, 600, 600, 411,
107947: /* 670 */ 39, 21, 37, 170, 237, 875, 411, 572, 572, 201,
107948: /* 680 */ 144, 473, 538, 331, 414, 474, 143, 146, 630, 628,
107949: /* 690 */ 334, 414, 353, 601, 68, 168, 590, 584, 132, 365,
107950: /* 700 */ 601, 96, 307, 423, 530, 336, 49, 46, 147, 568,
107951: /* 710 */ 406, 216, 549, 360, 529, 56, 57, 47, 582, 581,
107952: /* 720 */ 583, 583, 54, 54, 55, 55, 55, 55, 411, 53,
107953: /* 730 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
107954: /* 740 */ 313, 411, 605, 414, 484, 510, 172, 422, 597, 318,
107955: /* 750 */ 496, 485, 601, 99, 411, 142, 414, 411, 231, 411,
107956: /* 760 */ 540, 411, 359, 629, 2, 601, 97, 426, 308, 414,
107957: /* 770 */ 590, 584, 414, 20, 414, 621, 414, 621, 601, 106,
107958: /* 780 */ 503, 601, 105, 601, 108, 601, 109, 204, 28, 56,
107959: /* 790 */ 57, 47, 582, 581, 583, 583, 54, 54, 55, 55,
107960: /* 800 */ 55, 55, 411, 53, 53, 53, 53, 52, 52, 51,
107961: /* 810 */ 51, 51, 50, 238, 313, 411, 597, 414, 411, 276,
107962: /* 820 */ 214, 600, 411, 366, 213, 381, 601, 134, 274, 500,
107963: /* 830 */ 414, 167, 130, 414, 621, 411, 354, 414, 376, 601,
107964: /* 840 */ 135, 129, 601, 100, 590, 584, 601, 104, 522, 521,
107965: /* 850 */ 414, 621, 224, 273, 600, 167, 327, 282, 600, 601,
107966: /* 860 */ 103, 468, 521, 56, 57, 47, 582, 581, 583, 583,
107967: /* 870 */ 54, 54, 55, 55, 55, 55, 411, 53, 53, 53,
107968: /* 880 */ 53, 52, 52, 51, 51, 51, 50, 238, 313, 411,
107969: /* 890 */ 27, 414, 411, 375, 276, 167, 359, 544, 50, 238,
107970: /* 900 */ 601, 95, 128, 223, 414, 411, 165, 414, 411, 621,
107971: /* 910 */ 411, 621, 612, 601, 102, 372, 601, 76, 590, 584,
107972: /* 920 */ 414, 570, 236, 414, 470, 414, 167, 621, 188, 601,
107973: /* 930 */ 98, 225, 601, 138, 601, 137, 232, 56, 45, 47,
107974: /* 940 */ 582, 581, 583, 583, 54, 54, 55, 55, 55, 55,
107975: /* 950 */ 411, 53, 53, 53, 53, 52, 52, 51, 51, 51,
107976: /* 960 */ 50, 238, 313, 276, 276, 414, 411, 276, 544, 459,
107977: /* 970 */ 359, 171, 209, 479, 601, 136, 628, 334, 621, 621,
107978: /* 980 */ 125, 414, 621, 368, 411, 621, 257, 540, 589, 588,
107979: /* 990 */ 601, 75, 590, 584, 458, 446, 23, 23, 124, 414,
107980: /* 1000 */ 326, 325, 621, 427, 324, 309, 600, 288, 601, 92,
107981: /* 1010 */ 586, 585, 57, 47, 582, 581, 583, 583, 54, 54,
107982: /* 1020 */ 55, 55, 55, 55, 411, 53, 53, 53, 53, 52,
107983: /* 1030 */ 52, 51, 51, 51, 50, 238, 313, 587, 411, 414,
107984: /* 1040 */ 411, 207, 611, 476, 171, 472, 160, 123, 601, 91,
107985: /* 1050 */ 323, 261, 15, 414, 464, 414, 411, 621, 411, 354,
107986: /* 1060 */ 222, 411, 601, 74, 601, 90, 590, 584, 159, 264,
107987: /* 1070 */ 158, 414, 461, 414, 621, 600, 414, 121, 120, 25,
107988: /* 1080 */ 601, 89, 601, 101, 621, 601, 88, 47, 582, 581,
107989: /* 1090 */ 583, 583, 54, 54, 55, 55, 55, 55, 544, 53,
107990: /* 1100 */ 53, 53, 53, 52, 52, 51, 51, 51, 50, 238,
107991: /* 1110 */ 43, 405, 263, 3, 610, 264, 140, 415, 622, 24,
107992: /* 1120 */ 410, 11, 456, 594, 118, 155, 219, 452, 408, 621,
107993: /* 1130 */ 621, 621, 156, 43, 405, 621, 3, 286, 621, 113,
107994: /* 1140 */ 415, 622, 111, 445, 411, 400, 557, 403, 545, 10,
107995: /* 1150 */ 411, 408, 264, 110, 205, 436, 541, 566, 453, 414,
107996: /* 1160 */ 621, 621, 63, 621, 435, 414, 411, 621, 601, 94,
107997: /* 1170 */ 403, 621, 411, 337, 601, 86, 150, 40, 41, 534,
107998: /* 1180 */ 566, 414, 242, 264, 42, 413, 412, 414, 600, 595,
107999: /* 1190 */ 601, 85, 191, 333, 107, 451, 601, 84, 621, 539,
108000: /* 1200 */ 40, 41, 420, 230, 411, 149, 316, 42, 413, 412,
108001: /* 1210 */ 398, 127, 595, 315, 621, 399, 278, 625, 181, 414,
108002: /* 1220 */ 593, 593, 593, 592, 591, 14, 450, 411, 601, 71,
108003: /* 1230 */ 240, 621, 43, 405, 264, 3, 615, 180, 264, 415,
108004: /* 1240 */ 622, 614, 414, 593, 593, 593, 592, 591, 14, 621,
108005: /* 1250 */ 408, 601, 70, 621, 417, 33, 405, 613, 3, 411,
108006: /* 1260 */ 264, 411, 415, 622, 418, 626, 178, 509, 8, 403,
108007: /* 1270 */ 241, 416, 126, 408, 414, 621, 414, 449, 208, 566,
108008: /* 1280 */ 240, 221, 621, 601, 83, 601, 82, 599, 297, 277,
108009: /* 1290 */ 296, 30, 403, 31, 395, 264, 295, 397, 489, 40,
108010: /* 1300 */ 41, 411, 566, 220, 621, 294, 42, 413, 412, 271,
108011: /* 1310 */ 621, 595, 600, 621, 59, 60, 414, 269, 267, 623,
108012: /* 1320 */ 622, 36, 40, 41, 621, 601, 81, 598, 235, 42,
108013: /* 1330 */ 413, 412, 621, 621, 595, 265, 344, 411, 248, 556,
108014: /* 1340 */ 173, 185, 593, 593, 593, 592, 591, 14, 218, 29,
108015: /* 1350 */ 621, 543, 414, 305, 304, 303, 179, 301, 411, 566,
108016: /* 1360 */ 454, 601, 80, 289, 335, 593, 593, 593, 592, 591,
108017: /* 1370 */ 14, 411, 287, 414, 151, 392, 246, 260, 411, 196,
108018: /* 1380 */ 195, 523, 601, 69, 411, 245, 414, 526, 537, 285,
108019: /* 1390 */ 389, 595, 621, 414, 536, 601, 17, 362, 153, 414,
108020: /* 1400 */ 466, 463, 601, 78, 154, 414, 462, 152, 601, 77,
108021: /* 1410 */ 355, 255, 621, 455, 601, 9, 621, 386, 444, 517,
108022: /* 1420 */ 247, 621, 593, 593, 593, 621, 621, 244, 621, 243,
108023: /* 1430 */ 430, 518, 292, 621, 329, 621, 145, 393, 280, 513,
108024: /* 1440 */ 291, 131, 621, 514, 621, 621, 311, 621, 259, 346,
108025: /* 1450 */ 249, 621, 621, 229, 314, 621, 228, 512, 227, 240,
108026: /* 1460 */ 494, 488, 310, 164, 487, 486, 373, 480, 163, 262,
108027: /* 1470 */ 369, 371, 162, 26, 212, 478, 477, 161, 141, 363,
108028: /* 1480 */ 467, 122, 339, 187, 119, 348, 347, 117, 116, 115,
108029: /* 1490 */ 114, 112, 182, 457, 320, 22, 433, 432, 448, 19,
108030: /* 1500 */ 609, 431, 428, 62, 193, 596, 573, 298, 555, 552,
108031: /* 1510 */ 571, 404, 290, 380, 498, 510, 495, 306, 281, 499,
108032: /* 1520 */ 250, 5, 497, 460, 345, 447, 569, 550, 238, 299,
108033: /* 1530 */ 527, 525, 508, 961, 502, 501, 961, 401, 961, 211,
108034: /* 1540 */ 490, 356, 256, 961, 483, 961, 961, 961, 961, 961,
108035: /* 1550 */ 961, 961, 961, 961, 961, 961, 370,
108036: };
108037: static const YYCODETYPE yy_lookahead[] = {
108038: /* 0 */ 19, 142, 143, 144, 145, 24, 1, 26, 77, 78,
108039: /* 10 */ 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
108040: /* 20 */ 89, 90, 91, 92, 15, 98, 26, 27, 7, 8,
108041: /* 30 */ 49, 50, 77, 78, 79, 80, 109, 82, 83, 84,
108042: /* 40 */ 85, 86, 87, 88, 89, 90, 91, 92, 22, 68,
108043: /* 50 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
108044: /* 60 */ 79, 80, 23, 82, 83, 84, 85, 86, 87, 88,
108045: /* 70 */ 89, 90, 91, 92, 19, 94, 112, 19, 114, 115,
108046: /* 80 */ 25, 82, 83, 84, 85, 86, 87, 88, 89, 90,
108047: /* 90 */ 91, 92, 19, 22, 94, 95, 96, 150, 150, 99,
108048: /* 100 */ 100, 101, 76, 150, 49, 50, 105, 106, 107, 54,
108049: /* 110 */ 110, 158, 165, 165, 161, 162, 26, 27, 165, 113,
108050: /* 120 */ 16, 174, 175, 68, 69, 70, 71, 72, 73, 74,
108051: /* 130 */ 75, 76, 77, 78, 79, 80, 118, 82, 83, 84,
108052: /* 140 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 23,
108053: /* 150 */ 92, 97, 98, 24, 96, 97, 98, 99, 100, 101,
108054: /* 160 */ 102, 25, 97, 216, 60, 92, 62, 109, 221, 25,
108055: /* 170 */ 97, 98, 99, 100, 101, 102, 86, 87, 49, 50,
108056: /* 180 */ 118, 116, 109, 25, 94, 95, 32, 97, 88, 89,
108057: /* 190 */ 90, 91, 92, 128, 104, 41, 106, 68, 69, 70,
108058: /* 200 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
108059: /* 210 */ 11, 82, 83, 84, 85, 86, 87, 88, 89, 90,
108060: /* 220 */ 91, 92, 19, 19, 86, 87, 88, 89, 90, 91,
108061: /* 230 */ 92, 27, 96, 150, 66, 99, 100, 101, 112, 150,
108062: /* 240 */ 114, 115, 138, 150, 161, 162, 110, 103, 165, 222,
108063: /* 250 */ 223, 224, 49, 50, 165, 22, 57, 24, 165, 170,
108064: /* 260 */ 171, 118, 94, 170, 171, 23, 98, 25, 185, 186,
108065: /* 270 */ 243, 68, 69, 70, 71, 72, 73, 74, 75, 76,
108066: /* 280 */ 77, 78, 79, 80, 126, 82, 83, 84, 85, 86,
108067: /* 290 */ 87, 88, 89, 90, 91, 92, 19, 129, 130, 131,
108068: /* 300 */ 88, 23, 172, 173, 105, 106, 107, 150, 22, 26,
108069: /* 310 */ 27, 181, 26, 27, 22, 116, 26, 27, 26, 230,
108070: /* 320 */ 231, 197, 165, 230, 231, 113, 49, 50, 204, 117,
108071: /* 330 */ 96, 174, 175, 99, 100, 101, 22, 26, 27, 136,
108072: /* 340 */ 26, 27, 118, 16, 110, 68, 69, 70, 71, 72,
108073: /* 350 */ 73, 74, 75, 76, 77, 78, 79, 80, 118, 82,
108074: /* 360 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
108075: /* 370 */ 19, 214, 215, 150, 23, 23, 155, 94, 95, 22,
108076: /* 380 */ 94, 95, 116, 160, 94, 95, 94, 60, 165, 62,
108077: /* 390 */ 112, 26, 114, 115, 128, 23, 36, 174, 175, 88,
108078: /* 400 */ 49, 50, 57, 120, 22, 94, 95, 23, 94, 95,
108079: /* 410 */ 120, 51, 25, 136, 169, 170, 171, 194, 58, 68,
108080: /* 420 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
108081: /* 430 */ 79, 80, 23, 82, 83, 84, 85, 86, 87, 88,
108082: /* 440 */ 89, 90, 91, 92, 19, 150, 12, 12, 23, 228,
108083: /* 450 */ 105, 106, 107, 23, 233, 25, 165, 19, 150, 94,
108084: /* 460 */ 165, 116, 28, 28, 112, 174, 114, 115, 108, 174,
108085: /* 470 */ 175, 26, 27, 165, 49, 50, 231, 11, 44, 44,
108086: /* 480 */ 46, 46, 174, 175, 112, 160, 114, 115, 50, 22,
108087: /* 490 */ 23, 57, 25, 68, 69, 70, 71, 72, 73, 74,
108088: /* 500 */ 75, 76, 77, 78, 79, 80, 119, 82, 83, 84,
108089: /* 510 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 194,
108090: /* 520 */ 225, 23, 23, 215, 19, 95, 105, 106, 107, 150,
108091: /* 530 */ 23, 150, 27, 23, 67, 25, 150, 206, 207, 94,
108092: /* 540 */ 95, 166, 104, 218, 165, 22, 165, 109, 49, 50,
108093: /* 550 */ 120, 165, 25, 174, 175, 174, 175, 23, 21, 234,
108094: /* 560 */ 174, 175, 22, 23, 239, 25, 25, 68, 69, 70,
108095: /* 570 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
108096: /* 580 */ 205, 82, 83, 84, 85, 86, 87, 88, 89, 90,
108097: /* 590 */ 91, 92, 19, 22, 23, 216, 23, 222, 223, 224,
108098: /* 600 */ 63, 220, 35, 150, 150, 163, 220, 67, 166, 167,
108099: /* 610 */ 168, 150, 169, 170, 171, 161, 162, 25, 165, 165,
108100: /* 620 */ 150, 113, 49, 50, 25, 117, 165, 174, 175, 35,
108101: /* 630 */ 7, 8, 9, 160, 160, 165, 120, 100, 67, 247,
108102: /* 640 */ 248, 68, 69, 70, 71, 72, 73, 74, 75, 76,
108103: /* 650 */ 77, 78, 79, 80, 193, 82, 83, 84, 85, 86,
108104: /* 660 */ 87, 88, 89, 90, 91, 92, 19, 194, 194, 150,
108105: /* 670 */ 135, 24, 137, 35, 231, 138, 150, 129, 130, 206,
108106: /* 680 */ 207, 30, 27, 213, 165, 34, 118, 95, 0, 1,
108107: /* 690 */ 2, 165, 218, 174, 175, 50, 49, 50, 22, 48,
108108: /* 700 */ 174, 175, 22, 23, 23, 244, 222, 223, 224, 166,
108109: /* 710 */ 167, 168, 120, 239, 23, 68, 69, 70, 71, 72,
108110: /* 720 */ 73, 74, 75, 76, 77, 78, 79, 80, 150, 82,
108111: /* 730 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
108112: /* 740 */ 19, 150, 173, 165, 181, 182, 24, 67, 26, 104,
108113: /* 750 */ 181, 188, 174, 175, 150, 39, 165, 150, 52, 150,
108114: /* 760 */ 150, 150, 150, 144, 145, 174, 175, 249, 250, 165,
108115: /* 770 */ 49, 50, 165, 52, 165, 165, 165, 165, 174, 175,
108116: /* 780 */ 29, 174, 175, 174, 175, 174, 175, 160, 22, 68,
108117: /* 790 */ 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
108118: /* 800 */ 79, 80, 150, 82, 83, 84, 85, 86, 87, 88,
108119: /* 810 */ 89, 90, 91, 92, 19, 150, 94, 165, 150, 150,
108120: /* 820 */ 160, 194, 150, 213, 160, 52, 174, 175, 23, 23,
108121: /* 830 */ 165, 25, 22, 165, 165, 150, 150, 165, 52, 174,
108122: /* 840 */ 175, 22, 174, 175, 49, 50, 174, 175, 190, 191,
108123: /* 850 */ 165, 165, 240, 23, 194, 25, 187, 109, 194, 174,
108124: /* 860 */ 175, 190, 191, 68, 69, 70, 71, 72, 73, 74,
108125: /* 870 */ 75, 76, 77, 78, 79, 80, 150, 82, 83, 84,
108126: /* 880 */ 85, 86, 87, 88, 89, 90, 91, 92, 19, 150,
108127: /* 890 */ 22, 165, 150, 23, 150, 25, 150, 166, 91, 92,
108128: /* 900 */ 174, 175, 22, 217, 165, 150, 102, 165, 150, 165,
108129: /* 910 */ 150, 165, 150, 174, 175, 19, 174, 175, 49, 50,
108130: /* 920 */ 165, 86, 87, 165, 23, 165, 25, 165, 24, 174,
108131: /* 930 */ 175, 187, 174, 175, 174, 175, 205, 68, 69, 70,
108132: /* 940 */ 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
108133: /* 950 */ 150, 82, 83, 84, 85, 86, 87, 88, 89, 90,
108134: /* 960 */ 91, 92, 19, 150, 150, 165, 150, 150, 166, 23,
108135: /* 970 */ 150, 25, 160, 20, 174, 175, 1, 2, 165, 165,
108136: /* 980 */ 104, 165, 165, 43, 150, 165, 240, 150, 49, 50,
108137: /* 990 */ 174, 175, 49, 50, 23, 23, 25, 25, 53, 165,
108138: /* 1000 */ 187, 187, 165, 23, 187, 25, 194, 205, 174, 175,
108139: /* 1010 */ 71, 72, 69, 70, 71, 72, 73, 74, 75, 76,
108140: /* 1020 */ 77, 78, 79, 80, 150, 82, 83, 84, 85, 86,
108141: /* 1030 */ 87, 88, 89, 90, 91, 92, 19, 98, 150, 165,
108142: /* 1040 */ 150, 160, 150, 59, 25, 53, 104, 22, 174, 175,
108143: /* 1050 */ 213, 138, 5, 165, 1, 165, 150, 165, 150, 150,
108144: /* 1060 */ 240, 150, 174, 175, 174, 175, 49, 50, 118, 150,
108145: /* 1070 */ 35, 165, 27, 165, 165, 194, 165, 108, 127, 76,
108146: /* 1080 */ 174, 175, 174, 175, 165, 174, 175, 70, 71, 72,
108147: /* 1090 */ 73, 74, 75, 76, 77, 78, 79, 80, 166, 82,
108148: /* 1100 */ 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
108149: /* 1110 */ 19, 20, 193, 22, 150, 150, 150, 26, 27, 76,
108150: /* 1120 */ 150, 22, 1, 150, 119, 121, 217, 20, 37, 165,
108151: /* 1130 */ 165, 165, 16, 19, 20, 165, 22, 205, 165, 119,
108152: /* 1140 */ 26, 27, 108, 128, 150, 150, 150, 56, 150, 22,
108153: /* 1150 */ 150, 37, 150, 127, 160, 23, 150, 66, 193, 165,
108154: /* 1160 */ 165, 165, 16, 165, 23, 165, 150, 165, 174, 175,
108155: /* 1170 */ 56, 165, 150, 65, 174, 175, 15, 86, 87, 88,
108156: /* 1180 */ 66, 165, 140, 150, 93, 94, 95, 165, 194, 98,
108157: /* 1190 */ 174, 175, 22, 3, 164, 193, 174, 175, 165, 150,
108158: /* 1200 */ 86, 87, 4, 180, 150, 248, 251, 93, 94, 95,
108159: /* 1210 */ 216, 180, 98, 251, 165, 221, 150, 149, 6, 165,
108160: /* 1220 */ 129, 130, 131, 132, 133, 134, 193, 150, 174, 175,
108161: /* 1230 */ 116, 165, 19, 20, 150, 22, 149, 151, 150, 26,
108162: /* 1240 */ 27, 149, 165, 129, 130, 131, 132, 133, 134, 165,
108163: /* 1250 */ 37, 174, 175, 165, 149, 19, 20, 13, 22, 150,
108164: /* 1260 */ 150, 150, 26, 27, 146, 147, 151, 150, 25, 56,
108165: /* 1270 */ 152, 159, 154, 37, 165, 165, 165, 193, 160, 66,
108166: /* 1280 */ 116, 193, 165, 174, 175, 174, 175, 194, 199, 150,
108167: /* 1290 */ 200, 126, 56, 124, 123, 150, 201, 122, 150, 86,
108168: /* 1300 */ 87, 150, 66, 193, 165, 202, 93, 94, 95, 150,
108169: /* 1310 */ 165, 98, 194, 165, 125, 22, 165, 150, 150, 26,
108170: /* 1320 */ 27, 135, 86, 87, 165, 174, 175, 203, 226, 93,
108171: /* 1330 */ 94, 95, 165, 165, 98, 150, 218, 150, 193, 157,
108172: /* 1340 */ 118, 157, 129, 130, 131, 132, 133, 134, 5, 104,
108173: /* 1350 */ 165, 211, 165, 10, 11, 12, 13, 14, 150, 66,
108174: /* 1360 */ 17, 174, 175, 210, 246, 129, 130, 131, 132, 133,
108175: /* 1370 */ 134, 150, 210, 165, 31, 121, 33, 150, 150, 86,
108176: /* 1380 */ 87, 176, 174, 175, 150, 42, 165, 94, 211, 210,
108177: /* 1390 */ 150, 98, 165, 165, 211, 174, 175, 150, 55, 165,
108178: /* 1400 */ 57, 150, 174, 175, 61, 165, 150, 64, 174, 175,
108179: /* 1410 */ 150, 150, 165, 150, 174, 175, 165, 104, 150, 184,
108180: /* 1420 */ 150, 165, 129, 130, 131, 165, 165, 150, 165, 150,
108181: /* 1430 */ 150, 176, 150, 165, 47, 165, 150, 150, 176, 103,
108182: /* 1440 */ 150, 22, 165, 178, 165, 165, 179, 165, 105, 106,
108183: /* 1450 */ 107, 165, 165, 229, 111, 165, 92, 176, 229, 116,
108184: /* 1460 */ 184, 176, 179, 156, 176, 176, 18, 157, 156, 237,
108185: /* 1470 */ 45, 157, 156, 135, 157, 157, 238, 156, 68, 157,
108186: /* 1480 */ 189, 189, 139, 219, 22, 157, 18, 192, 192, 192,
108187: /* 1490 */ 192, 189, 219, 199, 157, 242, 40, 157, 199, 242,
108188: /* 1500 */ 153, 157, 38, 245, 196, 166, 232, 198, 177, 177,
108189: /* 1510 */ 232, 227, 209, 178, 166, 182, 166, 148, 177, 177,
108190: /* 1520 */ 209, 196, 177, 199, 209, 199, 166, 208, 92, 195,
108191: /* 1530 */ 174, 174, 183, 252, 183, 183, 252, 191, 252, 235,
108192: /* 1540 */ 186, 241, 241, 252, 186, 252, 252, 252, 252, 252,
108193: /* 1550 */ 252, 252, 252, 252, 252, 252, 236,
108194: };
108195: #define YY_SHIFT_USE_DFLT (-74)
108196: #define YY_SHIFT_COUNT (418)
108197: #define YY_SHIFT_MIN (-73)
108198: #define YY_SHIFT_MAX (1468)
108199: static const short yy_shift_ofst[] = {
108200: /* 0 */ 975, 1114, 1343, 1114, 1213, 1213, 90, 90, 0, -19,
108201: /* 10 */ 1213, 1213, 1213, 1213, 1213, 345, 445, 721, 1091, 1213,
108202: /* 20 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
108203: /* 30 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
108204: /* 40 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1236, 1213, 1213,
108205: /* 50 */ 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213, 1213,
108206: /* 60 */ 1213, 199, 445, 445, 835, 835, 365, 1164, 55, 647,
108207: /* 70 */ 573, 499, 425, 351, 277, 203, 129, 795, 795, 795,
108208: /* 80 */ 795, 795, 795, 795, 795, 795, 795, 795, 795, 795,
108209: /* 90 */ 795, 795, 795, 795, 795, 869, 795, 943, 1017, 1017,
108210: /* 100 */ -69, -45, -45, -45, -45, -45, -1, 58, 138, 100,
108211: /* 110 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
108212: /* 120 */ 445, 445, 445, 445, 445, 445, 537, 438, 445, 445,
108213: /* 130 */ 445, 445, 445, 365, 807, 1436, -74, -74, -74, 1293,
108214: /* 140 */ 73, 434, 434, 311, 314, 290, 283, 286, 540, 467,
108215: /* 150 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
108216: /* 160 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
108217: /* 170 */ 445, 445, 445, 445, 445, 445, 445, 445, 445, 445,
108218: /* 180 */ 445, 445, 65, 722, 722, 722, 688, 266, 1164, 1164,
108219: /* 190 */ 1164, -74, -74, -74, 136, 168, 168, 234, 360, 360,
108220: /* 200 */ 360, 430, 372, 435, 352, 278, 126, -36, -36, -36,
108221: /* 210 */ -36, 421, 651, -36, -36, 592, 292, 212, 623, 158,
108222: /* 220 */ 204, 204, 505, 158, 505, 144, 365, 154, 365, 154,
108223: /* 230 */ 645, 154, 204, 154, 154, 535, 548, 548, 365, 387,
108224: /* 240 */ 508, 233, 1464, 1222, 1222, 1456, 1456, 1222, 1462, 1410,
108225: /* 250 */ 1165, 1468, 1468, 1468, 1468, 1222, 1165, 1462, 1410, 1410,
108226: /* 260 */ 1222, 1448, 1338, 1425, 1222, 1222, 1448, 1222, 1448, 1222,
108227: /* 270 */ 1448, 1419, 1313, 1313, 1313, 1387, 1364, 1364, 1419, 1313,
108228: /* 280 */ 1336, 1313, 1387, 1313, 1313, 1254, 1245, 1254, 1245, 1254,
108229: /* 290 */ 1245, 1222, 1222, 1186, 1189, 1175, 1169, 1171, 1165, 1164,
108230: /* 300 */ 1243, 1244, 1244, 1212, 1212, 1212, 1212, -74, -74, -74,
108231: /* 310 */ -74, -74, -74, 939, 104, 680, 571, 327, 1, 980,
108232: /* 320 */ 26, 972, 971, 946, 901, 870, 830, 806, 54, 21,
108233: /* 330 */ -73, 510, 242, 1198, 1190, 1170, 1042, 1161, 1108, 1146,
108234: /* 340 */ 1141, 1132, 1015, 1127, 1026, 1034, 1020, 1107, 1004, 1116,
108235: /* 350 */ 1121, 1005, 1099, 951, 1043, 1003, 969, 1045, 1035, 950,
108236: /* 360 */ 1053, 1047, 1025, 942, 913, 992, 1019, 945, 984, 940,
108237: /* 370 */ 876, 904, 953, 896, 748, 804, 880, 786, 868, 819,
108238: /* 380 */ 805, 810, 773, 751, 766, 706, 716, 691, 681, 568,
108239: /* 390 */ 655, 638, 676, 516, 541, 594, 599, 567, 541, 534,
108240: /* 400 */ 507, 527, 498, 523, 466, 382, 409, 384, 357, 6,
108241: /* 410 */ 240, 224, 143, 62, 18, 71, 39, 9, 5,
108242: };
108243: #define YY_REDUCE_USE_DFLT (-142)
108244: #define YY_REDUCE_COUNT (312)
108245: #define YY_REDUCE_MIN (-141)
108246: #define YY_REDUCE_MAX (1369)
108247: static const short yy_reduce_ofst[] = {
108248: /* 0 */ -141, 994, 1118, 223, 157, -53, 93, 89, 83, 375,
108249: /* 10 */ 386, 381, 379, 308, 295, 325, -47, 27, 1240, 1234,
108250: /* 20 */ 1228, 1221, 1208, 1187, 1151, 1111, 1109, 1077, 1054, 1022,
108251: /* 30 */ 1016, 1000, 911, 908, 906, 890, 888, 874, 834, 816,
108252: /* 40 */ 800, 760, 758, 755, 742, 739, 726, 685, 672, 668,
108253: /* 50 */ 665, 652, 611, 609, 607, 604, 591, 578, 526, 519,
108254: /* 60 */ 453, 474, 454, 461, 443, 245, 442, 473, 484, 484,
108255: /* 70 */ 484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
108256: /* 80 */ 484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
108257: /* 90 */ 484, 484, 484, 484, 484, 484, 484, 484, 484, 484,
108258: /* 100 */ 484, 484, 484, 484, 484, 484, 484, 130, 484, 484,
108259: /* 110 */ 1145, 909, 1110, 1088, 1084, 1033, 1002, 965, 820, 837,
108260: /* 120 */ 746, 686, 612, 817, 610, 919, 221, 563, 814, 813,
108261: /* 130 */ 744, 669, 470, 543, 484, 484, 484, 484, 484, 291,
108262: /* 140 */ 569, 671, 658, 970, 1290, 1287, 1286, 1282, 518, 518,
108263: /* 150 */ 1280, 1279, 1277, 1270, 1268, 1263, 1261, 1260, 1256, 1251,
108264: /* 160 */ 1247, 1227, 1185, 1168, 1167, 1159, 1148, 1139, 1117, 1066,
108265: /* 170 */ 1049, 1006, 998, 996, 995, 973, 970, 966, 964, 892,
108266: /* 180 */ 762, -52, 881, 932, 802, 731, 619, 812, 664, 660,
108267: /* 190 */ 627, 392, 331, 124, 1358, 1357, 1356, 1354, 1352, 1351,
108268: /* 200 */ 1349, 1319, 1334, 1346, 1334, 1334, 1334, 1334, 1334, 1334,
108269: /* 210 */ 1334, 1320, 1304, 1334, 1334, 1319, 1360, 1325, 1369, 1326,
108270: /* 220 */ 1315, 1311, 1301, 1324, 1300, 1335, 1350, 1345, 1348, 1342,
108271: /* 230 */ 1333, 1341, 1303, 1332, 1331, 1284, 1278, 1274, 1339, 1309,
108272: /* 240 */ 1308, 1347, 1258, 1344, 1340, 1257, 1253, 1337, 1273, 1302,
108273: /* 250 */ 1299, 1298, 1297, 1296, 1295, 1328, 1294, 1264, 1292, 1291,
108274: /* 260 */ 1322, 1321, 1238, 1232, 1318, 1317, 1316, 1314, 1312, 1310,
108275: /* 270 */ 1307, 1283, 1289, 1288, 1285, 1276, 1229, 1224, 1267, 1281,
108276: /* 280 */ 1265, 1262, 1235, 1255, 1205, 1183, 1179, 1177, 1162, 1140,
108277: /* 290 */ 1153, 1184, 1182, 1102, 1124, 1103, 1095, 1090, 1089, 1093,
108278: /* 300 */ 1112, 1115, 1086, 1105, 1092, 1087, 1068, 962, 955, 957,
108279: /* 310 */ 1031, 1023, 1030,
108280: };
108281: static const YYACTIONTYPE yy_default[] = {
108282: /* 0 */ 635, 870, 959, 959, 959, 870, 899, 899, 959, 759,
108283: /* 10 */ 959, 959, 959, 959, 868, 959, 959, 933, 959, 959,
108284: /* 20 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108285: /* 30 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108286: /* 40 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108287: /* 50 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108288: /* 60 */ 959, 959, 959, 959, 899, 899, 674, 763, 794, 959,
108289: /* 70 */ 959, 959, 959, 959, 959, 959, 959, 932, 934, 809,
108290: /* 80 */ 808, 802, 801, 912, 774, 799, 792, 785, 796, 871,
108291: /* 90 */ 864, 865, 863, 867, 872, 959, 795, 831, 848, 830,
108292: /* 100 */ 842, 847, 854, 846, 843, 833, 832, 666, 834, 835,
108293: /* 110 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108294: /* 120 */ 959, 959, 959, 959, 959, 959, 661, 728, 959, 959,
108295: /* 130 */ 959, 959, 959, 959, 836, 837, 851, 850, 849, 959,
108296: /* 140 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108297: /* 150 */ 959, 939, 937, 959, 883, 959, 959, 959, 959, 959,
108298: /* 160 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108299: /* 170 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108300: /* 180 */ 959, 641, 959, 759, 759, 759, 635, 959, 959, 959,
108301: /* 190 */ 959, 951, 763, 753, 719, 959, 959, 959, 959, 959,
108302: /* 200 */ 959, 959, 959, 959, 959, 959, 959, 804, 742, 922,
108303: /* 210 */ 924, 959, 905, 740, 663, 761, 676, 751, 643, 798,
108304: /* 220 */ 776, 776, 917, 798, 917, 700, 959, 788, 959, 788,
108305: /* 230 */ 697, 788, 776, 788, 788, 866, 959, 959, 959, 760,
108306: /* 240 */ 751, 959, 944, 767, 767, 936, 936, 767, 810, 732,
108307: /* 250 */ 798, 739, 739, 739, 739, 767, 798, 810, 732, 732,
108308: /* 260 */ 767, 658, 911, 909, 767, 767, 658, 767, 658, 767,
108309: /* 270 */ 658, 876, 730, 730, 730, 715, 880, 880, 876, 730,
108310: /* 280 */ 700, 730, 715, 730, 730, 780, 775, 780, 775, 780,
108311: /* 290 */ 775, 767, 767, 959, 793, 781, 791, 789, 798, 959,
108312: /* 300 */ 718, 651, 651, 640, 640, 640, 640, 956, 956, 951,
108313: /* 310 */ 702, 702, 684, 959, 959, 959, 959, 959, 959, 959,
108314: /* 320 */ 885, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108315: /* 330 */ 959, 959, 959, 959, 636, 946, 959, 959, 943, 959,
108316: /* 340 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108317: /* 350 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 915,
108318: /* 360 */ 959, 959, 959, 959, 959, 959, 908, 907, 959, 959,
108319: /* 370 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108320: /* 380 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 959,
108321: /* 390 */ 959, 959, 959, 959, 790, 959, 782, 959, 869, 959,
108322: /* 400 */ 959, 959, 959, 959, 959, 959, 959, 959, 959, 745,
108323: /* 410 */ 819, 959, 818, 822, 817, 668, 959, 649, 959, 632,
108324: /* 420 */ 637, 955, 958, 957, 954, 953, 952, 947, 945, 942,
108325: /* 430 */ 941, 940, 938, 935, 931, 889, 887, 894, 893, 892,
108326: /* 440 */ 891, 890, 888, 886, 884, 805, 803, 800, 797, 930,
108327: /* 450 */ 882, 741, 738, 737, 657, 948, 914, 923, 921, 811,
108328: /* 460 */ 920, 919, 918, 916, 913, 900, 807, 806, 733, 874,
108329: /* 470 */ 873, 660, 904, 903, 902, 906, 910, 901, 769, 659,
108330: /* 480 */ 656, 665, 722, 721, 729, 727, 726, 725, 724, 723,
108331: /* 490 */ 720, 667, 675, 686, 714, 699, 698, 879, 881, 878,
108332: /* 500 */ 877, 707, 706, 712, 711, 710, 709, 708, 705, 704,
108333: /* 510 */ 703, 696, 695, 701, 694, 717, 716, 713, 693, 736,
108334: /* 520 */ 735, 734, 731, 692, 691, 690, 822, 689, 688, 828,
108335: /* 530 */ 827, 815, 858, 756, 755, 754, 766, 765, 778, 777,
108336: /* 540 */ 813, 812, 779, 764, 758, 757, 773, 772, 771, 770,
108337: /* 550 */ 762, 752, 784, 787, 786, 783, 860, 768, 857, 929,
108338: /* 560 */ 928, 927, 926, 925, 862, 861, 829, 826, 679, 680,
108339: /* 570 */ 898, 896, 897, 895, 682, 681, 678, 677, 859, 747,
108340: /* 580 */ 746, 855, 852, 844, 840, 856, 853, 845, 841, 839,
108341: /* 590 */ 838, 824, 823, 821, 820, 816, 825, 670, 748, 744,
108342: /* 600 */ 743, 814, 750, 749, 687, 685, 683, 664, 662, 655,
108343: /* 610 */ 653, 652, 654, 650, 648, 647, 646, 645, 644, 673,
108344: /* 620 */ 672, 671, 669, 668, 642, 639, 638, 634, 633, 631,
108345: };
108346:
108347: /* The next table maps tokens into fallback tokens. If a construct
108348: ** like the following:
108349: **
108350: ** %fallback ID X Y Z.
108351: **
108352: ** appears in the grammar, then ID becomes a fallback token for X, Y,
108353: ** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
108354: ** but it does not parse, the type of the token is changed to ID and
108355: ** the parse is retried before an error is thrown.
108356: */
108357: #ifdef YYFALLBACK
108358: static const YYCODETYPE yyFallback[] = {
108359: 0, /* $ => nothing */
108360: 0, /* SEMI => nothing */
108361: 26, /* EXPLAIN => ID */
108362: 26, /* QUERY => ID */
108363: 26, /* PLAN => ID */
108364: 26, /* BEGIN => ID */
108365: 0, /* TRANSACTION => nothing */
108366: 26, /* DEFERRED => ID */
108367: 26, /* IMMEDIATE => ID */
108368: 26, /* EXCLUSIVE => ID */
108369: 0, /* COMMIT => nothing */
108370: 26, /* END => ID */
108371: 26, /* ROLLBACK => ID */
108372: 26, /* SAVEPOINT => ID */
108373: 26, /* RELEASE => ID */
108374: 0, /* TO => nothing */
108375: 0, /* TABLE => nothing */
108376: 0, /* CREATE => nothing */
108377: 26, /* IF => ID */
108378: 0, /* NOT => nothing */
108379: 0, /* EXISTS => nothing */
108380: 26, /* TEMP => ID */
108381: 0, /* LP => nothing */
108382: 0, /* RP => nothing */
108383: 0, /* AS => nothing */
108384: 0, /* COMMA => nothing */
108385: 0, /* ID => nothing */
108386: 0, /* INDEXED => nothing */
108387: 26, /* ABORT => ID */
108388: 26, /* ACTION => ID */
108389: 26, /* AFTER => ID */
108390: 26, /* ANALYZE => ID */
108391: 26, /* ASC => ID */
108392: 26, /* ATTACH => ID */
108393: 26, /* BEFORE => ID */
108394: 26, /* BY => ID */
108395: 26, /* CASCADE => ID */
108396: 26, /* CAST => ID */
108397: 26, /* COLUMNKW => ID */
108398: 26, /* CONFLICT => ID */
108399: 26, /* DATABASE => ID */
108400: 26, /* DESC => ID */
108401: 26, /* DETACH => ID */
108402: 26, /* EACH => ID */
108403: 26, /* FAIL => ID */
108404: 26, /* FOR => ID */
108405: 26, /* IGNORE => ID */
108406: 26, /* INITIALLY => ID */
108407: 26, /* INSTEAD => ID */
108408: 26, /* LIKE_KW => ID */
108409: 26, /* MATCH => ID */
108410: 26, /* NO => ID */
108411: 26, /* KEY => ID */
108412: 26, /* OF => ID */
108413: 26, /* OFFSET => ID */
108414: 26, /* PRAGMA => ID */
108415: 26, /* RAISE => ID */
108416: 26, /* REPLACE => ID */
108417: 26, /* RESTRICT => ID */
108418: 26, /* ROW => ID */
108419: 26, /* TRIGGER => ID */
108420: 26, /* VACUUM => ID */
108421: 26, /* VIEW => ID */
108422: 26, /* VIRTUAL => ID */
108423: 26, /* REINDEX => ID */
108424: 26, /* RENAME => ID */
108425: 26, /* CTIME_KW => ID */
108426: };
108427: #endif /* YYFALLBACK */
108428:
108429: /* The following structure represents a single element of the
108430: ** parser's stack. Information stored includes:
108431: **
108432: ** + The state number for the parser at this level of the stack.
108433: **
108434: ** + The value of the token stored at this level of the stack.
108435: ** (In other words, the "major" token.)
108436: **
108437: ** + The semantic value stored at this level of the stack. This is
108438: ** the information used by the action routines in the grammar.
108439: ** It is sometimes called the "minor" token.
108440: */
108441: struct yyStackEntry {
108442: YYACTIONTYPE stateno; /* The state-number */
108443: YYCODETYPE major; /* The major token value. This is the code
108444: ** number for the token at this stack level */
108445: YYMINORTYPE minor; /* The user-supplied minor token value. This
108446: ** is the value of the token */
108447: };
108448: typedef struct yyStackEntry yyStackEntry;
108449:
108450: /* The state of the parser is completely contained in an instance of
108451: ** the following structure */
108452: struct yyParser {
108453: int yyidx; /* Index of top element in stack */
108454: #ifdef YYTRACKMAXSTACKDEPTH
108455: int yyidxMax; /* Maximum value of yyidx */
108456: #endif
108457: int yyerrcnt; /* Shifts left before out of the error */
108458: sqlite3ParserARG_SDECL /* A place to hold %extra_argument */
108459: #if YYSTACKDEPTH<=0
108460: int yystksz; /* Current side of the stack */
108461: yyStackEntry *yystack; /* The parser's stack */
108462: #else
108463: yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */
108464: #endif
108465: };
108466: typedef struct yyParser yyParser;
108467:
108468: #ifndef NDEBUG
108469: /* #include <stdio.h> */
108470: static FILE *yyTraceFILE = 0;
108471: static char *yyTracePrompt = 0;
108472: #endif /* NDEBUG */
108473:
108474: #ifndef NDEBUG
108475: /*
108476: ** Turn parser tracing on by giving a stream to which to write the trace
108477: ** and a prompt to preface each trace message. Tracing is turned off
108478: ** by making either argument NULL
108479: **
108480: ** Inputs:
108481: ** <ul>
108482: ** <li> A FILE* to which trace output should be written.
108483: ** If NULL, then tracing is turned off.
108484: ** <li> A prefix string written at the beginning of every
108485: ** line of trace output. If NULL, then tracing is
108486: ** turned off.
108487: ** </ul>
108488: **
108489: ** Outputs:
108490: ** None.
108491: */
108492: SQLITE_PRIVATE void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){
108493: yyTraceFILE = TraceFILE;
108494: yyTracePrompt = zTracePrompt;
108495: if( yyTraceFILE==0 ) yyTracePrompt = 0;
108496: else if( yyTracePrompt==0 ) yyTraceFILE = 0;
108497: }
108498: #endif /* NDEBUG */
108499:
108500: #ifndef NDEBUG
108501: /* For tracing shifts, the names of all terminals and nonterminals
108502: ** are required. The following table supplies these names */
108503: static const char *const yyTokenName[] = {
108504: "$", "SEMI", "EXPLAIN", "QUERY",
108505: "PLAN", "BEGIN", "TRANSACTION", "DEFERRED",
108506: "IMMEDIATE", "EXCLUSIVE", "COMMIT", "END",
108507: "ROLLBACK", "SAVEPOINT", "RELEASE", "TO",
108508: "TABLE", "CREATE", "IF", "NOT",
108509: "EXISTS", "TEMP", "LP", "RP",
108510: "AS", "COMMA", "ID", "INDEXED",
108511: "ABORT", "ACTION", "AFTER", "ANALYZE",
108512: "ASC", "ATTACH", "BEFORE", "BY",
108513: "CASCADE", "CAST", "COLUMNKW", "CONFLICT",
108514: "DATABASE", "DESC", "DETACH", "EACH",
108515: "FAIL", "FOR", "IGNORE", "INITIALLY",
108516: "INSTEAD", "LIKE_KW", "MATCH", "NO",
108517: "KEY", "OF", "OFFSET", "PRAGMA",
108518: "RAISE", "REPLACE", "RESTRICT", "ROW",
108519: "TRIGGER", "VACUUM", "VIEW", "VIRTUAL",
108520: "REINDEX", "RENAME", "CTIME_KW", "ANY",
108521: "OR", "AND", "IS", "BETWEEN",
108522: "IN", "ISNULL", "NOTNULL", "NE",
108523: "EQ", "GT", "LE", "LT",
108524: "GE", "ESCAPE", "BITAND", "BITOR",
108525: "LSHIFT", "RSHIFT", "PLUS", "MINUS",
108526: "STAR", "SLASH", "REM", "CONCAT",
108527: "COLLATE", "BITNOT", "STRING", "JOIN_KW",
108528: "CONSTRAINT", "DEFAULT", "NULL", "PRIMARY",
108529: "UNIQUE", "CHECK", "REFERENCES", "AUTOINCR",
108530: "ON", "INSERT", "DELETE", "UPDATE",
108531: "SET", "DEFERRABLE", "FOREIGN", "DROP",
108532: "UNION", "ALL", "EXCEPT", "INTERSECT",
108533: "SELECT", "DISTINCT", "DOT", "FROM",
108534: "JOIN", "USING", "ORDER", "GROUP",
108535: "HAVING", "LIMIT", "WHERE", "INTO",
108536: "VALUES", "INTEGER", "FLOAT", "BLOB",
108537: "REGISTER", "VARIABLE", "CASE", "WHEN",
108538: "THEN", "ELSE", "INDEX", "ALTER",
108539: "ADD", "error", "input", "cmdlist",
108540: "ecmd", "explain", "cmdx", "cmd",
108541: "transtype", "trans_opt", "nm", "savepoint_opt",
108542: "create_table", "create_table_args", "createkw", "temp",
108543: "ifnotexists", "dbnm", "columnlist", "conslist_opt",
108544: "select", "column", "columnid", "type",
108545: "carglist", "id", "ids", "typetoken",
108546: "typename", "signed", "plus_num", "minus_num",
108547: "carg", "ccons", "term", "expr",
108548: "onconf", "sortorder", "autoinc", "idxlist_opt",
108549: "refargs", "defer_subclause", "refarg", "refact",
108550: "init_deferred_pred_opt", "conslist", "tcons", "idxlist",
108551: "defer_subclause_opt", "orconf", "resolvetype", "raisetype",
108552: "ifexists", "fullname", "oneselect", "multiselect_op",
108553: "distinct", "selcollist", "from", "where_opt",
108554: "groupby_opt", "having_opt", "orderby_opt", "limit_opt",
108555: "sclp", "as", "seltablist", "stl_prefix",
108556: "joinop", "indexed_opt", "on_opt", "using_opt",
108557: "joinop2", "inscollist", "sortlist", "sortitem",
108558: "nexprlist", "setlist", "insert_cmd", "inscollist_opt",
108559: "itemlist", "exprlist", "likeop", "between_op",
108560: "in_op", "case_operand", "case_exprlist", "case_else",
108561: "uniqueflag", "collate", "nmnum", "plus_opt",
108562: "number", "trigger_decl", "trigger_cmd_list", "trigger_time",
108563: "trigger_event", "foreach_clause", "when_clause", "trigger_cmd",
108564: "trnm", "tridxby", "database_kw_opt", "key_opt",
108565: "add_column_fullname", "kwcolumn_opt", "create_vtab", "vtabarglist",
108566: "vtabarg", "vtabargtoken", "lp", "anylist",
108567: };
108568: #endif /* NDEBUG */
108569:
108570: #ifndef NDEBUG
108571: /* For tracing reduce actions, the names of all rules are required.
108572: */
108573: static const char *const yyRuleName[] = {
108574: /* 0 */ "input ::= cmdlist",
108575: /* 1 */ "cmdlist ::= cmdlist ecmd",
108576: /* 2 */ "cmdlist ::= ecmd",
108577: /* 3 */ "ecmd ::= SEMI",
108578: /* 4 */ "ecmd ::= explain cmdx SEMI",
108579: /* 5 */ "explain ::=",
108580: /* 6 */ "explain ::= EXPLAIN",
108581: /* 7 */ "explain ::= EXPLAIN QUERY PLAN",
108582: /* 8 */ "cmdx ::= cmd",
108583: /* 9 */ "cmd ::= BEGIN transtype trans_opt",
108584: /* 10 */ "trans_opt ::=",
108585: /* 11 */ "trans_opt ::= TRANSACTION",
108586: /* 12 */ "trans_opt ::= TRANSACTION nm",
108587: /* 13 */ "transtype ::=",
108588: /* 14 */ "transtype ::= DEFERRED",
108589: /* 15 */ "transtype ::= IMMEDIATE",
108590: /* 16 */ "transtype ::= EXCLUSIVE",
108591: /* 17 */ "cmd ::= COMMIT trans_opt",
108592: /* 18 */ "cmd ::= END trans_opt",
108593: /* 19 */ "cmd ::= ROLLBACK trans_opt",
108594: /* 20 */ "savepoint_opt ::= SAVEPOINT",
108595: /* 21 */ "savepoint_opt ::=",
108596: /* 22 */ "cmd ::= SAVEPOINT nm",
108597: /* 23 */ "cmd ::= RELEASE savepoint_opt nm",
108598: /* 24 */ "cmd ::= ROLLBACK trans_opt TO savepoint_opt nm",
108599: /* 25 */ "cmd ::= create_table create_table_args",
108600: /* 26 */ "create_table ::= createkw temp TABLE ifnotexists nm dbnm",
108601: /* 27 */ "createkw ::= CREATE",
108602: /* 28 */ "ifnotexists ::=",
108603: /* 29 */ "ifnotexists ::= IF NOT EXISTS",
108604: /* 30 */ "temp ::= TEMP",
108605: /* 31 */ "temp ::=",
108606: /* 32 */ "create_table_args ::= LP columnlist conslist_opt RP",
108607: /* 33 */ "create_table_args ::= AS select",
108608: /* 34 */ "columnlist ::= columnlist COMMA column",
108609: /* 35 */ "columnlist ::= column",
108610: /* 36 */ "column ::= columnid type carglist",
108611: /* 37 */ "columnid ::= nm",
108612: /* 38 */ "id ::= ID",
108613: /* 39 */ "id ::= INDEXED",
108614: /* 40 */ "ids ::= ID|STRING",
108615: /* 41 */ "nm ::= id",
108616: /* 42 */ "nm ::= STRING",
108617: /* 43 */ "nm ::= JOIN_KW",
108618: /* 44 */ "type ::=",
108619: /* 45 */ "type ::= typetoken",
108620: /* 46 */ "typetoken ::= typename",
108621: /* 47 */ "typetoken ::= typename LP signed RP",
108622: /* 48 */ "typetoken ::= typename LP signed COMMA signed RP",
108623: /* 49 */ "typename ::= ids",
108624: /* 50 */ "typename ::= typename ids",
108625: /* 51 */ "signed ::= plus_num",
108626: /* 52 */ "signed ::= minus_num",
108627: /* 53 */ "carglist ::= carglist carg",
108628: /* 54 */ "carglist ::=",
108629: /* 55 */ "carg ::= CONSTRAINT nm ccons",
108630: /* 56 */ "carg ::= ccons",
108631: /* 57 */ "ccons ::= DEFAULT term",
108632: /* 58 */ "ccons ::= DEFAULT LP expr RP",
108633: /* 59 */ "ccons ::= DEFAULT PLUS term",
108634: /* 60 */ "ccons ::= DEFAULT MINUS term",
108635: /* 61 */ "ccons ::= DEFAULT id",
108636: /* 62 */ "ccons ::= NULL onconf",
108637: /* 63 */ "ccons ::= NOT NULL onconf",
108638: /* 64 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc",
108639: /* 65 */ "ccons ::= UNIQUE onconf",
108640: /* 66 */ "ccons ::= CHECK LP expr RP",
108641: /* 67 */ "ccons ::= REFERENCES nm idxlist_opt refargs",
108642: /* 68 */ "ccons ::= defer_subclause",
108643: /* 69 */ "ccons ::= COLLATE ids",
108644: /* 70 */ "autoinc ::=",
108645: /* 71 */ "autoinc ::= AUTOINCR",
108646: /* 72 */ "refargs ::=",
108647: /* 73 */ "refargs ::= refargs refarg",
108648: /* 74 */ "refarg ::= MATCH nm",
108649: /* 75 */ "refarg ::= ON INSERT refact",
108650: /* 76 */ "refarg ::= ON DELETE refact",
108651: /* 77 */ "refarg ::= ON UPDATE refact",
108652: /* 78 */ "refact ::= SET NULL",
108653: /* 79 */ "refact ::= SET DEFAULT",
108654: /* 80 */ "refact ::= CASCADE",
108655: /* 81 */ "refact ::= RESTRICT",
108656: /* 82 */ "refact ::= NO ACTION",
108657: /* 83 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt",
108658: /* 84 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt",
108659: /* 85 */ "init_deferred_pred_opt ::=",
108660: /* 86 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED",
108661: /* 87 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE",
108662: /* 88 */ "conslist_opt ::=",
108663: /* 89 */ "conslist_opt ::= COMMA conslist",
108664: /* 90 */ "conslist ::= conslist COMMA tcons",
108665: /* 91 */ "conslist ::= conslist tcons",
108666: /* 92 */ "conslist ::= tcons",
108667: /* 93 */ "tcons ::= CONSTRAINT nm",
108668: /* 94 */ "tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf",
108669: /* 95 */ "tcons ::= UNIQUE LP idxlist RP onconf",
108670: /* 96 */ "tcons ::= CHECK LP expr RP onconf",
108671: /* 97 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt",
108672: /* 98 */ "defer_subclause_opt ::=",
108673: /* 99 */ "defer_subclause_opt ::= defer_subclause",
108674: /* 100 */ "onconf ::=",
108675: /* 101 */ "onconf ::= ON CONFLICT resolvetype",
108676: /* 102 */ "orconf ::=",
108677: /* 103 */ "orconf ::= OR resolvetype",
108678: /* 104 */ "resolvetype ::= raisetype",
108679: /* 105 */ "resolvetype ::= IGNORE",
108680: /* 106 */ "resolvetype ::= REPLACE",
108681: /* 107 */ "cmd ::= DROP TABLE ifexists fullname",
108682: /* 108 */ "ifexists ::= IF EXISTS",
108683: /* 109 */ "ifexists ::=",
108684: /* 110 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select",
108685: /* 111 */ "cmd ::= DROP VIEW ifexists fullname",
108686: /* 112 */ "cmd ::= select",
108687: /* 113 */ "select ::= oneselect",
108688: /* 114 */ "select ::= select multiselect_op oneselect",
108689: /* 115 */ "multiselect_op ::= UNION",
108690: /* 116 */ "multiselect_op ::= UNION ALL",
108691: /* 117 */ "multiselect_op ::= EXCEPT|INTERSECT",
108692: /* 118 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
108693: /* 119 */ "distinct ::= DISTINCT",
108694: /* 120 */ "distinct ::= ALL",
108695: /* 121 */ "distinct ::=",
108696: /* 122 */ "sclp ::= selcollist COMMA",
108697: /* 123 */ "sclp ::=",
108698: /* 124 */ "selcollist ::= sclp expr as",
108699: /* 125 */ "selcollist ::= sclp STAR",
108700: /* 126 */ "selcollist ::= sclp nm DOT STAR",
108701: /* 127 */ "as ::= AS nm",
108702: /* 128 */ "as ::= ids",
108703: /* 129 */ "as ::=",
108704: /* 130 */ "from ::=",
108705: /* 131 */ "from ::= FROM seltablist",
108706: /* 132 */ "stl_prefix ::= seltablist joinop",
108707: /* 133 */ "stl_prefix ::=",
108708: /* 134 */ "seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt",
108709: /* 135 */ "seltablist ::= stl_prefix LP select RP as on_opt using_opt",
108710: /* 136 */ "seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt",
108711: /* 137 */ "dbnm ::=",
108712: /* 138 */ "dbnm ::= DOT nm",
108713: /* 139 */ "fullname ::= nm dbnm",
108714: /* 140 */ "joinop ::= COMMA|JOIN",
108715: /* 141 */ "joinop ::= JOIN_KW JOIN",
108716: /* 142 */ "joinop ::= JOIN_KW nm JOIN",
108717: /* 143 */ "joinop ::= JOIN_KW nm nm JOIN",
108718: /* 144 */ "on_opt ::= ON expr",
108719: /* 145 */ "on_opt ::=",
108720: /* 146 */ "indexed_opt ::=",
108721: /* 147 */ "indexed_opt ::= INDEXED BY nm",
108722: /* 148 */ "indexed_opt ::= NOT INDEXED",
108723: /* 149 */ "using_opt ::= USING LP inscollist RP",
108724: /* 150 */ "using_opt ::=",
108725: /* 151 */ "orderby_opt ::=",
108726: /* 152 */ "orderby_opt ::= ORDER BY sortlist",
108727: /* 153 */ "sortlist ::= sortlist COMMA sortitem sortorder",
108728: /* 154 */ "sortlist ::= sortitem sortorder",
108729: /* 155 */ "sortitem ::= expr",
108730: /* 156 */ "sortorder ::= ASC",
108731: /* 157 */ "sortorder ::= DESC",
108732: /* 158 */ "sortorder ::=",
108733: /* 159 */ "groupby_opt ::=",
108734: /* 160 */ "groupby_opt ::= GROUP BY nexprlist",
108735: /* 161 */ "having_opt ::=",
108736: /* 162 */ "having_opt ::= HAVING expr",
108737: /* 163 */ "limit_opt ::=",
108738: /* 164 */ "limit_opt ::= LIMIT expr",
108739: /* 165 */ "limit_opt ::= LIMIT expr OFFSET expr",
108740: /* 166 */ "limit_opt ::= LIMIT expr COMMA expr",
108741: /* 167 */ "cmd ::= DELETE FROM fullname indexed_opt where_opt",
108742: /* 168 */ "where_opt ::=",
108743: /* 169 */ "where_opt ::= WHERE expr",
108744: /* 170 */ "cmd ::= UPDATE orconf fullname indexed_opt SET setlist where_opt",
108745: /* 171 */ "setlist ::= setlist COMMA nm EQ expr",
108746: /* 172 */ "setlist ::= nm EQ expr",
108747: /* 173 */ "cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP",
108748: /* 174 */ "cmd ::= insert_cmd INTO fullname inscollist_opt select",
108749: /* 175 */ "cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES",
108750: /* 176 */ "insert_cmd ::= INSERT orconf",
108751: /* 177 */ "insert_cmd ::= REPLACE",
108752: /* 178 */ "itemlist ::= itemlist COMMA expr",
108753: /* 179 */ "itemlist ::= expr",
108754: /* 180 */ "inscollist_opt ::=",
108755: /* 181 */ "inscollist_opt ::= LP inscollist RP",
108756: /* 182 */ "inscollist ::= inscollist COMMA nm",
108757: /* 183 */ "inscollist ::= nm",
108758: /* 184 */ "expr ::= term",
108759: /* 185 */ "expr ::= LP expr RP",
108760: /* 186 */ "term ::= NULL",
108761: /* 187 */ "expr ::= id",
108762: /* 188 */ "expr ::= JOIN_KW",
108763: /* 189 */ "expr ::= nm DOT nm",
108764: /* 190 */ "expr ::= nm DOT nm DOT nm",
108765: /* 191 */ "term ::= INTEGER|FLOAT|BLOB",
108766: /* 192 */ "term ::= STRING",
108767: /* 193 */ "expr ::= REGISTER",
108768: /* 194 */ "expr ::= VARIABLE",
108769: /* 195 */ "expr ::= expr COLLATE ids",
108770: /* 196 */ "expr ::= CAST LP expr AS typetoken RP",
108771: /* 197 */ "expr ::= ID LP distinct exprlist RP",
108772: /* 198 */ "expr ::= ID LP STAR RP",
108773: /* 199 */ "term ::= CTIME_KW",
108774: /* 200 */ "expr ::= expr AND expr",
108775: /* 201 */ "expr ::= expr OR expr",
108776: /* 202 */ "expr ::= expr LT|GT|GE|LE expr",
108777: /* 203 */ "expr ::= expr EQ|NE expr",
108778: /* 204 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
108779: /* 205 */ "expr ::= expr PLUS|MINUS expr",
108780: /* 206 */ "expr ::= expr STAR|SLASH|REM expr",
108781: /* 207 */ "expr ::= expr CONCAT expr",
108782: /* 208 */ "likeop ::= LIKE_KW",
108783: /* 209 */ "likeop ::= NOT LIKE_KW",
108784: /* 210 */ "likeop ::= MATCH",
108785: /* 211 */ "likeop ::= NOT MATCH",
108786: /* 212 */ "expr ::= expr likeop expr",
108787: /* 213 */ "expr ::= expr likeop expr ESCAPE expr",
108788: /* 214 */ "expr ::= expr ISNULL|NOTNULL",
108789: /* 215 */ "expr ::= expr NOT NULL",
108790: /* 216 */ "expr ::= expr IS expr",
108791: /* 217 */ "expr ::= expr IS NOT expr",
108792: /* 218 */ "expr ::= NOT expr",
108793: /* 219 */ "expr ::= BITNOT expr",
108794: /* 220 */ "expr ::= MINUS expr",
108795: /* 221 */ "expr ::= PLUS expr",
108796: /* 222 */ "between_op ::= BETWEEN",
108797: /* 223 */ "between_op ::= NOT BETWEEN",
108798: /* 224 */ "expr ::= expr between_op expr AND expr",
108799: /* 225 */ "in_op ::= IN",
108800: /* 226 */ "in_op ::= NOT IN",
108801: /* 227 */ "expr ::= expr in_op LP exprlist RP",
108802: /* 228 */ "expr ::= LP select RP",
108803: /* 229 */ "expr ::= expr in_op LP select RP",
108804: /* 230 */ "expr ::= expr in_op nm dbnm",
108805: /* 231 */ "expr ::= EXISTS LP select RP",
108806: /* 232 */ "expr ::= CASE case_operand case_exprlist case_else END",
108807: /* 233 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
108808: /* 234 */ "case_exprlist ::= WHEN expr THEN expr",
108809: /* 235 */ "case_else ::= ELSE expr",
108810: /* 236 */ "case_else ::=",
108811: /* 237 */ "case_operand ::= expr",
108812: /* 238 */ "case_operand ::=",
108813: /* 239 */ "exprlist ::= nexprlist",
108814: /* 240 */ "exprlist ::=",
108815: /* 241 */ "nexprlist ::= nexprlist COMMA expr",
108816: /* 242 */ "nexprlist ::= expr",
108817: /* 243 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP",
108818: /* 244 */ "uniqueflag ::= UNIQUE",
108819: /* 245 */ "uniqueflag ::=",
108820: /* 246 */ "idxlist_opt ::=",
108821: /* 247 */ "idxlist_opt ::= LP idxlist RP",
108822: /* 248 */ "idxlist ::= idxlist COMMA nm collate sortorder",
108823: /* 249 */ "idxlist ::= nm collate sortorder",
108824: /* 250 */ "collate ::=",
108825: /* 251 */ "collate ::= COLLATE ids",
108826: /* 252 */ "cmd ::= DROP INDEX ifexists fullname",
108827: /* 253 */ "cmd ::= VACUUM",
108828: /* 254 */ "cmd ::= VACUUM nm",
108829: /* 255 */ "cmd ::= PRAGMA nm dbnm",
108830: /* 256 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
108831: /* 257 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
108832: /* 258 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
108833: /* 259 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
108834: /* 260 */ "nmnum ::= plus_num",
108835: /* 261 */ "nmnum ::= nm",
108836: /* 262 */ "nmnum ::= ON",
108837: /* 263 */ "nmnum ::= DELETE",
108838: /* 264 */ "nmnum ::= DEFAULT",
108839: /* 265 */ "plus_num ::= plus_opt number",
108840: /* 266 */ "minus_num ::= MINUS number",
108841: /* 267 */ "number ::= INTEGER|FLOAT",
108842: /* 268 */ "plus_opt ::= PLUS",
108843: /* 269 */ "plus_opt ::=",
108844: /* 270 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
108845: /* 271 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
108846: /* 272 */ "trigger_time ::= BEFORE",
108847: /* 273 */ "trigger_time ::= AFTER",
108848: /* 274 */ "trigger_time ::= INSTEAD OF",
108849: /* 275 */ "trigger_time ::=",
108850: /* 276 */ "trigger_event ::= DELETE|INSERT",
108851: /* 277 */ "trigger_event ::= UPDATE",
108852: /* 278 */ "trigger_event ::= UPDATE OF inscollist",
108853: /* 279 */ "foreach_clause ::=",
108854: /* 280 */ "foreach_clause ::= FOR EACH ROW",
108855: /* 281 */ "when_clause ::=",
108856: /* 282 */ "when_clause ::= WHEN expr",
108857: /* 283 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
108858: /* 284 */ "trigger_cmd_list ::= trigger_cmd SEMI",
108859: /* 285 */ "trnm ::= nm",
108860: /* 286 */ "trnm ::= nm DOT nm",
108861: /* 287 */ "tridxby ::=",
108862: /* 288 */ "tridxby ::= INDEXED BY nm",
108863: /* 289 */ "tridxby ::= NOT INDEXED",
108864: /* 290 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt",
108865: /* 291 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP",
108866: /* 292 */ "trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select",
108867: /* 293 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt",
108868: /* 294 */ "trigger_cmd ::= select",
108869: /* 295 */ "expr ::= RAISE LP IGNORE RP",
108870: /* 296 */ "expr ::= RAISE LP raisetype COMMA nm RP",
108871: /* 297 */ "raisetype ::= ROLLBACK",
108872: /* 298 */ "raisetype ::= ABORT",
108873: /* 299 */ "raisetype ::= FAIL",
108874: /* 300 */ "cmd ::= DROP TRIGGER ifexists fullname",
108875: /* 301 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
108876: /* 302 */ "cmd ::= DETACH database_kw_opt expr",
108877: /* 303 */ "key_opt ::=",
108878: /* 304 */ "key_opt ::= KEY expr",
108879: /* 305 */ "database_kw_opt ::= DATABASE",
108880: /* 306 */ "database_kw_opt ::=",
108881: /* 307 */ "cmd ::= REINDEX",
108882: /* 308 */ "cmd ::= REINDEX nm dbnm",
108883: /* 309 */ "cmd ::= ANALYZE",
108884: /* 310 */ "cmd ::= ANALYZE nm dbnm",
108885: /* 311 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
108886: /* 312 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column",
108887: /* 313 */ "add_column_fullname ::= fullname",
108888: /* 314 */ "kwcolumn_opt ::=",
108889: /* 315 */ "kwcolumn_opt ::= COLUMNKW",
108890: /* 316 */ "cmd ::= create_vtab",
108891: /* 317 */ "cmd ::= create_vtab LP vtabarglist RP",
108892: /* 318 */ "create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm",
108893: /* 319 */ "vtabarglist ::= vtabarg",
108894: /* 320 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
108895: /* 321 */ "vtabarg ::=",
108896: /* 322 */ "vtabarg ::= vtabarg vtabargtoken",
108897: /* 323 */ "vtabargtoken ::= ANY",
108898: /* 324 */ "vtabargtoken ::= lp anylist RP",
108899: /* 325 */ "lp ::= LP",
108900: /* 326 */ "anylist ::=",
108901: /* 327 */ "anylist ::= anylist LP anylist RP",
108902: /* 328 */ "anylist ::= anylist ANY",
108903: };
108904: #endif /* NDEBUG */
108905:
108906:
108907: #if YYSTACKDEPTH<=0
108908: /*
108909: ** Try to increase the size of the parser stack.
108910: */
108911: static void yyGrowStack(yyParser *p){
108912: int newSize;
108913: yyStackEntry *pNew;
108914:
108915: newSize = p->yystksz*2 + 100;
108916: pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));
108917: if( pNew ){
108918: p->yystack = pNew;
108919: p->yystksz = newSize;
108920: #ifndef NDEBUG
108921: if( yyTraceFILE ){
108922: fprintf(yyTraceFILE,"%sStack grows to %d entries!\n",
108923: yyTracePrompt, p->yystksz);
108924: }
108925: #endif
108926: }
108927: }
108928: #endif
108929:
108930: /*
108931: ** This function allocates a new parser.
108932: ** The only argument is a pointer to a function which works like
108933: ** malloc.
108934: **
108935: ** Inputs:
108936: ** A pointer to the function used to allocate memory.
108937: **
108938: ** Outputs:
108939: ** A pointer to a parser. This pointer is used in subsequent calls
108940: ** to sqlite3Parser and sqlite3ParserFree.
108941: */
108942: SQLITE_PRIVATE void *sqlite3ParserAlloc(void *(*mallocProc)(size_t)){
108943: yyParser *pParser;
108944: pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) );
108945: if( pParser ){
108946: pParser->yyidx = -1;
108947: #ifdef YYTRACKMAXSTACKDEPTH
108948: pParser->yyidxMax = 0;
108949: #endif
108950: #if YYSTACKDEPTH<=0
108951: pParser->yystack = NULL;
108952: pParser->yystksz = 0;
108953: yyGrowStack(pParser);
108954: #endif
108955: }
108956: return pParser;
108957: }
108958:
108959: /* The following function deletes the value associated with a
108960: ** symbol. The symbol can be either a terminal or nonterminal.
108961: ** "yymajor" is the symbol code, and "yypminor" is a pointer to
108962: ** the value.
108963: */
108964: static void yy_destructor(
108965: yyParser *yypParser, /* The parser */
108966: YYCODETYPE yymajor, /* Type code for object to destroy */
108967: YYMINORTYPE *yypminor /* The object to be destroyed */
108968: ){
108969: sqlite3ParserARG_FETCH;
108970: switch( yymajor ){
108971: /* Here is inserted the actions which take place when a
108972: ** terminal or non-terminal is destroyed. This can happen
108973: ** when the symbol is popped from the stack during a
108974: ** reduce or during error processing or when a parser is
108975: ** being destroyed before it is finished parsing.
108976: **
108977: ** Note: during a reduce, the only symbols destroyed are those
108978: ** which appear on the RHS of the rule, but which are not used
108979: ** inside the C code.
108980: */
108981: case 160: /* select */
108982: case 194: /* oneselect */
108983: {
108984: sqlite3SelectDelete(pParse->db, (yypminor->yy387));
108985: }
108986: break;
108987: case 174: /* term */
108988: case 175: /* expr */
108989: {
108990: sqlite3ExprDelete(pParse->db, (yypminor->yy118).pExpr);
108991: }
108992: break;
108993: case 179: /* idxlist_opt */
108994: case 187: /* idxlist */
108995: case 197: /* selcollist */
108996: case 200: /* groupby_opt */
108997: case 202: /* orderby_opt */
108998: case 204: /* sclp */
108999: case 214: /* sortlist */
109000: case 216: /* nexprlist */
109001: case 217: /* setlist */
109002: case 220: /* itemlist */
109003: case 221: /* exprlist */
109004: case 226: /* case_exprlist */
109005: {
109006: sqlite3ExprListDelete(pParse->db, (yypminor->yy322));
109007: }
109008: break;
109009: case 193: /* fullname */
109010: case 198: /* from */
109011: case 206: /* seltablist */
109012: case 207: /* stl_prefix */
109013: {
109014: sqlite3SrcListDelete(pParse->db, (yypminor->yy259));
109015: }
109016: break;
109017: case 199: /* where_opt */
109018: case 201: /* having_opt */
109019: case 210: /* on_opt */
109020: case 215: /* sortitem */
109021: case 225: /* case_operand */
109022: case 227: /* case_else */
109023: case 238: /* when_clause */
109024: case 243: /* key_opt */
109025: {
109026: sqlite3ExprDelete(pParse->db, (yypminor->yy314));
109027: }
109028: break;
109029: case 211: /* using_opt */
109030: case 213: /* inscollist */
109031: case 219: /* inscollist_opt */
109032: {
109033: sqlite3IdListDelete(pParse->db, (yypminor->yy384));
109034: }
109035: break;
109036: case 234: /* trigger_cmd_list */
109037: case 239: /* trigger_cmd */
109038: {
109039: sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy203));
109040: }
109041: break;
109042: case 236: /* trigger_event */
109043: {
109044: sqlite3IdListDelete(pParse->db, (yypminor->yy90).b);
109045: }
109046: break;
109047: default: break; /* If no destructor action specified: do nothing */
109048: }
109049: }
109050:
109051: /*
109052: ** Pop the parser's stack once.
109053: **
109054: ** If there is a destructor routine associated with the token which
109055: ** is popped from the stack, then call it.
109056: **
109057: ** Return the major token number for the symbol popped.
109058: */
109059: static int yy_pop_parser_stack(yyParser *pParser){
109060: YYCODETYPE yymajor;
109061: yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];
109062:
109063: /* There is no mechanism by which the parser stack can be popped below
109064: ** empty in SQLite. */
109065: if( NEVER(pParser->yyidx<0) ) return 0;
109066: #ifndef NDEBUG
109067: if( yyTraceFILE && pParser->yyidx>=0 ){
109068: fprintf(yyTraceFILE,"%sPopping %s\n",
109069: yyTracePrompt,
109070: yyTokenName[yytos->major]);
109071: }
109072: #endif
109073: yymajor = yytos->major;
109074: yy_destructor(pParser, yymajor, &yytos->minor);
109075: pParser->yyidx--;
109076: return yymajor;
109077: }
109078:
109079: /*
109080: ** Deallocate and destroy a parser. Destructors are all called for
109081: ** all stack elements before shutting the parser down.
109082: **
109083: ** Inputs:
109084: ** <ul>
109085: ** <li> A pointer to the parser. This should be a pointer
109086: ** obtained from sqlite3ParserAlloc.
109087: ** <li> A pointer to a function used to reclaim memory obtained
109088: ** from malloc.
109089: ** </ul>
109090: */
109091: SQLITE_PRIVATE void sqlite3ParserFree(
109092: void *p, /* The parser to be deleted */
109093: void (*freeProc)(void*) /* Function used to reclaim memory */
109094: ){
109095: yyParser *pParser = (yyParser*)p;
109096: /* In SQLite, we never try to destroy a parser that was not successfully
109097: ** created in the first place. */
109098: if( NEVER(pParser==0) ) return;
109099: while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser);
109100: #if YYSTACKDEPTH<=0
109101: free(pParser->yystack);
109102: #endif
109103: (*freeProc)((void*)pParser);
109104: }
109105:
109106: /*
109107: ** Return the peak depth of the stack for a parser.
109108: */
109109: #ifdef YYTRACKMAXSTACKDEPTH
109110: SQLITE_PRIVATE int sqlite3ParserStackPeak(void *p){
109111: yyParser *pParser = (yyParser*)p;
109112: return pParser->yyidxMax;
109113: }
109114: #endif
109115:
109116: /*
109117: ** Find the appropriate action for a parser given the terminal
109118: ** look-ahead token iLookAhead.
109119: **
109120: ** If the look-ahead token is YYNOCODE, then check to see if the action is
109121: ** independent of the look-ahead. If it is, return the action, otherwise
109122: ** return YY_NO_ACTION.
109123: */
109124: static int yy_find_shift_action(
109125: yyParser *pParser, /* The parser */
109126: YYCODETYPE iLookAhead /* The look-ahead token */
109127: ){
109128: int i;
109129: int stateno = pParser->yystack[pParser->yyidx].stateno;
109130:
109131: if( stateno>YY_SHIFT_COUNT
109132: || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
109133: return yy_default[stateno];
109134: }
109135: assert( iLookAhead!=YYNOCODE );
109136: i += iLookAhead;
109137: if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
109138: if( iLookAhead>0 ){
109139: #ifdef YYFALLBACK
109140: YYCODETYPE iFallback; /* Fallback token */
109141: if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
109142: && (iFallback = yyFallback[iLookAhead])!=0 ){
109143: #ifndef NDEBUG
109144: if( yyTraceFILE ){
109145: fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
109146: yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
109147: }
109148: #endif
109149: return yy_find_shift_action(pParser, iFallback);
109150: }
109151: #endif
109152: #ifdef YYWILDCARD
109153: {
109154: int j = i - iLookAhead + YYWILDCARD;
109155: if(
109156: #if YY_SHIFT_MIN+YYWILDCARD<0
109157: j>=0 &&
109158: #endif
109159: #if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
109160: j<YY_ACTTAB_COUNT &&
109161: #endif
109162: yy_lookahead[j]==YYWILDCARD
109163: ){
109164: #ifndef NDEBUG
109165: if( yyTraceFILE ){
109166: fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
109167: yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
109168: }
109169: #endif /* NDEBUG */
109170: return yy_action[j];
109171: }
109172: }
109173: #endif /* YYWILDCARD */
109174: }
109175: return yy_default[stateno];
109176: }else{
109177: return yy_action[i];
109178: }
109179: }
109180:
109181: /*
109182: ** Find the appropriate action for a parser given the non-terminal
109183: ** look-ahead token iLookAhead.
109184: **
109185: ** If the look-ahead token is YYNOCODE, then check to see if the action is
109186: ** independent of the look-ahead. If it is, return the action, otherwise
109187: ** return YY_NO_ACTION.
109188: */
109189: static int yy_find_reduce_action(
109190: int stateno, /* Current state number */
109191: YYCODETYPE iLookAhead /* The look-ahead token */
109192: ){
109193: int i;
109194: #ifdef YYERRORSYMBOL
109195: if( stateno>YY_REDUCE_COUNT ){
109196: return yy_default[stateno];
109197: }
109198: #else
109199: assert( stateno<=YY_REDUCE_COUNT );
109200: #endif
109201: i = yy_reduce_ofst[stateno];
109202: assert( i!=YY_REDUCE_USE_DFLT );
109203: assert( iLookAhead!=YYNOCODE );
109204: i += iLookAhead;
109205: #ifdef YYERRORSYMBOL
109206: if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
109207: return yy_default[stateno];
109208: }
109209: #else
109210: assert( i>=0 && i<YY_ACTTAB_COUNT );
109211: assert( yy_lookahead[i]==iLookAhead );
109212: #endif
109213: return yy_action[i];
109214: }
109215:
109216: /*
109217: ** The following routine is called if the stack overflows.
109218: */
109219: static void yyStackOverflow(yyParser *yypParser, YYMINORTYPE *yypMinor){
109220: sqlite3ParserARG_FETCH;
109221: yypParser->yyidx--;
109222: #ifndef NDEBUG
109223: if( yyTraceFILE ){
109224: fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
109225: }
109226: #endif
109227: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
109228: /* Here code is inserted which will execute if the parser
109229: ** stack every overflows */
109230:
109231: UNUSED_PARAMETER(yypMinor); /* Silence some compiler warnings */
109232: sqlite3ErrorMsg(pParse, "parser stack overflow");
109233: sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument var */
109234: }
109235:
109236: /*
109237: ** Perform a shift action.
109238: */
109239: static void yy_shift(
109240: yyParser *yypParser, /* The parser to be shifted */
109241: int yyNewState, /* The new state to shift in */
109242: int yyMajor, /* The major token to shift in */
109243: YYMINORTYPE *yypMinor /* Pointer to the minor token to shift in */
109244: ){
109245: yyStackEntry *yytos;
109246: yypParser->yyidx++;
109247: #ifdef YYTRACKMAXSTACKDEPTH
109248: if( yypParser->yyidx>yypParser->yyidxMax ){
109249: yypParser->yyidxMax = yypParser->yyidx;
109250: }
109251: #endif
109252: #if YYSTACKDEPTH>0
109253: if( yypParser->yyidx>=YYSTACKDEPTH ){
109254: yyStackOverflow(yypParser, yypMinor);
109255: return;
109256: }
109257: #else
109258: if( yypParser->yyidx>=yypParser->yystksz ){
109259: yyGrowStack(yypParser);
109260: if( yypParser->yyidx>=yypParser->yystksz ){
109261: yyStackOverflow(yypParser, yypMinor);
109262: return;
109263: }
109264: }
109265: #endif
109266: yytos = &yypParser->yystack[yypParser->yyidx];
109267: yytos->stateno = (YYACTIONTYPE)yyNewState;
109268: yytos->major = (YYCODETYPE)yyMajor;
109269: yytos->minor = *yypMinor;
109270: #ifndef NDEBUG
109271: if( yyTraceFILE && yypParser->yyidx>0 ){
109272: int i;
109273: fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState);
109274: fprintf(yyTraceFILE,"%sStack:",yyTracePrompt);
109275: for(i=1; i<=yypParser->yyidx; i++)
109276: fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]);
109277: fprintf(yyTraceFILE,"\n");
109278: }
109279: #endif
109280: }
109281:
109282: /* The following table contains information about every rule that
109283: ** is used during the reduce.
109284: */
109285: static const struct {
109286: YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */
109287: unsigned char nrhs; /* Number of right-hand side symbols in the rule */
109288: } yyRuleInfo[] = {
109289: { 142, 1 },
109290: { 143, 2 },
109291: { 143, 1 },
109292: { 144, 1 },
109293: { 144, 3 },
109294: { 145, 0 },
109295: { 145, 1 },
109296: { 145, 3 },
109297: { 146, 1 },
109298: { 147, 3 },
109299: { 149, 0 },
109300: { 149, 1 },
109301: { 149, 2 },
109302: { 148, 0 },
109303: { 148, 1 },
109304: { 148, 1 },
109305: { 148, 1 },
109306: { 147, 2 },
109307: { 147, 2 },
109308: { 147, 2 },
109309: { 151, 1 },
109310: { 151, 0 },
109311: { 147, 2 },
109312: { 147, 3 },
109313: { 147, 5 },
109314: { 147, 2 },
109315: { 152, 6 },
109316: { 154, 1 },
109317: { 156, 0 },
109318: { 156, 3 },
109319: { 155, 1 },
109320: { 155, 0 },
109321: { 153, 4 },
109322: { 153, 2 },
109323: { 158, 3 },
109324: { 158, 1 },
109325: { 161, 3 },
109326: { 162, 1 },
109327: { 165, 1 },
109328: { 165, 1 },
109329: { 166, 1 },
109330: { 150, 1 },
109331: { 150, 1 },
109332: { 150, 1 },
109333: { 163, 0 },
109334: { 163, 1 },
109335: { 167, 1 },
109336: { 167, 4 },
109337: { 167, 6 },
109338: { 168, 1 },
109339: { 168, 2 },
109340: { 169, 1 },
109341: { 169, 1 },
109342: { 164, 2 },
109343: { 164, 0 },
109344: { 172, 3 },
109345: { 172, 1 },
109346: { 173, 2 },
109347: { 173, 4 },
109348: { 173, 3 },
109349: { 173, 3 },
109350: { 173, 2 },
109351: { 173, 2 },
109352: { 173, 3 },
109353: { 173, 5 },
109354: { 173, 2 },
109355: { 173, 4 },
109356: { 173, 4 },
109357: { 173, 1 },
109358: { 173, 2 },
109359: { 178, 0 },
109360: { 178, 1 },
109361: { 180, 0 },
109362: { 180, 2 },
109363: { 182, 2 },
109364: { 182, 3 },
109365: { 182, 3 },
109366: { 182, 3 },
109367: { 183, 2 },
109368: { 183, 2 },
109369: { 183, 1 },
109370: { 183, 1 },
109371: { 183, 2 },
109372: { 181, 3 },
109373: { 181, 2 },
109374: { 184, 0 },
109375: { 184, 2 },
109376: { 184, 2 },
109377: { 159, 0 },
109378: { 159, 2 },
109379: { 185, 3 },
109380: { 185, 2 },
109381: { 185, 1 },
109382: { 186, 2 },
109383: { 186, 7 },
109384: { 186, 5 },
109385: { 186, 5 },
109386: { 186, 10 },
109387: { 188, 0 },
109388: { 188, 1 },
109389: { 176, 0 },
109390: { 176, 3 },
109391: { 189, 0 },
109392: { 189, 2 },
109393: { 190, 1 },
109394: { 190, 1 },
109395: { 190, 1 },
109396: { 147, 4 },
109397: { 192, 2 },
109398: { 192, 0 },
109399: { 147, 8 },
109400: { 147, 4 },
109401: { 147, 1 },
109402: { 160, 1 },
109403: { 160, 3 },
109404: { 195, 1 },
109405: { 195, 2 },
109406: { 195, 1 },
109407: { 194, 9 },
109408: { 196, 1 },
109409: { 196, 1 },
109410: { 196, 0 },
109411: { 204, 2 },
109412: { 204, 0 },
109413: { 197, 3 },
109414: { 197, 2 },
109415: { 197, 4 },
109416: { 205, 2 },
109417: { 205, 1 },
109418: { 205, 0 },
109419: { 198, 0 },
109420: { 198, 2 },
109421: { 207, 2 },
109422: { 207, 0 },
109423: { 206, 7 },
109424: { 206, 7 },
109425: { 206, 7 },
109426: { 157, 0 },
109427: { 157, 2 },
109428: { 193, 2 },
109429: { 208, 1 },
109430: { 208, 2 },
109431: { 208, 3 },
109432: { 208, 4 },
109433: { 210, 2 },
109434: { 210, 0 },
109435: { 209, 0 },
109436: { 209, 3 },
109437: { 209, 2 },
109438: { 211, 4 },
109439: { 211, 0 },
109440: { 202, 0 },
109441: { 202, 3 },
109442: { 214, 4 },
109443: { 214, 2 },
109444: { 215, 1 },
109445: { 177, 1 },
109446: { 177, 1 },
109447: { 177, 0 },
109448: { 200, 0 },
109449: { 200, 3 },
109450: { 201, 0 },
109451: { 201, 2 },
109452: { 203, 0 },
109453: { 203, 2 },
109454: { 203, 4 },
109455: { 203, 4 },
109456: { 147, 5 },
109457: { 199, 0 },
109458: { 199, 2 },
109459: { 147, 7 },
109460: { 217, 5 },
109461: { 217, 3 },
109462: { 147, 8 },
109463: { 147, 5 },
109464: { 147, 6 },
109465: { 218, 2 },
109466: { 218, 1 },
109467: { 220, 3 },
109468: { 220, 1 },
109469: { 219, 0 },
109470: { 219, 3 },
109471: { 213, 3 },
109472: { 213, 1 },
109473: { 175, 1 },
109474: { 175, 3 },
109475: { 174, 1 },
109476: { 175, 1 },
109477: { 175, 1 },
109478: { 175, 3 },
109479: { 175, 5 },
109480: { 174, 1 },
109481: { 174, 1 },
109482: { 175, 1 },
109483: { 175, 1 },
109484: { 175, 3 },
109485: { 175, 6 },
109486: { 175, 5 },
109487: { 175, 4 },
109488: { 174, 1 },
109489: { 175, 3 },
109490: { 175, 3 },
109491: { 175, 3 },
109492: { 175, 3 },
109493: { 175, 3 },
109494: { 175, 3 },
109495: { 175, 3 },
109496: { 175, 3 },
109497: { 222, 1 },
109498: { 222, 2 },
109499: { 222, 1 },
109500: { 222, 2 },
109501: { 175, 3 },
109502: { 175, 5 },
109503: { 175, 2 },
109504: { 175, 3 },
109505: { 175, 3 },
109506: { 175, 4 },
109507: { 175, 2 },
109508: { 175, 2 },
109509: { 175, 2 },
109510: { 175, 2 },
109511: { 223, 1 },
109512: { 223, 2 },
109513: { 175, 5 },
109514: { 224, 1 },
109515: { 224, 2 },
109516: { 175, 5 },
109517: { 175, 3 },
109518: { 175, 5 },
109519: { 175, 4 },
109520: { 175, 4 },
109521: { 175, 5 },
109522: { 226, 5 },
109523: { 226, 4 },
109524: { 227, 2 },
109525: { 227, 0 },
109526: { 225, 1 },
109527: { 225, 0 },
109528: { 221, 1 },
109529: { 221, 0 },
109530: { 216, 3 },
109531: { 216, 1 },
109532: { 147, 11 },
109533: { 228, 1 },
109534: { 228, 0 },
109535: { 179, 0 },
109536: { 179, 3 },
109537: { 187, 5 },
109538: { 187, 3 },
109539: { 229, 0 },
109540: { 229, 2 },
109541: { 147, 4 },
109542: { 147, 1 },
109543: { 147, 2 },
109544: { 147, 3 },
109545: { 147, 5 },
109546: { 147, 6 },
109547: { 147, 5 },
109548: { 147, 6 },
109549: { 230, 1 },
109550: { 230, 1 },
109551: { 230, 1 },
109552: { 230, 1 },
109553: { 230, 1 },
109554: { 170, 2 },
109555: { 171, 2 },
109556: { 232, 1 },
109557: { 231, 1 },
109558: { 231, 0 },
109559: { 147, 5 },
109560: { 233, 11 },
109561: { 235, 1 },
109562: { 235, 1 },
109563: { 235, 2 },
109564: { 235, 0 },
109565: { 236, 1 },
109566: { 236, 1 },
109567: { 236, 3 },
109568: { 237, 0 },
109569: { 237, 3 },
109570: { 238, 0 },
109571: { 238, 2 },
109572: { 234, 3 },
109573: { 234, 2 },
109574: { 240, 1 },
109575: { 240, 3 },
109576: { 241, 0 },
109577: { 241, 3 },
109578: { 241, 2 },
109579: { 239, 7 },
109580: { 239, 8 },
109581: { 239, 5 },
109582: { 239, 5 },
109583: { 239, 1 },
109584: { 175, 4 },
109585: { 175, 6 },
109586: { 191, 1 },
109587: { 191, 1 },
109588: { 191, 1 },
109589: { 147, 4 },
109590: { 147, 6 },
109591: { 147, 3 },
109592: { 243, 0 },
109593: { 243, 2 },
109594: { 242, 1 },
109595: { 242, 0 },
109596: { 147, 1 },
109597: { 147, 3 },
109598: { 147, 1 },
109599: { 147, 3 },
109600: { 147, 6 },
109601: { 147, 6 },
109602: { 244, 1 },
109603: { 245, 0 },
109604: { 245, 1 },
109605: { 147, 1 },
109606: { 147, 4 },
109607: { 246, 7 },
109608: { 247, 1 },
109609: { 247, 3 },
109610: { 248, 0 },
109611: { 248, 2 },
109612: { 249, 1 },
109613: { 249, 3 },
109614: { 250, 1 },
109615: { 251, 0 },
109616: { 251, 4 },
109617: { 251, 2 },
109618: };
109619:
109620: static void yy_accept(yyParser*); /* Forward Declaration */
109621:
109622: /*
109623: ** Perform a reduce action and the shift that must immediately
109624: ** follow the reduce.
109625: */
109626: static void yy_reduce(
109627: yyParser *yypParser, /* The parser */
109628: int yyruleno /* Number of the rule by which to reduce */
109629: ){
109630: int yygoto; /* The next state */
109631: int yyact; /* The next action */
109632: YYMINORTYPE yygotominor; /* The LHS of the rule reduced */
109633: yyStackEntry *yymsp; /* The top of the parser's stack */
109634: int yysize; /* Amount to pop the stack */
109635: sqlite3ParserARG_FETCH;
109636: yymsp = &yypParser->yystack[yypParser->yyidx];
109637: #ifndef NDEBUG
109638: if( yyTraceFILE && yyruleno>=0
109639: && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){
109640: fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt,
109641: yyRuleName[yyruleno]);
109642: }
109643: #endif /* NDEBUG */
109644:
109645: /* Silence complaints from purify about yygotominor being uninitialized
109646: ** in some cases when it is copied into the stack after the following
109647: ** switch. yygotominor is uninitialized when a rule reduces that does
109648: ** not set the value of its left-hand side nonterminal. Leaving the
109649: ** value of the nonterminal uninitialized is utterly harmless as long
109650: ** as the value is never used. So really the only thing this code
109651: ** accomplishes is to quieten purify.
109652: **
109653: ** 2007-01-16: The wireshark project (www.wireshark.org) reports that
109654: ** without this code, their parser segfaults. I'm not sure what there
109655: ** parser is doing to make this happen. This is the second bug report
109656: ** from wireshark this week. Clearly they are stressing Lemon in ways
109657: ** that it has not been previously stressed... (SQLite ticket #2172)
109658: */
109659: /*memset(&yygotominor, 0, sizeof(yygotominor));*/
109660: yygotominor = yyzerominor;
109661:
109662:
109663: switch( yyruleno ){
109664: /* Beginning here are the reduction cases. A typical example
109665: ** follows:
109666: ** case 0:
109667: ** #line <lineno> <grammarfile>
109668: ** { ... } // User supplied code
109669: ** #line <lineno> <thisfile>
109670: ** break;
109671: */
109672: case 5: /* explain ::= */
109673: { sqlite3BeginParse(pParse, 0); }
109674: break;
109675: case 6: /* explain ::= EXPLAIN */
109676: { sqlite3BeginParse(pParse, 1); }
109677: break;
109678: case 7: /* explain ::= EXPLAIN QUERY PLAN */
109679: { sqlite3BeginParse(pParse, 2); }
109680: break;
109681: case 8: /* cmdx ::= cmd */
109682: { sqlite3FinishCoding(pParse); }
109683: break;
109684: case 9: /* cmd ::= BEGIN transtype trans_opt */
109685: {sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy4);}
109686: break;
109687: case 13: /* transtype ::= */
109688: {yygotominor.yy4 = TK_DEFERRED;}
109689: break;
109690: case 14: /* transtype ::= DEFERRED */
109691: case 15: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==15);
109692: case 16: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==16);
109693: case 115: /* multiselect_op ::= UNION */ yytestcase(yyruleno==115);
109694: case 117: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==117);
109695: {yygotominor.yy4 = yymsp[0].major;}
109696: break;
109697: case 17: /* cmd ::= COMMIT trans_opt */
109698: case 18: /* cmd ::= END trans_opt */ yytestcase(yyruleno==18);
109699: {sqlite3CommitTransaction(pParse);}
109700: break;
109701: case 19: /* cmd ::= ROLLBACK trans_opt */
109702: {sqlite3RollbackTransaction(pParse);}
109703: break;
109704: case 22: /* cmd ::= SAVEPOINT nm */
109705: {
109706: sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0);
109707: }
109708: break;
109709: case 23: /* cmd ::= RELEASE savepoint_opt nm */
109710: {
109711: sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0);
109712: }
109713: break;
109714: case 24: /* cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
109715: {
109716: sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
109717: }
109718: break;
109719: case 26: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
109720: {
109721: sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy4,0,0,yymsp[-2].minor.yy4);
109722: }
109723: break;
109724: case 27: /* createkw ::= CREATE */
109725: {
109726: pParse->db->lookaside.bEnabled = 0;
109727: yygotominor.yy0 = yymsp[0].minor.yy0;
109728: }
109729: break;
109730: case 28: /* ifnotexists ::= */
109731: case 31: /* temp ::= */ yytestcase(yyruleno==31);
109732: case 70: /* autoinc ::= */ yytestcase(yyruleno==70);
109733: case 83: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */ yytestcase(yyruleno==83);
109734: case 85: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==85);
109735: case 87: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */ yytestcase(yyruleno==87);
109736: case 98: /* defer_subclause_opt ::= */ yytestcase(yyruleno==98);
109737: case 109: /* ifexists ::= */ yytestcase(yyruleno==109);
109738: case 120: /* distinct ::= ALL */ yytestcase(yyruleno==120);
109739: case 121: /* distinct ::= */ yytestcase(yyruleno==121);
109740: case 222: /* between_op ::= BETWEEN */ yytestcase(yyruleno==222);
109741: case 225: /* in_op ::= IN */ yytestcase(yyruleno==225);
109742: {yygotominor.yy4 = 0;}
109743: break;
109744: case 29: /* ifnotexists ::= IF NOT EXISTS */
109745: case 30: /* temp ::= TEMP */ yytestcase(yyruleno==30);
109746: case 71: /* autoinc ::= AUTOINCR */ yytestcase(yyruleno==71);
109747: case 86: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */ yytestcase(yyruleno==86);
109748: case 108: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==108);
109749: case 119: /* distinct ::= DISTINCT */ yytestcase(yyruleno==119);
109750: case 223: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==223);
109751: case 226: /* in_op ::= NOT IN */ yytestcase(yyruleno==226);
109752: {yygotominor.yy4 = 1;}
109753: break;
109754: case 32: /* create_table_args ::= LP columnlist conslist_opt RP */
109755: {
109756: sqlite3EndTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0);
109757: }
109758: break;
109759: case 33: /* create_table_args ::= AS select */
109760: {
109761: sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy387);
109762: sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy387);
109763: }
109764: break;
109765: case 36: /* column ::= columnid type carglist */
109766: {
109767: yygotominor.yy0.z = yymsp[-2].minor.yy0.z;
109768: yygotominor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-2].minor.yy0.z) + pParse->sLastToken.n;
109769: }
109770: break;
109771: case 37: /* columnid ::= nm */
109772: {
109773: sqlite3AddColumn(pParse,&yymsp[0].minor.yy0);
109774: yygotominor.yy0 = yymsp[0].minor.yy0;
109775: }
109776: break;
109777: case 38: /* id ::= ID */
109778: case 39: /* id ::= INDEXED */ yytestcase(yyruleno==39);
109779: case 40: /* ids ::= ID|STRING */ yytestcase(yyruleno==40);
109780: case 41: /* nm ::= id */ yytestcase(yyruleno==41);
109781: case 42: /* nm ::= STRING */ yytestcase(yyruleno==42);
109782: case 43: /* nm ::= JOIN_KW */ yytestcase(yyruleno==43);
109783: case 46: /* typetoken ::= typename */ yytestcase(yyruleno==46);
109784: case 49: /* typename ::= ids */ yytestcase(yyruleno==49);
109785: case 127: /* as ::= AS nm */ yytestcase(yyruleno==127);
109786: case 128: /* as ::= ids */ yytestcase(yyruleno==128);
109787: case 138: /* dbnm ::= DOT nm */ yytestcase(yyruleno==138);
109788: case 147: /* indexed_opt ::= INDEXED BY nm */ yytestcase(yyruleno==147);
109789: case 251: /* collate ::= COLLATE ids */ yytestcase(yyruleno==251);
109790: case 260: /* nmnum ::= plus_num */ yytestcase(yyruleno==260);
109791: case 261: /* nmnum ::= nm */ yytestcase(yyruleno==261);
109792: case 262: /* nmnum ::= ON */ yytestcase(yyruleno==262);
109793: case 263: /* nmnum ::= DELETE */ yytestcase(yyruleno==263);
109794: case 264: /* nmnum ::= DEFAULT */ yytestcase(yyruleno==264);
109795: case 265: /* plus_num ::= plus_opt number */ yytestcase(yyruleno==265);
109796: case 266: /* minus_num ::= MINUS number */ yytestcase(yyruleno==266);
109797: case 267: /* number ::= INTEGER|FLOAT */ yytestcase(yyruleno==267);
109798: case 285: /* trnm ::= nm */ yytestcase(yyruleno==285);
109799: {yygotominor.yy0 = yymsp[0].minor.yy0;}
109800: break;
109801: case 45: /* type ::= typetoken */
109802: {sqlite3AddColumnType(pParse,&yymsp[0].minor.yy0);}
109803: break;
109804: case 47: /* typetoken ::= typename LP signed RP */
109805: {
109806: yygotominor.yy0.z = yymsp[-3].minor.yy0.z;
109807: yygotominor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
109808: }
109809: break;
109810: case 48: /* typetoken ::= typename LP signed COMMA signed RP */
109811: {
109812: yygotominor.yy0.z = yymsp[-5].minor.yy0.z;
109813: yygotominor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z);
109814: }
109815: break;
109816: case 50: /* typename ::= typename ids */
109817: {yygotominor.yy0.z=yymsp[-1].minor.yy0.z; yygotominor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
109818: break;
109819: case 57: /* ccons ::= DEFAULT term */
109820: case 59: /* ccons ::= DEFAULT PLUS term */ yytestcase(yyruleno==59);
109821: {sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy118);}
109822: break;
109823: case 58: /* ccons ::= DEFAULT LP expr RP */
109824: {sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy118);}
109825: break;
109826: case 60: /* ccons ::= DEFAULT MINUS term */
109827: {
109828: ExprSpan v;
109829: v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy118.pExpr, 0, 0);
109830: v.zStart = yymsp[-1].minor.yy0.z;
109831: v.zEnd = yymsp[0].minor.yy118.zEnd;
109832: sqlite3AddDefaultValue(pParse,&v);
109833: }
109834: break;
109835: case 61: /* ccons ::= DEFAULT id */
109836: {
109837: ExprSpan v;
109838: spanExpr(&v, pParse, TK_STRING, &yymsp[0].minor.yy0);
109839: sqlite3AddDefaultValue(pParse,&v);
109840: }
109841: break;
109842: case 63: /* ccons ::= NOT NULL onconf */
109843: {sqlite3AddNotNull(pParse, yymsp[0].minor.yy4);}
109844: break;
109845: case 64: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
109846: {sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy4,yymsp[0].minor.yy4,yymsp[-2].minor.yy4);}
109847: break;
109848: case 65: /* ccons ::= UNIQUE onconf */
109849: {sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy4,0,0,0,0);}
109850: break;
109851: case 66: /* ccons ::= CHECK LP expr RP */
109852: {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy118.pExpr);}
109853: break;
109854: case 67: /* ccons ::= REFERENCES nm idxlist_opt refargs */
109855: {sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy322,yymsp[0].minor.yy4);}
109856: break;
109857: case 68: /* ccons ::= defer_subclause */
109858: {sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy4);}
109859: break;
109860: case 69: /* ccons ::= COLLATE ids */
109861: {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
109862: break;
109863: case 72: /* refargs ::= */
109864: { yygotominor.yy4 = OE_None*0x0101; /* EV: R-19803-45884 */}
109865: break;
109866: case 73: /* refargs ::= refargs refarg */
109867: { yygotominor.yy4 = (yymsp[-1].minor.yy4 & ~yymsp[0].minor.yy215.mask) | yymsp[0].minor.yy215.value; }
109868: break;
109869: case 74: /* refarg ::= MATCH nm */
109870: case 75: /* refarg ::= ON INSERT refact */ yytestcase(yyruleno==75);
109871: { yygotominor.yy215.value = 0; yygotominor.yy215.mask = 0x000000; }
109872: break;
109873: case 76: /* refarg ::= ON DELETE refact */
109874: { yygotominor.yy215.value = yymsp[0].minor.yy4; yygotominor.yy215.mask = 0x0000ff; }
109875: break;
109876: case 77: /* refarg ::= ON UPDATE refact */
109877: { yygotominor.yy215.value = yymsp[0].minor.yy4<<8; yygotominor.yy215.mask = 0x00ff00; }
109878: break;
109879: case 78: /* refact ::= SET NULL */
109880: { yygotominor.yy4 = OE_SetNull; /* EV: R-33326-45252 */}
109881: break;
109882: case 79: /* refact ::= SET DEFAULT */
109883: { yygotominor.yy4 = OE_SetDflt; /* EV: R-33326-45252 */}
109884: break;
109885: case 80: /* refact ::= CASCADE */
109886: { yygotominor.yy4 = OE_Cascade; /* EV: R-33326-45252 */}
109887: break;
109888: case 81: /* refact ::= RESTRICT */
109889: { yygotominor.yy4 = OE_Restrict; /* EV: R-33326-45252 */}
109890: break;
109891: case 82: /* refact ::= NO ACTION */
109892: { yygotominor.yy4 = OE_None; /* EV: R-33326-45252 */}
109893: break;
109894: case 84: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
109895: case 99: /* defer_subclause_opt ::= defer_subclause */ yytestcase(yyruleno==99);
109896: case 101: /* onconf ::= ON CONFLICT resolvetype */ yytestcase(yyruleno==101);
109897: case 104: /* resolvetype ::= raisetype */ yytestcase(yyruleno==104);
109898: {yygotominor.yy4 = yymsp[0].minor.yy4;}
109899: break;
109900: case 88: /* conslist_opt ::= */
109901: {yygotominor.yy0.n = 0; yygotominor.yy0.z = 0;}
109902: break;
109903: case 89: /* conslist_opt ::= COMMA conslist */
109904: {yygotominor.yy0 = yymsp[-1].minor.yy0;}
109905: break;
109906: case 94: /* tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf */
109907: {sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy322,yymsp[0].minor.yy4,yymsp[-2].minor.yy4,0);}
109908: break;
109909: case 95: /* tcons ::= UNIQUE LP idxlist RP onconf */
109910: {sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy322,yymsp[0].minor.yy4,0,0,0,0);}
109911: break;
109912: case 96: /* tcons ::= CHECK LP expr RP onconf */
109913: {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy118.pExpr);}
109914: break;
109915: case 97: /* tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt */
109916: {
109917: sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy322, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[-1].minor.yy4);
109918: sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy4);
109919: }
109920: break;
109921: case 100: /* onconf ::= */
109922: {yygotominor.yy4 = OE_Default;}
109923: break;
109924: case 102: /* orconf ::= */
109925: {yygotominor.yy210 = OE_Default;}
109926: break;
109927: case 103: /* orconf ::= OR resolvetype */
109928: {yygotominor.yy210 = (u8)yymsp[0].minor.yy4;}
109929: break;
109930: case 105: /* resolvetype ::= IGNORE */
109931: {yygotominor.yy4 = OE_Ignore;}
109932: break;
109933: case 106: /* resolvetype ::= REPLACE */
109934: {yygotominor.yy4 = OE_Replace;}
109935: break;
109936: case 107: /* cmd ::= DROP TABLE ifexists fullname */
109937: {
109938: sqlite3DropTable(pParse, yymsp[0].minor.yy259, 0, yymsp[-1].minor.yy4);
109939: }
109940: break;
109941: case 110: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm AS select */
109942: {
109943: sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy387, yymsp[-6].minor.yy4, yymsp[-4].minor.yy4);
109944: }
109945: break;
109946: case 111: /* cmd ::= DROP VIEW ifexists fullname */
109947: {
109948: sqlite3DropTable(pParse, yymsp[0].minor.yy259, 1, yymsp[-1].minor.yy4);
109949: }
109950: break;
109951: case 112: /* cmd ::= select */
109952: {
109953: SelectDest dest = {SRT_Output, 0, 0, 0, 0};
109954: sqlite3Select(pParse, yymsp[0].minor.yy387, &dest);
109955: sqlite3ExplainBegin(pParse->pVdbe);
109956: sqlite3ExplainSelect(pParse->pVdbe, yymsp[0].minor.yy387);
109957: sqlite3ExplainFinish(pParse->pVdbe);
109958: sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy387);
109959: }
109960: break;
109961: case 113: /* select ::= oneselect */
109962: {yygotominor.yy387 = yymsp[0].minor.yy387;}
109963: break;
109964: case 114: /* select ::= select multiselect_op oneselect */
109965: {
109966: if( yymsp[0].minor.yy387 ){
109967: yymsp[0].minor.yy387->op = (u8)yymsp[-1].minor.yy4;
109968: yymsp[0].minor.yy387->pPrior = yymsp[-2].minor.yy387;
109969: }else{
109970: sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy387);
109971: }
109972: yygotominor.yy387 = yymsp[0].minor.yy387;
109973: }
109974: break;
109975: case 116: /* multiselect_op ::= UNION ALL */
109976: {yygotominor.yy4 = TK_ALL;}
109977: break;
109978: case 118: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
109979: {
109980: yygotominor.yy387 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy322,yymsp[-5].minor.yy259,yymsp[-4].minor.yy314,yymsp[-3].minor.yy322,yymsp[-2].minor.yy314,yymsp[-1].minor.yy322,yymsp[-7].minor.yy4,yymsp[0].minor.yy292.pLimit,yymsp[0].minor.yy292.pOffset);
109981: }
109982: break;
109983: case 122: /* sclp ::= selcollist COMMA */
109984: case 247: /* idxlist_opt ::= LP idxlist RP */ yytestcase(yyruleno==247);
109985: {yygotominor.yy322 = yymsp[-1].minor.yy322;}
109986: break;
109987: case 123: /* sclp ::= */
109988: case 151: /* orderby_opt ::= */ yytestcase(yyruleno==151);
109989: case 159: /* groupby_opt ::= */ yytestcase(yyruleno==159);
109990: case 240: /* exprlist ::= */ yytestcase(yyruleno==240);
109991: case 246: /* idxlist_opt ::= */ yytestcase(yyruleno==246);
109992: {yygotominor.yy322 = 0;}
109993: break;
109994: case 124: /* selcollist ::= sclp expr as */
109995: {
109996: yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy322, yymsp[-1].minor.yy118.pExpr);
109997: if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[0].minor.yy0, 1);
109998: sqlite3ExprListSetSpan(pParse,yygotominor.yy322,&yymsp[-1].minor.yy118);
109999: }
110000: break;
110001: case 125: /* selcollist ::= sclp STAR */
110002: {
110003: Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
110004: yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy322, p);
110005: }
110006: break;
110007: case 126: /* selcollist ::= sclp nm DOT STAR */
110008: {
110009: Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &yymsp[0].minor.yy0);
110010: Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
110011: Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
110012: yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322, pDot);
110013: }
110014: break;
110015: case 129: /* as ::= */
110016: {yygotominor.yy0.n = 0;}
110017: break;
110018: case 130: /* from ::= */
110019: {yygotominor.yy259 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy259));}
110020: break;
110021: case 131: /* from ::= FROM seltablist */
110022: {
110023: yygotominor.yy259 = yymsp[0].minor.yy259;
110024: sqlite3SrcListShiftJoinType(yygotominor.yy259);
110025: }
110026: break;
110027: case 132: /* stl_prefix ::= seltablist joinop */
110028: {
110029: yygotominor.yy259 = yymsp[-1].minor.yy259;
110030: if( ALWAYS(yygotominor.yy259 && yygotominor.yy259->nSrc>0) ) yygotominor.yy259->a[yygotominor.yy259->nSrc-1].jointype = (u8)yymsp[0].minor.yy4;
110031: }
110032: break;
110033: case 133: /* stl_prefix ::= */
110034: {yygotominor.yy259 = 0;}
110035: break;
110036: case 134: /* seltablist ::= stl_prefix nm dbnm as indexed_opt on_opt using_opt */
110037: {
110038: yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
110039: sqlite3SrcListIndexedBy(pParse, yygotominor.yy259, &yymsp[-2].minor.yy0);
110040: }
110041: break;
110042: case 135: /* seltablist ::= stl_prefix LP select RP as on_opt using_opt */
110043: {
110044: yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy387,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
110045: }
110046: break;
110047: case 136: /* seltablist ::= stl_prefix LP seltablist RP as on_opt using_opt */
110048: {
110049: if( yymsp[-6].minor.yy259==0 && yymsp[-2].minor.yy0.n==0 && yymsp[-1].minor.yy314==0 && yymsp[0].minor.yy384==0 ){
110050: yygotominor.yy259 = yymsp[-4].minor.yy259;
110051: }else{
110052: Select *pSubquery;
110053: sqlite3SrcListShiftJoinType(yymsp[-4].minor.yy259);
110054: pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy259,0,0,0,0,0,0,0);
110055: yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
110056: }
110057: }
110058: break;
110059: case 137: /* dbnm ::= */
110060: case 146: /* indexed_opt ::= */ yytestcase(yyruleno==146);
110061: {yygotominor.yy0.z=0; yygotominor.yy0.n=0;}
110062: break;
110063: case 139: /* fullname ::= nm dbnm */
110064: {yygotominor.yy259 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
110065: break;
110066: case 140: /* joinop ::= COMMA|JOIN */
110067: { yygotominor.yy4 = JT_INNER; }
110068: break;
110069: case 141: /* joinop ::= JOIN_KW JOIN */
110070: { yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
110071: break;
110072: case 142: /* joinop ::= JOIN_KW nm JOIN */
110073: { yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
110074: break;
110075: case 143: /* joinop ::= JOIN_KW nm nm JOIN */
110076: { yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
110077: break;
110078: case 144: /* on_opt ::= ON expr */
110079: case 155: /* sortitem ::= expr */ yytestcase(yyruleno==155);
110080: case 162: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==162);
110081: case 169: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==169);
110082: case 235: /* case_else ::= ELSE expr */ yytestcase(yyruleno==235);
110083: case 237: /* case_operand ::= expr */ yytestcase(yyruleno==237);
110084: {yygotominor.yy314 = yymsp[0].minor.yy118.pExpr;}
110085: break;
110086: case 145: /* on_opt ::= */
110087: case 161: /* having_opt ::= */ yytestcase(yyruleno==161);
110088: case 168: /* where_opt ::= */ yytestcase(yyruleno==168);
110089: case 236: /* case_else ::= */ yytestcase(yyruleno==236);
110090: case 238: /* case_operand ::= */ yytestcase(yyruleno==238);
110091: {yygotominor.yy314 = 0;}
110092: break;
110093: case 148: /* indexed_opt ::= NOT INDEXED */
110094: {yygotominor.yy0.z=0; yygotominor.yy0.n=1;}
110095: break;
110096: case 149: /* using_opt ::= USING LP inscollist RP */
110097: case 181: /* inscollist_opt ::= LP inscollist RP */ yytestcase(yyruleno==181);
110098: {yygotominor.yy384 = yymsp[-1].minor.yy384;}
110099: break;
110100: case 150: /* using_opt ::= */
110101: case 180: /* inscollist_opt ::= */ yytestcase(yyruleno==180);
110102: {yygotominor.yy384 = 0;}
110103: break;
110104: case 152: /* orderby_opt ::= ORDER BY sortlist */
110105: case 160: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==160);
110106: case 239: /* exprlist ::= nexprlist */ yytestcase(yyruleno==239);
110107: {yygotominor.yy322 = yymsp[0].minor.yy322;}
110108: break;
110109: case 153: /* sortlist ::= sortlist COMMA sortitem sortorder */
110110: {
110111: yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322,yymsp[-1].minor.yy314);
110112: if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
110113: }
110114: break;
110115: case 154: /* sortlist ::= sortitem sortorder */
110116: {
110117: yygotominor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy314);
110118: if( yygotominor.yy322 && ALWAYS(yygotominor.yy322->a) ) yygotominor.yy322->a[0].sortOrder = (u8)yymsp[0].minor.yy4;
110119: }
110120: break;
110121: case 156: /* sortorder ::= ASC */
110122: case 158: /* sortorder ::= */ yytestcase(yyruleno==158);
110123: {yygotominor.yy4 = SQLITE_SO_ASC;}
110124: break;
110125: case 157: /* sortorder ::= DESC */
110126: {yygotominor.yy4 = SQLITE_SO_DESC;}
110127: break;
110128: case 163: /* limit_opt ::= */
110129: {yygotominor.yy292.pLimit = 0; yygotominor.yy292.pOffset = 0;}
110130: break;
110131: case 164: /* limit_opt ::= LIMIT expr */
110132: {yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr; yygotominor.yy292.pOffset = 0;}
110133: break;
110134: case 165: /* limit_opt ::= LIMIT expr OFFSET expr */
110135: {yygotominor.yy292.pLimit = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pOffset = yymsp[0].minor.yy118.pExpr;}
110136: break;
110137: case 166: /* limit_opt ::= LIMIT expr COMMA expr */
110138: {yygotominor.yy292.pOffset = yymsp[-2].minor.yy118.pExpr; yygotominor.yy292.pLimit = yymsp[0].minor.yy118.pExpr;}
110139: break;
110140: case 167: /* cmd ::= DELETE FROM fullname indexed_opt where_opt */
110141: {
110142: sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy259, &yymsp[-1].minor.yy0);
110143: sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy259,yymsp[0].minor.yy314);
110144: }
110145: break;
110146: case 170: /* cmd ::= UPDATE orconf fullname indexed_opt SET setlist where_opt */
110147: {
110148: sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy259, &yymsp[-3].minor.yy0);
110149: sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy322,"set list");
110150: sqlite3Update(pParse,yymsp[-4].minor.yy259,yymsp[-1].minor.yy322,yymsp[0].minor.yy314,yymsp[-5].minor.yy210);
110151: }
110152: break;
110153: case 171: /* setlist ::= setlist COMMA nm EQ expr */
110154: {
110155: yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[0].minor.yy118.pExpr);
110156: sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
110157: }
110158: break;
110159: case 172: /* setlist ::= nm EQ expr */
110160: {
110161: yygotominor.yy322 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy118.pExpr);
110162: sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
110163: }
110164: break;
110165: case 173: /* cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP */
110166: {sqlite3Insert(pParse, yymsp[-5].minor.yy259, yymsp[-1].minor.yy322, 0, yymsp[-4].minor.yy384, yymsp[-7].minor.yy210);}
110167: break;
110168: case 174: /* cmd ::= insert_cmd INTO fullname inscollist_opt select */
110169: {sqlite3Insert(pParse, yymsp[-2].minor.yy259, 0, yymsp[0].minor.yy387, yymsp[-1].minor.yy384, yymsp[-4].minor.yy210);}
110170: break;
110171: case 175: /* cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES */
110172: {sqlite3Insert(pParse, yymsp[-3].minor.yy259, 0, 0, yymsp[-2].minor.yy384, yymsp[-5].minor.yy210);}
110173: break;
110174: case 176: /* insert_cmd ::= INSERT orconf */
110175: {yygotominor.yy210 = yymsp[0].minor.yy210;}
110176: break;
110177: case 177: /* insert_cmd ::= REPLACE */
110178: {yygotominor.yy210 = OE_Replace;}
110179: break;
110180: case 178: /* itemlist ::= itemlist COMMA expr */
110181: case 241: /* nexprlist ::= nexprlist COMMA expr */ yytestcase(yyruleno==241);
110182: {yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[0].minor.yy118.pExpr);}
110183: break;
110184: case 179: /* itemlist ::= expr */
110185: case 242: /* nexprlist ::= expr */ yytestcase(yyruleno==242);
110186: {yygotominor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy118.pExpr);}
110187: break;
110188: case 182: /* inscollist ::= inscollist COMMA nm */
110189: {yygotominor.yy384 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy384,&yymsp[0].minor.yy0);}
110190: break;
110191: case 183: /* inscollist ::= nm */
110192: {yygotominor.yy384 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
110193: break;
110194: case 184: /* expr ::= term */
110195: {yygotominor.yy118 = yymsp[0].minor.yy118;}
110196: break;
110197: case 185: /* expr ::= LP expr RP */
110198: {yygotominor.yy118.pExpr = yymsp[-1].minor.yy118.pExpr; spanSet(&yygotominor.yy118,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);}
110199: break;
110200: case 186: /* term ::= NULL */
110201: case 191: /* term ::= INTEGER|FLOAT|BLOB */ yytestcase(yyruleno==191);
110202: case 192: /* term ::= STRING */ yytestcase(yyruleno==192);
110203: {spanExpr(&yygotominor.yy118, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
110204: break;
110205: case 187: /* expr ::= id */
110206: case 188: /* expr ::= JOIN_KW */ yytestcase(yyruleno==188);
110207: {spanExpr(&yygotominor.yy118, pParse, TK_ID, &yymsp[0].minor.yy0);}
110208: break;
110209: case 189: /* expr ::= nm DOT nm */
110210: {
110211: Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
110212: Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
110213: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
110214: spanSet(&yygotominor.yy118,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
110215: }
110216: break;
110217: case 190: /* expr ::= nm DOT nm DOT nm */
110218: {
110219: Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-4].minor.yy0);
110220: Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
110221: Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
110222: Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
110223: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
110224: spanSet(&yygotominor.yy118,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
110225: }
110226: break;
110227: case 193: /* expr ::= REGISTER */
110228: {
110229: /* When doing a nested parse, one can include terms in an expression
110230: ** that look like this: #1 #2 ... These terms refer to registers
110231: ** in the virtual machine. #N is the N-th register. */
110232: if( pParse->nested==0 ){
110233: sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0);
110234: yygotominor.yy118.pExpr = 0;
110235: }else{
110236: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
110237: if( yygotominor.yy118.pExpr ) sqlite3GetInt32(&yymsp[0].minor.yy0.z[1], &yygotominor.yy118.pExpr->iTable);
110238: }
110239: spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
110240: }
110241: break;
110242: case 194: /* expr ::= VARIABLE */
110243: {
110244: spanExpr(&yygotominor.yy118, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
110245: sqlite3ExprAssignVarNumber(pParse, yygotominor.yy118.pExpr);
110246: spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
110247: }
110248: break;
110249: case 195: /* expr ::= expr COLLATE ids */
110250: {
110251: yygotominor.yy118.pExpr = sqlite3ExprSetCollByToken(pParse, yymsp[-2].minor.yy118.pExpr, &yymsp[0].minor.yy0);
110252: yygotominor.yy118.zStart = yymsp[-2].minor.yy118.zStart;
110253: yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110254: }
110255: break;
110256: case 196: /* expr ::= CAST LP expr AS typetoken RP */
110257: {
110258: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy118.pExpr, 0, &yymsp[-1].minor.yy0);
110259: spanSet(&yygotominor.yy118,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);
110260: }
110261: break;
110262: case 197: /* expr ::= ID LP distinct exprlist RP */
110263: {
110264: if( yymsp[-1].minor.yy322 && yymsp[-1].minor.yy322->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
110265: sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0);
110266: }
110267: yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0);
110268: spanSet(&yygotominor.yy118,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0);
110269: if( yymsp[-2].minor.yy4 && yygotominor.yy118.pExpr ){
110270: yygotominor.yy118.pExpr->flags |= EP_Distinct;
110271: }
110272: }
110273: break;
110274: case 198: /* expr ::= ID LP STAR RP */
110275: {
110276: yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
110277: spanSet(&yygotominor.yy118,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);
110278: }
110279: break;
110280: case 199: /* term ::= CTIME_KW */
110281: {
110282: /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are
110283: ** treated as functions that return constants */
110284: yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
110285: if( yygotominor.yy118.pExpr ){
110286: yygotominor.yy118.pExpr->op = TK_CONST_FUNC;
110287: }
110288: spanSet(&yygotominor.yy118, &yymsp[0].minor.yy0, &yymsp[0].minor.yy0);
110289: }
110290: break;
110291: case 200: /* expr ::= expr AND expr */
110292: case 201: /* expr ::= expr OR expr */ yytestcase(yyruleno==201);
110293: case 202: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==202);
110294: case 203: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==203);
110295: case 204: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==204);
110296: case 205: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==205);
110297: case 206: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==206);
110298: case 207: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==207);
110299: {spanBinaryExpr(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);}
110300: break;
110301: case 208: /* likeop ::= LIKE_KW */
110302: case 210: /* likeop ::= MATCH */ yytestcase(yyruleno==210);
110303: {yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 0;}
110304: break;
110305: case 209: /* likeop ::= NOT LIKE_KW */
110306: case 211: /* likeop ::= NOT MATCH */ yytestcase(yyruleno==211);
110307: {yygotominor.yy342.eOperator = yymsp[0].minor.yy0; yygotominor.yy342.not = 1;}
110308: break;
110309: case 212: /* expr ::= expr likeop expr */
110310: {
110311: ExprList *pList;
110312: pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy118.pExpr);
110313: pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy118.pExpr);
110314: yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy342.eOperator);
110315: if( yymsp[-1].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110316: yygotominor.yy118.zStart = yymsp[-2].minor.yy118.zStart;
110317: yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
110318: if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags |= EP_InfixFunc;
110319: }
110320: break;
110321: case 213: /* expr ::= expr likeop expr ESCAPE expr */
110322: {
110323: ExprList *pList;
110324: pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
110325: pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy118.pExpr);
110326: pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
110327: yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy342.eOperator);
110328: if( yymsp[-3].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110329: yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
110330: yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
110331: if( yygotominor.yy118.pExpr ) yygotominor.yy118.pExpr->flags |= EP_InfixFunc;
110332: }
110333: break;
110334: case 214: /* expr ::= expr ISNULL|NOTNULL */
110335: {spanUnaryPostfix(&yygotominor.yy118,pParse,yymsp[0].major,&yymsp[-1].minor.yy118,&yymsp[0].minor.yy0);}
110336: break;
110337: case 215: /* expr ::= expr NOT NULL */
110338: {spanUnaryPostfix(&yygotominor.yy118,pParse,TK_NOTNULL,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy0);}
110339: break;
110340: case 216: /* expr ::= expr IS expr */
110341: {
110342: spanBinaryExpr(&yygotominor.yy118,pParse,TK_IS,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);
110343: binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_ISNULL);
110344: }
110345: break;
110346: case 217: /* expr ::= expr IS NOT expr */
110347: {
110348: spanBinaryExpr(&yygotominor.yy118,pParse,TK_ISNOT,&yymsp[-3].minor.yy118,&yymsp[0].minor.yy118);
110349: binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_NOTNULL);
110350: }
110351: break;
110352: case 218: /* expr ::= NOT expr */
110353: case 219: /* expr ::= BITNOT expr */ yytestcase(yyruleno==219);
110354: {spanUnaryPrefix(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
110355: break;
110356: case 220: /* expr ::= MINUS expr */
110357: {spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UMINUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
110358: break;
110359: case 221: /* expr ::= PLUS expr */
110360: {spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UPLUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
110361: break;
110362: case 224: /* expr ::= expr between_op expr AND expr */
110363: {
110364: ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
110365: pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
110366: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy118.pExpr, 0, 0);
110367: if( yygotominor.yy118.pExpr ){
110368: yygotominor.yy118.pExpr->x.pList = pList;
110369: }else{
110370: sqlite3ExprListDelete(pParse->db, pList);
110371: }
110372: if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110373: yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
110374: yygotominor.yy118.zEnd = yymsp[0].minor.yy118.zEnd;
110375: }
110376: break;
110377: case 227: /* expr ::= expr in_op LP exprlist RP */
110378: {
110379: if( yymsp[-1].minor.yy322==0 ){
110380: /* Expressions of the form
110381: **
110382: ** expr1 IN ()
110383: ** expr1 NOT IN ()
110384: **
110385: ** simplify to constants 0 (false) and 1 (true), respectively,
110386: ** regardless of the value of expr1.
110387: */
110388: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[yymsp[-3].minor.yy4]);
110389: sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy118.pExpr);
110390: }else{
110391: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
110392: if( yygotominor.yy118.pExpr ){
110393: yygotominor.yy118.pExpr->x.pList = yymsp[-1].minor.yy322;
110394: sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110395: }else{
110396: sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);
110397: }
110398: if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110399: }
110400: yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
110401: yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110402: }
110403: break;
110404: case 228: /* expr ::= LP select RP */
110405: {
110406: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
110407: if( yygotominor.yy118.pExpr ){
110408: yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
110409: ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
110410: sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110411: }else{
110412: sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
110413: }
110414: yygotominor.yy118.zStart = yymsp[-2].minor.yy0.z;
110415: yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110416: }
110417: break;
110418: case 229: /* expr ::= expr in_op LP select RP */
110419: {
110420: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
110421: if( yygotominor.yy118.pExpr ){
110422: yygotominor.yy118.pExpr->x.pSelect = yymsp[-1].minor.yy387;
110423: ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
110424: sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110425: }else{
110426: sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
110427: }
110428: if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110429: yygotominor.yy118.zStart = yymsp[-4].minor.yy118.zStart;
110430: yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110431: }
110432: break;
110433: case 230: /* expr ::= expr in_op nm dbnm */
110434: {
110435: SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);
110436: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy118.pExpr, 0, 0);
110437: if( yygotominor.yy118.pExpr ){
110438: yygotominor.yy118.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
110439: ExprSetProperty(yygotominor.yy118.pExpr, EP_xIsSelect);
110440: sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110441: }else{
110442: sqlite3SrcListDelete(pParse->db, pSrc);
110443: }
110444: if( yymsp[-2].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
110445: yygotominor.yy118.zStart = yymsp[-3].minor.yy118.zStart;
110446: yygotominor.yy118.zEnd = yymsp[0].minor.yy0.z ? &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] : &yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n];
110447: }
110448: break;
110449: case 231: /* expr ::= EXISTS LP select RP */
110450: {
110451: Expr *p = yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
110452: if( p ){
110453: p->x.pSelect = yymsp[-1].minor.yy387;
110454: ExprSetProperty(p, EP_xIsSelect);
110455: sqlite3ExprSetHeight(pParse, p);
110456: }else{
110457: sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
110458: }
110459: yygotominor.yy118.zStart = yymsp[-3].minor.yy0.z;
110460: yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110461: }
110462: break;
110463: case 232: /* expr ::= CASE case_operand case_exprlist case_else END */
110464: {
110465: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy314, yymsp[-1].minor.yy314, 0);
110466: if( yygotominor.yy118.pExpr ){
110467: yygotominor.yy118.pExpr->x.pList = yymsp[-2].minor.yy322;
110468: sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
110469: }else{
110470: sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy322);
110471: }
110472: yygotominor.yy118.zStart = yymsp[-4].minor.yy0.z;
110473: yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110474: }
110475: break;
110476: case 233: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
110477: {
110478: yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[-2].minor.yy118.pExpr);
110479: yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
110480: }
110481: break;
110482: case 234: /* case_exprlist ::= WHEN expr THEN expr */
110483: {
110484: yygotominor.yy322 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
110485: yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
110486: }
110487: break;
110488: case 243: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP */
110489: {
110490: sqlite3CreateIndex(pParse, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0,
110491: sqlite3SrcListAppend(pParse->db,0,&yymsp[-3].minor.yy0,0), yymsp[-1].minor.yy322, yymsp[-9].minor.yy4,
110492: &yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLITE_SO_ASC, yymsp[-7].minor.yy4);
110493: }
110494: break;
110495: case 244: /* uniqueflag ::= UNIQUE */
110496: case 298: /* raisetype ::= ABORT */ yytestcase(yyruleno==298);
110497: {yygotominor.yy4 = OE_Abort;}
110498: break;
110499: case 245: /* uniqueflag ::= */
110500: {yygotominor.yy4 = OE_None;}
110501: break;
110502: case 248: /* idxlist ::= idxlist COMMA nm collate sortorder */
110503: {
110504: Expr *p = 0;
110505: if( yymsp[-1].minor.yy0.n>0 ){
110506: p = sqlite3Expr(pParse->db, TK_COLUMN, 0);
110507: sqlite3ExprSetCollByToken(pParse, p, &yymsp[-1].minor.yy0);
110508: }
110509: yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, p);
110510: sqlite3ExprListSetName(pParse,yygotominor.yy322,&yymsp[-2].minor.yy0,1);
110511: sqlite3ExprListCheckLength(pParse, yygotominor.yy322, "index");
110512: if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
110513: }
110514: break;
110515: case 249: /* idxlist ::= nm collate sortorder */
110516: {
110517: Expr *p = 0;
110518: if( yymsp[-1].minor.yy0.n>0 ){
110519: p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
110520: sqlite3ExprSetCollByToken(pParse, p, &yymsp[-1].minor.yy0);
110521: }
110522: yygotominor.yy322 = sqlite3ExprListAppend(pParse,0, p);
110523: sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
110524: sqlite3ExprListCheckLength(pParse, yygotominor.yy322, "index");
110525: if( yygotominor.yy322 ) yygotominor.yy322->a[yygotominor.yy322->nExpr-1].sortOrder = (u8)yymsp[0].minor.yy4;
110526: }
110527: break;
110528: case 250: /* collate ::= */
110529: {yygotominor.yy0.z = 0; yygotominor.yy0.n = 0;}
110530: break;
110531: case 252: /* cmd ::= DROP INDEX ifexists fullname */
110532: {sqlite3DropIndex(pParse, yymsp[0].minor.yy259, yymsp[-1].minor.yy4);}
110533: break;
110534: case 253: /* cmd ::= VACUUM */
110535: case 254: /* cmd ::= VACUUM nm */ yytestcase(yyruleno==254);
110536: {sqlite3Vacuum(pParse);}
110537: break;
110538: case 255: /* cmd ::= PRAGMA nm dbnm */
110539: {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
110540: break;
110541: case 256: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
110542: {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
110543: break;
110544: case 257: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
110545: {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
110546: break;
110547: case 258: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
110548: {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
110549: break;
110550: case 259: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
110551: {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
110552: break;
110553: case 270: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
110554: {
110555: Token all;
110556: all.z = yymsp[-3].minor.yy0.z;
110557: all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
110558: sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy203, &all);
110559: }
110560: break;
110561: case 271: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
110562: {
110563: sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy4, yymsp[-4].minor.yy90.a, yymsp[-4].minor.yy90.b, yymsp[-2].minor.yy259, yymsp[0].minor.yy314, yymsp[-10].minor.yy4, yymsp[-8].minor.yy4);
110564: yygotominor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0);
110565: }
110566: break;
110567: case 272: /* trigger_time ::= BEFORE */
110568: case 275: /* trigger_time ::= */ yytestcase(yyruleno==275);
110569: { yygotominor.yy4 = TK_BEFORE; }
110570: break;
110571: case 273: /* trigger_time ::= AFTER */
110572: { yygotominor.yy4 = TK_AFTER; }
110573: break;
110574: case 274: /* trigger_time ::= INSTEAD OF */
110575: { yygotominor.yy4 = TK_INSTEAD;}
110576: break;
110577: case 276: /* trigger_event ::= DELETE|INSERT */
110578: case 277: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==277);
110579: {yygotominor.yy90.a = yymsp[0].major; yygotominor.yy90.b = 0;}
110580: break;
110581: case 278: /* trigger_event ::= UPDATE OF inscollist */
110582: {yygotominor.yy90.a = TK_UPDATE; yygotominor.yy90.b = yymsp[0].minor.yy384;}
110583: break;
110584: case 281: /* when_clause ::= */
110585: case 303: /* key_opt ::= */ yytestcase(yyruleno==303);
110586: { yygotominor.yy314 = 0; }
110587: break;
110588: case 282: /* when_clause ::= WHEN expr */
110589: case 304: /* key_opt ::= KEY expr */ yytestcase(yyruleno==304);
110590: { yygotominor.yy314 = yymsp[0].minor.yy118.pExpr; }
110591: break;
110592: case 283: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
110593: {
110594: assert( yymsp[-2].minor.yy203!=0 );
110595: yymsp[-2].minor.yy203->pLast->pNext = yymsp[-1].minor.yy203;
110596: yymsp[-2].minor.yy203->pLast = yymsp[-1].minor.yy203;
110597: yygotominor.yy203 = yymsp[-2].minor.yy203;
110598: }
110599: break;
110600: case 284: /* trigger_cmd_list ::= trigger_cmd SEMI */
110601: {
110602: assert( yymsp[-1].minor.yy203!=0 );
110603: yymsp[-1].minor.yy203->pLast = yymsp[-1].minor.yy203;
110604: yygotominor.yy203 = yymsp[-1].minor.yy203;
110605: }
110606: break;
110607: case 286: /* trnm ::= nm DOT nm */
110608: {
110609: yygotominor.yy0 = yymsp[0].minor.yy0;
110610: sqlite3ErrorMsg(pParse,
110611: "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
110612: "statements within triggers");
110613: }
110614: break;
110615: case 288: /* tridxby ::= INDEXED BY nm */
110616: {
110617: sqlite3ErrorMsg(pParse,
110618: "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
110619: "within triggers");
110620: }
110621: break;
110622: case 289: /* tridxby ::= NOT INDEXED */
110623: {
110624: sqlite3ErrorMsg(pParse,
110625: "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
110626: "within triggers");
110627: }
110628: break;
110629: case 290: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
110630: { yygotominor.yy203 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy322, yymsp[0].minor.yy314, yymsp[-5].minor.yy210); }
110631: break;
110632: case 291: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt VALUES LP itemlist RP */
110633: {yygotominor.yy203 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy384, yymsp[-1].minor.yy322, 0, yymsp[-7].minor.yy210);}
110634: break;
110635: case 292: /* trigger_cmd ::= insert_cmd INTO trnm inscollist_opt select */
110636: {yygotominor.yy203 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy384, 0, yymsp[0].minor.yy387, yymsp[-4].minor.yy210);}
110637: break;
110638: case 293: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
110639: {yygotominor.yy203 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy314);}
110640: break;
110641: case 294: /* trigger_cmd ::= select */
110642: {yygotominor.yy203 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy387); }
110643: break;
110644: case 295: /* expr ::= RAISE LP IGNORE RP */
110645: {
110646: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
110647: if( yygotominor.yy118.pExpr ){
110648: yygotominor.yy118.pExpr->affinity = OE_Ignore;
110649: }
110650: yygotominor.yy118.zStart = yymsp[-3].minor.yy0.z;
110651: yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110652: }
110653: break;
110654: case 296: /* expr ::= RAISE LP raisetype COMMA nm RP */
110655: {
110656: yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
110657: if( yygotominor.yy118.pExpr ) {
110658: yygotominor.yy118.pExpr->affinity = (char)yymsp[-3].minor.yy4;
110659: }
110660: yygotominor.yy118.zStart = yymsp[-5].minor.yy0.z;
110661: yygotominor.yy118.zEnd = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n];
110662: }
110663: break;
110664: case 297: /* raisetype ::= ROLLBACK */
110665: {yygotominor.yy4 = OE_Rollback;}
110666: break;
110667: case 299: /* raisetype ::= FAIL */
110668: {yygotominor.yy4 = OE_Fail;}
110669: break;
110670: case 300: /* cmd ::= DROP TRIGGER ifexists fullname */
110671: {
110672: sqlite3DropTrigger(pParse,yymsp[0].minor.yy259,yymsp[-1].minor.yy4);
110673: }
110674: break;
110675: case 301: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
110676: {
110677: sqlite3Attach(pParse, yymsp[-3].minor.yy118.pExpr, yymsp[-1].minor.yy118.pExpr, yymsp[0].minor.yy314);
110678: }
110679: break;
110680: case 302: /* cmd ::= DETACH database_kw_opt expr */
110681: {
110682: sqlite3Detach(pParse, yymsp[0].minor.yy118.pExpr);
110683: }
110684: break;
110685: case 307: /* cmd ::= REINDEX */
110686: {sqlite3Reindex(pParse, 0, 0);}
110687: break;
110688: case 308: /* cmd ::= REINDEX nm dbnm */
110689: {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
110690: break;
110691: case 309: /* cmd ::= ANALYZE */
110692: {sqlite3Analyze(pParse, 0, 0);}
110693: break;
110694: case 310: /* cmd ::= ANALYZE nm dbnm */
110695: {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
110696: break;
110697: case 311: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
110698: {
110699: sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy259,&yymsp[0].minor.yy0);
110700: }
110701: break;
110702: case 312: /* cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column */
110703: {
110704: sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0);
110705: }
110706: break;
110707: case 313: /* add_column_fullname ::= fullname */
110708: {
110709: pParse->db->lookaside.bEnabled = 0;
110710: sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy259);
110711: }
110712: break;
110713: case 316: /* cmd ::= create_vtab */
110714: {sqlite3VtabFinishParse(pParse,0);}
110715: break;
110716: case 317: /* cmd ::= create_vtab LP vtabarglist RP */
110717: {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
110718: break;
110719: case 318: /* create_vtab ::= createkw VIRTUAL TABLE nm dbnm USING nm */
110720: {
110721: sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
110722: }
110723: break;
110724: case 321: /* vtabarg ::= */
110725: {sqlite3VtabArgInit(pParse);}
110726: break;
110727: case 323: /* vtabargtoken ::= ANY */
110728: case 324: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==324);
110729: case 325: /* lp ::= LP */ yytestcase(yyruleno==325);
110730: {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
110731: break;
110732: default:
110733: /* (0) input ::= cmdlist */ yytestcase(yyruleno==0);
110734: /* (1) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==1);
110735: /* (2) cmdlist ::= ecmd */ yytestcase(yyruleno==2);
110736: /* (3) ecmd ::= SEMI */ yytestcase(yyruleno==3);
110737: /* (4) ecmd ::= explain cmdx SEMI */ yytestcase(yyruleno==4);
110738: /* (10) trans_opt ::= */ yytestcase(yyruleno==10);
110739: /* (11) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==11);
110740: /* (12) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==12);
110741: /* (20) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==20);
110742: /* (21) savepoint_opt ::= */ yytestcase(yyruleno==21);
110743: /* (25) cmd ::= create_table create_table_args */ yytestcase(yyruleno==25);
110744: /* (34) columnlist ::= columnlist COMMA column */ yytestcase(yyruleno==34);
110745: /* (35) columnlist ::= column */ yytestcase(yyruleno==35);
110746: /* (44) type ::= */ yytestcase(yyruleno==44);
110747: /* (51) signed ::= plus_num */ yytestcase(yyruleno==51);
110748: /* (52) signed ::= minus_num */ yytestcase(yyruleno==52);
110749: /* (53) carglist ::= carglist carg */ yytestcase(yyruleno==53);
110750: /* (54) carglist ::= */ yytestcase(yyruleno==54);
110751: /* (55) carg ::= CONSTRAINT nm ccons */ yytestcase(yyruleno==55);
110752: /* (56) carg ::= ccons */ yytestcase(yyruleno==56);
110753: /* (62) ccons ::= NULL onconf */ yytestcase(yyruleno==62);
110754: /* (90) conslist ::= conslist COMMA tcons */ yytestcase(yyruleno==90);
110755: /* (91) conslist ::= conslist tcons */ yytestcase(yyruleno==91);
110756: /* (92) conslist ::= tcons */ yytestcase(yyruleno==92);
110757: /* (93) tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==93);
110758: /* (268) plus_opt ::= PLUS */ yytestcase(yyruleno==268);
110759: /* (269) plus_opt ::= */ yytestcase(yyruleno==269);
110760: /* (279) foreach_clause ::= */ yytestcase(yyruleno==279);
110761: /* (280) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==280);
110762: /* (287) tridxby ::= */ yytestcase(yyruleno==287);
110763: /* (305) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==305);
110764: /* (306) database_kw_opt ::= */ yytestcase(yyruleno==306);
110765: /* (314) kwcolumn_opt ::= */ yytestcase(yyruleno==314);
110766: /* (315) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==315);
110767: /* (319) vtabarglist ::= vtabarg */ yytestcase(yyruleno==319);
110768: /* (320) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==320);
110769: /* (322) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==322);
110770: /* (326) anylist ::= */ yytestcase(yyruleno==326);
110771: /* (327) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==327);
110772: /* (328) anylist ::= anylist ANY */ yytestcase(yyruleno==328);
110773: break;
110774: };
110775: yygoto = yyRuleInfo[yyruleno].lhs;
110776: yysize = yyRuleInfo[yyruleno].nrhs;
110777: yypParser->yyidx -= yysize;
110778: yyact = yy_find_reduce_action(yymsp[-yysize].stateno,(YYCODETYPE)yygoto);
110779: if( yyact < YYNSTATE ){
110780: #ifdef NDEBUG
110781: /* If we are not debugging and the reduce action popped at least
110782: ** one element off the stack, then we can push the new element back
110783: ** onto the stack here, and skip the stack overflow test in yy_shift().
110784: ** That gives a significant speed improvement. */
110785: if( yysize ){
110786: yypParser->yyidx++;
110787: yymsp -= yysize-1;
110788: yymsp->stateno = (YYACTIONTYPE)yyact;
110789: yymsp->major = (YYCODETYPE)yygoto;
110790: yymsp->minor = yygotominor;
110791: }else
110792: #endif
110793: {
110794: yy_shift(yypParser,yyact,yygoto,&yygotominor);
110795: }
110796: }else{
110797: assert( yyact == YYNSTATE + YYNRULE + 1 );
110798: yy_accept(yypParser);
110799: }
110800: }
110801:
110802: /*
110803: ** The following code executes when the parse fails
110804: */
110805: #ifndef YYNOERRORRECOVERY
110806: static void yy_parse_failed(
110807: yyParser *yypParser /* The parser */
110808: ){
110809: sqlite3ParserARG_FETCH;
110810: #ifndef NDEBUG
110811: if( yyTraceFILE ){
110812: fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
110813: }
110814: #endif
110815: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
110816: /* Here code is inserted which will be executed whenever the
110817: ** parser fails */
110818: sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
110819: }
110820: #endif /* YYNOERRORRECOVERY */
110821:
110822: /*
110823: ** The following code executes when a syntax error first occurs.
110824: */
110825: static void yy_syntax_error(
110826: yyParser *yypParser, /* The parser */
110827: int yymajor, /* The major type of the error token */
110828: YYMINORTYPE yyminor /* The minor type of the error token */
110829: ){
110830: sqlite3ParserARG_FETCH;
110831: #define TOKEN (yyminor.yy0)
110832:
110833: UNUSED_PARAMETER(yymajor); /* Silence some compiler warnings */
110834: assert( TOKEN.z[0] ); /* The tokenizer always gives us a token */
110835: sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
110836: sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
110837: }
110838:
110839: /*
110840: ** The following is executed when the parser accepts
110841: */
110842: static void yy_accept(
110843: yyParser *yypParser /* The parser */
110844: ){
110845: sqlite3ParserARG_FETCH;
110846: #ifndef NDEBUG
110847: if( yyTraceFILE ){
110848: fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
110849: }
110850: #endif
110851: while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser);
110852: /* Here code is inserted which will be executed whenever the
110853: ** parser accepts */
110854: sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
110855: }
110856:
110857: /* The main parser program.
110858: ** The first argument is a pointer to a structure obtained from
110859: ** "sqlite3ParserAlloc" which describes the current state of the parser.
110860: ** The second argument is the major token number. The third is
110861: ** the minor token. The fourth optional argument is whatever the
110862: ** user wants (and specified in the grammar) and is available for
110863: ** use by the action routines.
110864: **
110865: ** Inputs:
110866: ** <ul>
110867: ** <li> A pointer to the parser (an opaque structure.)
110868: ** <li> The major token number.
110869: ** <li> The minor token number.
110870: ** <li> An option argument of a grammar-specified type.
110871: ** </ul>
110872: **
110873: ** Outputs:
110874: ** None.
110875: */
110876: SQLITE_PRIVATE void sqlite3Parser(
110877: void *yyp, /* The parser */
110878: int yymajor, /* The major token code number */
110879: sqlite3ParserTOKENTYPE yyminor /* The value for the token */
110880: sqlite3ParserARG_PDECL /* Optional %extra_argument parameter */
110881: ){
110882: YYMINORTYPE yyminorunion;
110883: int yyact; /* The parser action. */
110884: #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
110885: int yyendofinput; /* True if we are at the end of input */
110886: #endif
110887: #ifdef YYERRORSYMBOL
110888: int yyerrorhit = 0; /* True if yymajor has invoked an error */
110889: #endif
110890: yyParser *yypParser; /* The parser */
110891:
110892: /* (re)initialize the parser, if necessary */
110893: yypParser = (yyParser*)yyp;
110894: if( yypParser->yyidx<0 ){
110895: #if YYSTACKDEPTH<=0
110896: if( yypParser->yystksz <=0 ){
110897: /*memset(&yyminorunion, 0, sizeof(yyminorunion));*/
110898: yyminorunion = yyzerominor;
110899: yyStackOverflow(yypParser, &yyminorunion);
110900: return;
110901: }
110902: #endif
110903: yypParser->yyidx = 0;
110904: yypParser->yyerrcnt = -1;
110905: yypParser->yystack[0].stateno = 0;
110906: yypParser->yystack[0].major = 0;
110907: }
110908: yyminorunion.yy0 = yyminor;
110909: #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
110910: yyendofinput = (yymajor==0);
110911: #endif
110912: sqlite3ParserARG_STORE;
110913:
110914: #ifndef NDEBUG
110915: if( yyTraceFILE ){
110916: fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]);
110917: }
110918: #endif
110919:
110920: do{
110921: yyact = yy_find_shift_action(yypParser,(YYCODETYPE)yymajor);
110922: if( yyact<YYNSTATE ){
110923: yy_shift(yypParser,yyact,yymajor,&yyminorunion);
110924: yypParser->yyerrcnt--;
110925: yymajor = YYNOCODE;
110926: }else if( yyact < YYNSTATE + YYNRULE ){
110927: yy_reduce(yypParser,yyact-YYNSTATE);
110928: }else{
110929: assert( yyact == YY_ERROR_ACTION );
110930: #ifdef YYERRORSYMBOL
110931: int yymx;
110932: #endif
110933: #ifndef NDEBUG
110934: if( yyTraceFILE ){
110935: fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
110936: }
110937: #endif
110938: #ifdef YYERRORSYMBOL
110939: /* A syntax error has occurred.
110940: ** The response to an error depends upon whether or not the
110941: ** grammar defines an error token "ERROR".
110942: **
110943: ** This is what we do if the grammar does define ERROR:
110944: **
110945: ** * Call the %syntax_error function.
110946: **
110947: ** * Begin popping the stack until we enter a state where
110948: ** it is legal to shift the error symbol, then shift
110949: ** the error symbol.
110950: **
110951: ** * Set the error count to three.
110952: **
110953: ** * Begin accepting and shifting new tokens. No new error
110954: ** processing will occur until three tokens have been
110955: ** shifted successfully.
110956: **
110957: */
110958: if( yypParser->yyerrcnt<0 ){
110959: yy_syntax_error(yypParser,yymajor,yyminorunion);
110960: }
110961: yymx = yypParser->yystack[yypParser->yyidx].major;
110962: if( yymx==YYERRORSYMBOL || yyerrorhit ){
110963: #ifndef NDEBUG
110964: if( yyTraceFILE ){
110965: fprintf(yyTraceFILE,"%sDiscard input token %s\n",
110966: yyTracePrompt,yyTokenName[yymajor]);
110967: }
110968: #endif
110969: yy_destructor(yypParser, (YYCODETYPE)yymajor,&yyminorunion);
110970: yymajor = YYNOCODE;
110971: }else{
110972: while(
110973: yypParser->yyidx >= 0 &&
110974: yymx != YYERRORSYMBOL &&
110975: (yyact = yy_find_reduce_action(
110976: yypParser->yystack[yypParser->yyidx].stateno,
110977: YYERRORSYMBOL)) >= YYNSTATE
110978: ){
110979: yy_pop_parser_stack(yypParser);
110980: }
110981: if( yypParser->yyidx < 0 || yymajor==0 ){
110982: yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
110983: yy_parse_failed(yypParser);
110984: yymajor = YYNOCODE;
110985: }else if( yymx!=YYERRORSYMBOL ){
110986: YYMINORTYPE u2;
110987: u2.YYERRSYMDT = 0;
110988: yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2);
110989: }
110990: }
110991: yypParser->yyerrcnt = 3;
110992: yyerrorhit = 1;
110993: #elif defined(YYNOERRORRECOVERY)
110994: /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
110995: ** do any kind of error recovery. Instead, simply invoke the syntax
110996: ** error routine and continue going as if nothing had happened.
110997: **
110998: ** Applications can set this macro (for example inside %include) if
110999: ** they intend to abandon the parse upon the first syntax error seen.
111000: */
111001: yy_syntax_error(yypParser,yymajor,yyminorunion);
111002: yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
111003: yymajor = YYNOCODE;
111004:
111005: #else /* YYERRORSYMBOL is not defined */
111006: /* This is what we do if the grammar does not define ERROR:
111007: **
111008: ** * Report an error message, and throw away the input token.
111009: **
111010: ** * If the input token is $, then fail the parse.
111011: **
111012: ** As before, subsequent error messages are suppressed until
111013: ** three input tokens have been successfully shifted.
111014: */
111015: if( yypParser->yyerrcnt<=0 ){
111016: yy_syntax_error(yypParser,yymajor,yyminorunion);
111017: }
111018: yypParser->yyerrcnt = 3;
111019: yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
111020: if( yyendofinput ){
111021: yy_parse_failed(yypParser);
111022: }
111023: yymajor = YYNOCODE;
111024: #endif
111025: }
111026: }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 );
111027: return;
111028: }
111029:
111030: /************** End of parse.c ***********************************************/
111031: /************** Begin file tokenize.c ****************************************/
111032: /*
111033: ** 2001 September 15
111034: **
111035: ** The author disclaims copyright to this source code. In place of
111036: ** a legal notice, here is a blessing:
111037: **
111038: ** May you do good and not evil.
111039: ** May you find forgiveness for yourself and forgive others.
111040: ** May you share freely, never taking more than you give.
111041: **
111042: *************************************************************************
111043: ** An tokenizer for SQL
111044: **
111045: ** This file contains C code that splits an SQL input string up into
111046: ** individual tokens and sends those tokens one-by-one over to the
111047: ** parser for analysis.
111048: */
111049: /* #include <stdlib.h> */
111050:
111051: /*
111052: ** The charMap() macro maps alphabetic characters into their
111053: ** lower-case ASCII equivalent. On ASCII machines, this is just
111054: ** an upper-to-lower case map. On EBCDIC machines we also need
111055: ** to adjust the encoding. Only alphabetic characters and underscores
111056: ** need to be translated.
111057: */
111058: #ifdef SQLITE_ASCII
111059: # define charMap(X) sqlite3UpperToLower[(unsigned char)X]
111060: #endif
111061: #ifdef SQLITE_EBCDIC
111062: # define charMap(X) ebcdicToAscii[(unsigned char)X]
111063: const unsigned char ebcdicToAscii[] = {
111064: /* 0 1 2 3 4 5 6 7 8 9 A B C D E F */
111065: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */
111066: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */
111067: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */
111068: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 3x */
111069: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 4x */
111070: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 5x */
111071: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95, 0, 0, /* 6x */
111072: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 7x */
111073: 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* 8x */
111074: 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* 9x */
111075: 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ax */
111076: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */
111077: 0, 97, 98, 99,100,101,102,103,104,105, 0, 0, 0, 0, 0, 0, /* Cx */
111078: 0,106,107,108,109,110,111,112,113,114, 0, 0, 0, 0, 0, 0, /* Dx */
111079: 0, 0,115,116,117,118,119,120,121,122, 0, 0, 0, 0, 0, 0, /* Ex */
111080: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Fx */
111081: };
111082: #endif
111083:
111084: /*
111085: ** The sqlite3KeywordCode function looks up an identifier to determine if
111086: ** it is a keyword. If it is a keyword, the token code of that keyword is
111087: ** returned. If the input is not a keyword, TK_ID is returned.
111088: **
111089: ** The implementation of this routine was generated by a program,
111090: ** mkkeywordhash.h, located in the tool subdirectory of the distribution.
111091: ** The output of the mkkeywordhash.c program is written into a file
111092: ** named keywordhash.h and then included into this source file by
111093: ** the #include below.
111094: */
111095: /************** Include keywordhash.h in the middle of tokenize.c ************/
111096: /************** Begin file keywordhash.h *************************************/
111097: /***** This file contains automatically generated code ******
111098: **
111099: ** The code in this file has been automatically generated by
111100: **
111101: ** sqlite/tool/mkkeywordhash.c
111102: **
111103: ** The code in this file implements a function that determines whether
111104: ** or not a given identifier is really an SQL keyword. The same thing
111105: ** might be implemented more directly using a hand-written hash table.
111106: ** But by using this automatically generated code, the size of the code
111107: ** is substantially reduced. This is important for embedded applications
111108: ** on platforms with limited memory.
111109: */
111110: /* Hash score: 175 */
111111: static int keywordCode(const char *z, int n){
111112: /* zText[] encodes 811 bytes of keywords in 541 bytes */
111113: /* REINDEXEDESCAPEACHECKEYBEFOREIGNOREGEXPLAINSTEADDATABASELECT */
111114: /* ABLEFTHENDEFERRABLELSEXCEPTRANSACTIONATURALTERAISEXCLUSIVE */
111115: /* XISTSAVEPOINTERSECTRIGGEREFERENCESCONSTRAINTOFFSETEMPORARY */
111116: /* UNIQUERYATTACHAVINGROUPDATEBEGINNERELEASEBETWEENOTNULLIKE */
111117: /* CASCADELETECASECOLLATECREATECURRENT_DATEDETACHIMMEDIATEJOIN */
111118: /* SERTMATCHPLANALYZEPRAGMABORTVALUESVIRTUALIMITWHENWHERENAME */
111119: /* AFTEREPLACEANDEFAULTAUTOINCREMENTCASTCOLUMNCOMMITCONFLICTCROSS */
111120: /* CURRENT_TIMESTAMPRIMARYDEFERREDISTINCTDROPFAILFROMFULLGLOBYIF */
111121: /* ISNULLORDERESTRICTOUTERIGHTROLLBACKROWUNIONUSINGVACUUMVIEW */
111122: /* INITIALLY */
111123: static const char zText[540] = {
111124: 'R','E','I','N','D','E','X','E','D','E','S','C','A','P','E','A','C','H',
111125: 'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G',
111126: 'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A',
111127: 'S','E','L','E','C','T','A','B','L','E','F','T','H','E','N','D','E','F',
111128: 'E','R','R','A','B','L','E','L','S','E','X','C','E','P','T','R','A','N',
111129: 'S','A','C','T','I','O','N','A','T','U','R','A','L','T','E','R','A','I',
111130: 'S','E','X','C','L','U','S','I','V','E','X','I','S','T','S','A','V','E',
111131: 'P','O','I','N','T','E','R','S','E','C','T','R','I','G','G','E','R','E',
111132: 'F','E','R','E','N','C','E','S','C','O','N','S','T','R','A','I','N','T',
111133: 'O','F','F','S','E','T','E','M','P','O','R','A','R','Y','U','N','I','Q',
111134: 'U','E','R','Y','A','T','T','A','C','H','A','V','I','N','G','R','O','U',
111135: 'P','D','A','T','E','B','E','G','I','N','N','E','R','E','L','E','A','S',
111136: 'E','B','E','T','W','E','E','N','O','T','N','U','L','L','I','K','E','C',
111137: 'A','S','C','A','D','E','L','E','T','E','C','A','S','E','C','O','L','L',
111138: 'A','T','E','C','R','E','A','T','E','C','U','R','R','E','N','T','_','D',
111139: 'A','T','E','D','E','T','A','C','H','I','M','M','E','D','I','A','T','E',
111140: 'J','O','I','N','S','E','R','T','M','A','T','C','H','P','L','A','N','A',
111141: 'L','Y','Z','E','P','R','A','G','M','A','B','O','R','T','V','A','L','U',
111142: 'E','S','V','I','R','T','U','A','L','I','M','I','T','W','H','E','N','W',
111143: 'H','E','R','E','N','A','M','E','A','F','T','E','R','E','P','L','A','C',
111144: 'E','A','N','D','E','F','A','U','L','T','A','U','T','O','I','N','C','R',
111145: 'E','M','E','N','T','C','A','S','T','C','O','L','U','M','N','C','O','M',
111146: 'M','I','T','C','O','N','F','L','I','C','T','C','R','O','S','S','C','U',
111147: 'R','R','E','N','T','_','T','I','M','E','S','T','A','M','P','R','I','M',
111148: 'A','R','Y','D','E','F','E','R','R','E','D','I','S','T','I','N','C','T',
111149: 'D','R','O','P','F','A','I','L','F','R','O','M','F','U','L','L','G','L',
111150: 'O','B','Y','I','F','I','S','N','U','L','L','O','R','D','E','R','E','S',
111151: 'T','R','I','C','T','O','U','T','E','R','I','G','H','T','R','O','L','L',
111152: 'B','A','C','K','R','O','W','U','N','I','O','N','U','S','I','N','G','V',
111153: 'A','C','U','U','M','V','I','E','W','I','N','I','T','I','A','L','L','Y',
111154: };
111155: static const unsigned char aHash[127] = {
111156: 72, 101, 114, 70, 0, 45, 0, 0, 78, 0, 73, 0, 0,
111157: 42, 12, 74, 15, 0, 113, 81, 50, 108, 0, 19, 0, 0,
111158: 118, 0, 116, 111, 0, 22, 89, 0, 9, 0, 0, 66, 67,
111159: 0, 65, 6, 0, 48, 86, 98, 0, 115, 97, 0, 0, 44,
111160: 0, 99, 24, 0, 17, 0, 119, 49, 23, 0, 5, 106, 25,
111161: 92, 0, 0, 121, 102, 56, 120, 53, 28, 51, 0, 87, 0,
111162: 96, 26, 0, 95, 0, 0, 0, 91, 88, 93, 84, 105, 14,
111163: 39, 104, 0, 77, 0, 18, 85, 107, 32, 0, 117, 76, 109,
111164: 58, 46, 80, 0, 0, 90, 40, 0, 112, 0, 36, 0, 0,
111165: 29, 0, 82, 59, 60, 0, 20, 57, 0, 52,
111166: };
111167: static const unsigned char aNext[121] = {
111168: 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0,
111169: 0, 2, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0,
111170: 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
111171: 0, 0, 0, 0, 33, 0, 21, 0, 0, 0, 43, 3, 47,
111172: 0, 0, 0, 0, 30, 0, 54, 0, 38, 0, 0, 0, 1,
111173: 62, 0, 0, 63, 0, 41, 0, 0, 0, 0, 0, 0, 0,
111174: 61, 0, 0, 0, 0, 31, 55, 16, 34, 10, 0, 0, 0,
111175: 0, 0, 0, 0, 11, 68, 75, 0, 8, 0, 100, 94, 0,
111176: 103, 0, 83, 0, 71, 0, 0, 110, 27, 37, 69, 79, 0,
111177: 35, 64, 0, 0,
111178: };
111179: static const unsigned char aLen[121] = {
111180: 7, 7, 5, 4, 6, 4, 5, 3, 6, 7, 3, 6, 6,
111181: 7, 7, 3, 8, 2, 6, 5, 4, 4, 3, 10, 4, 6,
111182: 11, 6, 2, 7, 5, 5, 9, 6, 9, 9, 7, 10, 10,
111183: 4, 6, 2, 3, 9, 4, 2, 6, 5, 6, 6, 5, 6,
111184: 5, 5, 7, 7, 7, 3, 2, 4, 4, 7, 3, 6, 4,
111185: 7, 6, 12, 6, 9, 4, 6, 5, 4, 7, 6, 5, 6,
111186: 7, 5, 4, 5, 6, 5, 7, 3, 7, 13, 2, 2, 4,
111187: 6, 6, 8, 5, 17, 12, 7, 8, 8, 2, 4, 4, 4,
111188: 4, 4, 2, 2, 6, 5, 8, 5, 5, 8, 3, 5, 5,
111189: 6, 4, 9, 3,
111190: };
111191: static const unsigned short int aOffset[121] = {
111192: 0, 2, 2, 8, 9, 14, 16, 20, 23, 25, 25, 29, 33,
111193: 36, 41, 46, 48, 53, 54, 59, 62, 65, 67, 69, 78, 81,
111194: 86, 91, 95, 96, 101, 105, 109, 117, 122, 128, 136, 142, 152,
111195: 159, 162, 162, 165, 167, 167, 171, 176, 179, 184, 189, 194, 197,
111196: 203, 206, 210, 217, 223, 223, 223, 226, 229, 233, 234, 238, 244,
111197: 248, 255, 261, 273, 279, 288, 290, 296, 301, 303, 310, 315, 320,
111198: 326, 332, 337, 341, 344, 350, 354, 361, 363, 370, 372, 374, 383,
111199: 387, 393, 399, 407, 412, 412, 428, 435, 442, 443, 450, 454, 458,
111200: 462, 466, 469, 471, 473, 479, 483, 491, 495, 500, 508, 511, 516,
111201: 521, 527, 531, 536,
111202: };
111203: static const unsigned char aCode[121] = {
111204: TK_REINDEX, TK_INDEXED, TK_INDEX, TK_DESC, TK_ESCAPE,
111205: TK_EACH, TK_CHECK, TK_KEY, TK_BEFORE, TK_FOREIGN,
111206: TK_FOR, TK_IGNORE, TK_LIKE_KW, TK_EXPLAIN, TK_INSTEAD,
111207: TK_ADD, TK_DATABASE, TK_AS, TK_SELECT, TK_TABLE,
111208: TK_JOIN_KW, TK_THEN, TK_END, TK_DEFERRABLE, TK_ELSE,
111209: TK_EXCEPT, TK_TRANSACTION,TK_ACTION, TK_ON, TK_JOIN_KW,
111210: TK_ALTER, TK_RAISE, TK_EXCLUSIVE, TK_EXISTS, TK_SAVEPOINT,
111211: TK_INTERSECT, TK_TRIGGER, TK_REFERENCES, TK_CONSTRAINT, TK_INTO,
111212: TK_OFFSET, TK_OF, TK_SET, TK_TEMP, TK_TEMP,
111213: TK_OR, TK_UNIQUE, TK_QUERY, TK_ATTACH, TK_HAVING,
111214: TK_GROUP, TK_UPDATE, TK_BEGIN, TK_JOIN_KW, TK_RELEASE,
111215: TK_BETWEEN, TK_NOTNULL, TK_NOT, TK_NO, TK_NULL,
111216: TK_LIKE_KW, TK_CASCADE, TK_ASC, TK_DELETE, TK_CASE,
111217: TK_COLLATE, TK_CREATE, TK_CTIME_KW, TK_DETACH, TK_IMMEDIATE,
111218: TK_JOIN, TK_INSERT, TK_MATCH, TK_PLAN, TK_ANALYZE,
111219: TK_PRAGMA, TK_ABORT, TK_VALUES, TK_VIRTUAL, TK_LIMIT,
111220: TK_WHEN, TK_WHERE, TK_RENAME, TK_AFTER, TK_REPLACE,
111221: TK_AND, TK_DEFAULT, TK_AUTOINCR, TK_TO, TK_IN,
111222: TK_CAST, TK_COLUMNKW, TK_COMMIT, TK_CONFLICT, TK_JOIN_KW,
111223: TK_CTIME_KW, TK_CTIME_KW, TK_PRIMARY, TK_DEFERRED, TK_DISTINCT,
111224: TK_IS, TK_DROP, TK_FAIL, TK_FROM, TK_JOIN_KW,
111225: TK_LIKE_KW, TK_BY, TK_IF, TK_ISNULL, TK_ORDER,
111226: TK_RESTRICT, TK_JOIN_KW, TK_JOIN_KW, TK_ROLLBACK, TK_ROW,
111227: TK_UNION, TK_USING, TK_VACUUM, TK_VIEW, TK_INITIALLY,
111228: TK_ALL,
111229: };
111230: int h, i;
111231: if( n<2 ) return TK_ID;
111232: h = ((charMap(z[0])*4) ^
111233: (charMap(z[n-1])*3) ^
111234: n) % 127;
111235: for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){
111236: if( aLen[i]==n && sqlite3StrNICmp(&zText[aOffset[i]],z,n)==0 ){
111237: testcase( i==0 ); /* REINDEX */
111238: testcase( i==1 ); /* INDEXED */
111239: testcase( i==2 ); /* INDEX */
111240: testcase( i==3 ); /* DESC */
111241: testcase( i==4 ); /* ESCAPE */
111242: testcase( i==5 ); /* EACH */
111243: testcase( i==6 ); /* CHECK */
111244: testcase( i==7 ); /* KEY */
111245: testcase( i==8 ); /* BEFORE */
111246: testcase( i==9 ); /* FOREIGN */
111247: testcase( i==10 ); /* FOR */
111248: testcase( i==11 ); /* IGNORE */
111249: testcase( i==12 ); /* REGEXP */
111250: testcase( i==13 ); /* EXPLAIN */
111251: testcase( i==14 ); /* INSTEAD */
111252: testcase( i==15 ); /* ADD */
111253: testcase( i==16 ); /* DATABASE */
111254: testcase( i==17 ); /* AS */
111255: testcase( i==18 ); /* SELECT */
111256: testcase( i==19 ); /* TABLE */
111257: testcase( i==20 ); /* LEFT */
111258: testcase( i==21 ); /* THEN */
111259: testcase( i==22 ); /* END */
111260: testcase( i==23 ); /* DEFERRABLE */
111261: testcase( i==24 ); /* ELSE */
111262: testcase( i==25 ); /* EXCEPT */
111263: testcase( i==26 ); /* TRANSACTION */
111264: testcase( i==27 ); /* ACTION */
111265: testcase( i==28 ); /* ON */
111266: testcase( i==29 ); /* NATURAL */
111267: testcase( i==30 ); /* ALTER */
111268: testcase( i==31 ); /* RAISE */
111269: testcase( i==32 ); /* EXCLUSIVE */
111270: testcase( i==33 ); /* EXISTS */
111271: testcase( i==34 ); /* SAVEPOINT */
111272: testcase( i==35 ); /* INTERSECT */
111273: testcase( i==36 ); /* TRIGGER */
111274: testcase( i==37 ); /* REFERENCES */
111275: testcase( i==38 ); /* CONSTRAINT */
111276: testcase( i==39 ); /* INTO */
111277: testcase( i==40 ); /* OFFSET */
111278: testcase( i==41 ); /* OF */
111279: testcase( i==42 ); /* SET */
111280: testcase( i==43 ); /* TEMPORARY */
111281: testcase( i==44 ); /* TEMP */
111282: testcase( i==45 ); /* OR */
111283: testcase( i==46 ); /* UNIQUE */
111284: testcase( i==47 ); /* QUERY */
111285: testcase( i==48 ); /* ATTACH */
111286: testcase( i==49 ); /* HAVING */
111287: testcase( i==50 ); /* GROUP */
111288: testcase( i==51 ); /* UPDATE */
111289: testcase( i==52 ); /* BEGIN */
111290: testcase( i==53 ); /* INNER */
111291: testcase( i==54 ); /* RELEASE */
111292: testcase( i==55 ); /* BETWEEN */
111293: testcase( i==56 ); /* NOTNULL */
111294: testcase( i==57 ); /* NOT */
111295: testcase( i==58 ); /* NO */
111296: testcase( i==59 ); /* NULL */
111297: testcase( i==60 ); /* LIKE */
111298: testcase( i==61 ); /* CASCADE */
111299: testcase( i==62 ); /* ASC */
111300: testcase( i==63 ); /* DELETE */
111301: testcase( i==64 ); /* CASE */
111302: testcase( i==65 ); /* COLLATE */
111303: testcase( i==66 ); /* CREATE */
111304: testcase( i==67 ); /* CURRENT_DATE */
111305: testcase( i==68 ); /* DETACH */
111306: testcase( i==69 ); /* IMMEDIATE */
111307: testcase( i==70 ); /* JOIN */
111308: testcase( i==71 ); /* INSERT */
111309: testcase( i==72 ); /* MATCH */
111310: testcase( i==73 ); /* PLAN */
111311: testcase( i==74 ); /* ANALYZE */
111312: testcase( i==75 ); /* PRAGMA */
111313: testcase( i==76 ); /* ABORT */
111314: testcase( i==77 ); /* VALUES */
111315: testcase( i==78 ); /* VIRTUAL */
111316: testcase( i==79 ); /* LIMIT */
111317: testcase( i==80 ); /* WHEN */
111318: testcase( i==81 ); /* WHERE */
111319: testcase( i==82 ); /* RENAME */
111320: testcase( i==83 ); /* AFTER */
111321: testcase( i==84 ); /* REPLACE */
111322: testcase( i==85 ); /* AND */
111323: testcase( i==86 ); /* DEFAULT */
111324: testcase( i==87 ); /* AUTOINCREMENT */
111325: testcase( i==88 ); /* TO */
111326: testcase( i==89 ); /* IN */
111327: testcase( i==90 ); /* CAST */
111328: testcase( i==91 ); /* COLUMN */
111329: testcase( i==92 ); /* COMMIT */
111330: testcase( i==93 ); /* CONFLICT */
111331: testcase( i==94 ); /* CROSS */
111332: testcase( i==95 ); /* CURRENT_TIMESTAMP */
111333: testcase( i==96 ); /* CURRENT_TIME */
111334: testcase( i==97 ); /* PRIMARY */
111335: testcase( i==98 ); /* DEFERRED */
111336: testcase( i==99 ); /* DISTINCT */
111337: testcase( i==100 ); /* IS */
111338: testcase( i==101 ); /* DROP */
111339: testcase( i==102 ); /* FAIL */
111340: testcase( i==103 ); /* FROM */
111341: testcase( i==104 ); /* FULL */
111342: testcase( i==105 ); /* GLOB */
111343: testcase( i==106 ); /* BY */
111344: testcase( i==107 ); /* IF */
111345: testcase( i==108 ); /* ISNULL */
111346: testcase( i==109 ); /* ORDER */
111347: testcase( i==110 ); /* RESTRICT */
111348: testcase( i==111 ); /* OUTER */
111349: testcase( i==112 ); /* RIGHT */
111350: testcase( i==113 ); /* ROLLBACK */
111351: testcase( i==114 ); /* ROW */
111352: testcase( i==115 ); /* UNION */
111353: testcase( i==116 ); /* USING */
111354: testcase( i==117 ); /* VACUUM */
111355: testcase( i==118 ); /* VIEW */
111356: testcase( i==119 ); /* INITIALLY */
111357: testcase( i==120 ); /* ALL */
111358: return aCode[i];
111359: }
111360: }
111361: return TK_ID;
111362: }
111363: SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){
111364: return keywordCode((char*)z, n);
111365: }
111366: #define SQLITE_N_KEYWORD 121
111367:
111368: /************** End of keywordhash.h *****************************************/
111369: /************** Continuing where we left off in tokenize.c *******************/
111370:
111371:
111372: /*
111373: ** If X is a character that can be used in an identifier then
111374: ** IdChar(X) will be true. Otherwise it is false.
111375: **
111376: ** For ASCII, any character with the high-order bit set is
111377: ** allowed in an identifier. For 7-bit characters,
111378: ** sqlite3IsIdChar[X] must be 1.
111379: **
111380: ** For EBCDIC, the rules are more complex but have the same
111381: ** end result.
111382: **
111383: ** Ticket #1066. the SQL standard does not allow '$' in the
111384: ** middle of identfiers. But many SQL implementations do.
111385: ** SQLite will allow '$' in identifiers for compatibility.
111386: ** But the feature is undocumented.
111387: */
111388: #ifdef SQLITE_ASCII
111389: #define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)
111390: #endif
111391: #ifdef SQLITE_EBCDIC
111392: SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[] = {
111393: /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
111394: 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 4x */
111395: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, /* 5x */
111396: 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, /* 6x */
111397: 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, /* 7x */
111398: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, /* 8x */
111399: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, /* 9x */
111400: 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, /* Ax */
111401: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Bx */
111402: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Cx */
111403: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Dx */
111404: 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, /* Ex */
111405: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, /* Fx */
111406: };
111407: #define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
111408: #endif
111409:
111410:
111411: /*
111412: ** Return the length of the token that begins at z[0].
111413: ** Store the token type in *tokenType before returning.
111414: */
111415: SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
111416: int i, c;
111417: switch( *z ){
111418: case ' ': case '\t': case '\n': case '\f': case '\r': {
111419: testcase( z[0]==' ' );
111420: testcase( z[0]=='\t' );
111421: testcase( z[0]=='\n' );
111422: testcase( z[0]=='\f' );
111423: testcase( z[0]=='\r' );
111424: for(i=1; sqlite3Isspace(z[i]); i++){}
111425: *tokenType = TK_SPACE;
111426: return i;
111427: }
111428: case '-': {
111429: if( z[1]=='-' ){
111430: /* IMP: R-50417-27976 -- syntax diagram for comments */
111431: for(i=2; (c=z[i])!=0 && c!='\n'; i++){}
111432: *tokenType = TK_SPACE; /* IMP: R-22934-25134 */
111433: return i;
111434: }
111435: *tokenType = TK_MINUS;
111436: return 1;
111437: }
111438: case '(': {
111439: *tokenType = TK_LP;
111440: return 1;
111441: }
111442: case ')': {
111443: *tokenType = TK_RP;
111444: return 1;
111445: }
111446: case ';': {
111447: *tokenType = TK_SEMI;
111448: return 1;
111449: }
111450: case '+': {
111451: *tokenType = TK_PLUS;
111452: return 1;
111453: }
111454: case '*': {
111455: *tokenType = TK_STAR;
111456: return 1;
111457: }
111458: case '/': {
111459: if( z[1]!='*' || z[2]==0 ){
111460: *tokenType = TK_SLASH;
111461: return 1;
111462: }
111463: /* IMP: R-50417-27976 -- syntax diagram for comments */
111464: for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){}
111465: if( c ) i++;
111466: *tokenType = TK_SPACE; /* IMP: R-22934-25134 */
111467: return i;
111468: }
111469: case '%': {
111470: *tokenType = TK_REM;
111471: return 1;
111472: }
111473: case '=': {
111474: *tokenType = TK_EQ;
111475: return 1 + (z[1]=='=');
111476: }
111477: case '<': {
111478: if( (c=z[1])=='=' ){
111479: *tokenType = TK_LE;
111480: return 2;
111481: }else if( c=='>' ){
111482: *tokenType = TK_NE;
111483: return 2;
111484: }else if( c=='<' ){
111485: *tokenType = TK_LSHIFT;
111486: return 2;
111487: }else{
111488: *tokenType = TK_LT;
111489: return 1;
111490: }
111491: }
111492: case '>': {
111493: if( (c=z[1])=='=' ){
111494: *tokenType = TK_GE;
111495: return 2;
111496: }else if( c=='>' ){
111497: *tokenType = TK_RSHIFT;
111498: return 2;
111499: }else{
111500: *tokenType = TK_GT;
111501: return 1;
111502: }
111503: }
111504: case '!': {
111505: if( z[1]!='=' ){
111506: *tokenType = TK_ILLEGAL;
111507: return 2;
111508: }else{
111509: *tokenType = TK_NE;
111510: return 2;
111511: }
111512: }
111513: case '|': {
111514: if( z[1]!='|' ){
111515: *tokenType = TK_BITOR;
111516: return 1;
111517: }else{
111518: *tokenType = TK_CONCAT;
111519: return 2;
111520: }
111521: }
111522: case ',': {
111523: *tokenType = TK_COMMA;
111524: return 1;
111525: }
111526: case '&': {
111527: *tokenType = TK_BITAND;
111528: return 1;
111529: }
111530: case '~': {
111531: *tokenType = TK_BITNOT;
111532: return 1;
111533: }
111534: case '`':
111535: case '\'':
111536: case '"': {
111537: int delim = z[0];
111538: testcase( delim=='`' );
111539: testcase( delim=='\'' );
111540: testcase( delim=='"' );
111541: for(i=1; (c=z[i])!=0; i++){
111542: if( c==delim ){
111543: if( z[i+1]==delim ){
111544: i++;
111545: }else{
111546: break;
111547: }
111548: }
111549: }
111550: if( c=='\'' ){
111551: *tokenType = TK_STRING;
111552: return i+1;
111553: }else if( c!=0 ){
111554: *tokenType = TK_ID;
111555: return i+1;
111556: }else{
111557: *tokenType = TK_ILLEGAL;
111558: return i;
111559: }
111560: }
111561: case '.': {
111562: #ifndef SQLITE_OMIT_FLOATING_POINT
111563: if( !sqlite3Isdigit(z[1]) )
111564: #endif
111565: {
111566: *tokenType = TK_DOT;
111567: return 1;
111568: }
111569: /* If the next character is a digit, this is a floating point
111570: ** number that begins with ".". Fall thru into the next case */
111571: }
111572: case '0': case '1': case '2': case '3': case '4':
111573: case '5': case '6': case '7': case '8': case '9': {
111574: testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' );
111575: testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' );
111576: testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' );
111577: testcase( z[0]=='9' );
111578: *tokenType = TK_INTEGER;
111579: for(i=0; sqlite3Isdigit(z[i]); i++){}
111580: #ifndef SQLITE_OMIT_FLOATING_POINT
111581: if( z[i]=='.' ){
111582: i++;
111583: while( sqlite3Isdigit(z[i]) ){ i++; }
111584: *tokenType = TK_FLOAT;
111585: }
111586: if( (z[i]=='e' || z[i]=='E') &&
111587: ( sqlite3Isdigit(z[i+1])
111588: || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2]))
111589: )
111590: ){
111591: i += 2;
111592: while( sqlite3Isdigit(z[i]) ){ i++; }
111593: *tokenType = TK_FLOAT;
111594: }
111595: #endif
111596: while( IdChar(z[i]) ){
111597: *tokenType = TK_ILLEGAL;
111598: i++;
111599: }
111600: return i;
111601: }
111602: case '[': {
111603: for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
111604: *tokenType = c==']' ? TK_ID : TK_ILLEGAL;
111605: return i;
111606: }
111607: case '?': {
111608: *tokenType = TK_VARIABLE;
111609: for(i=1; sqlite3Isdigit(z[i]); i++){}
111610: return i;
111611: }
111612: case '#': {
111613: for(i=1; sqlite3Isdigit(z[i]); i++){}
111614: if( i>1 ){
111615: /* Parameters of the form #NNN (where NNN is a number) are used
111616: ** internally by sqlite3NestedParse. */
111617: *tokenType = TK_REGISTER;
111618: return i;
111619: }
111620: /* Fall through into the next case if the '#' is not followed by
111621: ** a digit. Try to match #AAAA where AAAA is a parameter name. */
111622: }
111623: #ifndef SQLITE_OMIT_TCL_VARIABLE
111624: case '$':
111625: #endif
111626: case '@': /* For compatibility with MS SQL Server */
111627: case ':': {
111628: int n = 0;
111629: testcase( z[0]=='$' ); testcase( z[0]=='@' ); testcase( z[0]==':' );
111630: *tokenType = TK_VARIABLE;
111631: for(i=1; (c=z[i])!=0; i++){
111632: if( IdChar(c) ){
111633: n++;
111634: #ifndef SQLITE_OMIT_TCL_VARIABLE
111635: }else if( c=='(' && n>0 ){
111636: do{
111637: i++;
111638: }while( (c=z[i])!=0 && !sqlite3Isspace(c) && c!=')' );
111639: if( c==')' ){
111640: i++;
111641: }else{
111642: *tokenType = TK_ILLEGAL;
111643: }
111644: break;
111645: }else if( c==':' && z[i+1]==':' ){
111646: i++;
111647: #endif
111648: }else{
111649: break;
111650: }
111651: }
111652: if( n==0 ) *tokenType = TK_ILLEGAL;
111653: return i;
111654: }
111655: #ifndef SQLITE_OMIT_BLOB_LITERAL
111656: case 'x': case 'X': {
111657: testcase( z[0]=='x' ); testcase( z[0]=='X' );
111658: if( z[1]=='\'' ){
111659: *tokenType = TK_BLOB;
111660: for(i=2; sqlite3Isxdigit(z[i]); i++){}
111661: if( z[i]!='\'' || i%2 ){
111662: *tokenType = TK_ILLEGAL;
111663: while( z[i] && z[i]!='\'' ){ i++; }
111664: }
111665: if( z[i] ) i++;
111666: return i;
111667: }
111668: /* Otherwise fall through to the next case */
111669: }
111670: #endif
111671: default: {
111672: if( !IdChar(*z) ){
111673: break;
111674: }
111675: for(i=1; IdChar(z[i]); i++){}
111676: *tokenType = keywordCode((char*)z, i);
111677: return i;
111678: }
111679: }
111680: *tokenType = TK_ILLEGAL;
111681: return 1;
111682: }
111683:
111684: /*
111685: ** Run the parser on the given SQL string. The parser structure is
111686: ** passed in. An SQLITE_ status code is returned. If an error occurs
111687: ** then an and attempt is made to write an error message into
111688: ** memory obtained from sqlite3_malloc() and to make *pzErrMsg point to that
111689: ** error message.
111690: */
111691: SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
111692: int nErr = 0; /* Number of errors encountered */
111693: int i; /* Loop counter */
111694: void *pEngine; /* The LEMON-generated LALR(1) parser */
111695: int tokenType; /* type of the next token */
111696: int lastTokenParsed = -1; /* type of the previous token */
111697: u8 enableLookaside; /* Saved value of db->lookaside.bEnabled */
111698: sqlite3 *db = pParse->db; /* The database connection */
111699: int mxSqlLen; /* Max length of an SQL string */
111700:
111701:
111702: mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
111703: if( db->activeVdbeCnt==0 ){
111704: db->u1.isInterrupted = 0;
111705: }
111706: pParse->rc = SQLITE_OK;
111707: pParse->zTail = zSql;
111708: i = 0;
111709: assert( pzErrMsg!=0 );
111710: pEngine = sqlite3ParserAlloc((void*(*)(size_t))sqlite3Malloc);
111711: if( pEngine==0 ){
111712: db->mallocFailed = 1;
111713: return SQLITE_NOMEM;
111714: }
111715: assert( pParse->pNewTable==0 );
111716: assert( pParse->pNewTrigger==0 );
111717: assert( pParse->nVar==0 );
111718: assert( pParse->nzVar==0 );
111719: assert( pParse->azVar==0 );
111720: enableLookaside = db->lookaside.bEnabled;
111721: if( db->lookaside.pStart ) db->lookaside.bEnabled = 1;
111722: while( !db->mallocFailed && zSql[i]!=0 ){
111723: assert( i>=0 );
111724: pParse->sLastToken.z = &zSql[i];
111725: pParse->sLastToken.n = sqlite3GetToken((unsigned char*)&zSql[i],&tokenType);
111726: i += pParse->sLastToken.n;
111727: if( i>mxSqlLen ){
111728: pParse->rc = SQLITE_TOOBIG;
111729: break;
111730: }
111731: switch( tokenType ){
111732: case TK_SPACE: {
111733: if( db->u1.isInterrupted ){
111734: sqlite3ErrorMsg(pParse, "interrupt");
111735: pParse->rc = SQLITE_INTERRUPT;
111736: goto abort_parse;
111737: }
111738: break;
111739: }
111740: case TK_ILLEGAL: {
111741: sqlite3DbFree(db, *pzErrMsg);
111742: *pzErrMsg = sqlite3MPrintf(db, "unrecognized token: \"%T\"",
111743: &pParse->sLastToken);
111744: nErr++;
111745: goto abort_parse;
111746: }
111747: case TK_SEMI: {
111748: pParse->zTail = &zSql[i];
111749: /* Fall thru into the default case */
111750: }
111751: default: {
111752: sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
111753: lastTokenParsed = tokenType;
111754: if( pParse->rc!=SQLITE_OK ){
111755: goto abort_parse;
111756: }
111757: break;
111758: }
111759: }
111760: }
111761: abort_parse:
111762: if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){
111763: if( lastTokenParsed!=TK_SEMI ){
111764: sqlite3Parser(pEngine, TK_SEMI, pParse->sLastToken, pParse);
111765: pParse->zTail = &zSql[i];
111766: }
111767: sqlite3Parser(pEngine, 0, pParse->sLastToken, pParse);
111768: }
111769: #ifdef YYTRACKMAXSTACKDEPTH
111770: sqlite3StatusSet(SQLITE_STATUS_PARSER_STACK,
111771: sqlite3ParserStackPeak(pEngine)
111772: );
111773: #endif /* YYDEBUG */
111774: sqlite3ParserFree(pEngine, sqlite3_free);
111775: db->lookaside.bEnabled = enableLookaside;
111776: if( db->mallocFailed ){
111777: pParse->rc = SQLITE_NOMEM;
111778: }
111779: if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
111780: sqlite3SetString(&pParse->zErrMsg, db, "%s", sqlite3ErrStr(pParse->rc));
111781: }
111782: assert( pzErrMsg!=0 );
111783: if( pParse->zErrMsg ){
111784: *pzErrMsg = pParse->zErrMsg;
111785: sqlite3_log(pParse->rc, "%s", *pzErrMsg);
111786: pParse->zErrMsg = 0;
111787: nErr++;
111788: }
111789: if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
111790: sqlite3VdbeDelete(pParse->pVdbe);
111791: pParse->pVdbe = 0;
111792: }
111793: #ifndef SQLITE_OMIT_SHARED_CACHE
111794: if( pParse->nested==0 ){
111795: sqlite3DbFree(db, pParse->aTableLock);
111796: pParse->aTableLock = 0;
111797: pParse->nTableLock = 0;
111798: }
111799: #endif
111800: #ifndef SQLITE_OMIT_VIRTUALTABLE
111801: sqlite3_free(pParse->apVtabLock);
111802: #endif
111803:
111804: if( !IN_DECLARE_VTAB ){
111805: /* If the pParse->declareVtab flag is set, do not delete any table
111806: ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
111807: ** will take responsibility for freeing the Table structure.
111808: */
111809: sqlite3DeleteTable(db, pParse->pNewTable);
111810: }
111811:
111812: sqlite3DeleteTrigger(db, pParse->pNewTrigger);
111813: for(i=pParse->nzVar-1; i>=0; i--) sqlite3DbFree(db, pParse->azVar[i]);
111814: sqlite3DbFree(db, pParse->azVar);
111815: sqlite3DbFree(db, pParse->aAlias);
111816: while( pParse->pAinc ){
111817: AutoincInfo *p = pParse->pAinc;
111818: pParse->pAinc = p->pNext;
111819: sqlite3DbFree(db, p);
111820: }
111821: while( pParse->pZombieTab ){
111822: Table *p = pParse->pZombieTab;
111823: pParse->pZombieTab = p->pNextZombie;
111824: sqlite3DeleteTable(db, p);
111825: }
111826: if( nErr>0 && pParse->rc==SQLITE_OK ){
111827: pParse->rc = SQLITE_ERROR;
111828: }
111829: return nErr;
111830: }
111831:
111832: /************** End of tokenize.c ********************************************/
111833: /************** Begin file complete.c ****************************************/
111834: /*
111835: ** 2001 September 15
111836: **
111837: ** The author disclaims copyright to this source code. In place of
111838: ** a legal notice, here is a blessing:
111839: **
111840: ** May you do good and not evil.
111841: ** May you find forgiveness for yourself and forgive others.
111842: ** May you share freely, never taking more than you give.
111843: **
111844: *************************************************************************
111845: ** An tokenizer for SQL
111846: **
111847: ** This file contains C code that implements the sqlite3_complete() API.
111848: ** This code used to be part of the tokenizer.c source file. But by
111849: ** separating it out, the code will be automatically omitted from
111850: ** static links that do not use it.
111851: */
111852: #ifndef SQLITE_OMIT_COMPLETE
111853:
111854: /*
111855: ** This is defined in tokenize.c. We just have to import the definition.
111856: */
111857: #ifndef SQLITE_AMALGAMATION
111858: #ifdef SQLITE_ASCII
111859: #define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)
111860: #endif
111861: #ifdef SQLITE_EBCDIC
111862: SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[];
111863: #define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
111864: #endif
111865: #endif /* SQLITE_AMALGAMATION */
111866:
111867:
111868: /*
111869: ** Token types used by the sqlite3_complete() routine. See the header
111870: ** comments on that procedure for additional information.
111871: */
111872: #define tkSEMI 0
111873: #define tkWS 1
111874: #define tkOTHER 2
111875: #ifndef SQLITE_OMIT_TRIGGER
111876: #define tkEXPLAIN 3
111877: #define tkCREATE 4
111878: #define tkTEMP 5
111879: #define tkTRIGGER 6
111880: #define tkEND 7
111881: #endif
111882:
111883: /*
111884: ** Return TRUE if the given SQL string ends in a semicolon.
111885: **
111886: ** Special handling is require for CREATE TRIGGER statements.
111887: ** Whenever the CREATE TRIGGER keywords are seen, the statement
111888: ** must end with ";END;".
111889: **
111890: ** This implementation uses a state machine with 8 states:
111891: **
111892: ** (0) INVALID We have not yet seen a non-whitespace character.
111893: **
111894: ** (1) START At the beginning or end of an SQL statement. This routine
111895: ** returns 1 if it ends in the START state and 0 if it ends
111896: ** in any other state.
111897: **
111898: ** (2) NORMAL We are in the middle of statement which ends with a single
111899: ** semicolon.
111900: **
111901: ** (3) EXPLAIN The keyword EXPLAIN has been seen at the beginning of
111902: ** a statement.
111903: **
111904: ** (4) CREATE The keyword CREATE has been seen at the beginning of a
111905: ** statement, possibly preceeded by EXPLAIN and/or followed by
111906: ** TEMP or TEMPORARY
111907: **
111908: ** (5) TRIGGER We are in the middle of a trigger definition that must be
111909: ** ended by a semicolon, the keyword END, and another semicolon.
111910: **
111911: ** (6) SEMI We've seen the first semicolon in the ";END;" that occurs at
111912: ** the end of a trigger definition.
111913: **
111914: ** (7) END We've seen the ";END" of the ";END;" that occurs at the end
111915: ** of a trigger difinition.
111916: **
111917: ** Transitions between states above are determined by tokens extracted
111918: ** from the input. The following tokens are significant:
111919: **
111920: ** (0) tkSEMI A semicolon.
111921: ** (1) tkWS Whitespace.
111922: ** (2) tkOTHER Any other SQL token.
111923: ** (3) tkEXPLAIN The "explain" keyword.
111924: ** (4) tkCREATE The "create" keyword.
111925: ** (5) tkTEMP The "temp" or "temporary" keyword.
111926: ** (6) tkTRIGGER The "trigger" keyword.
111927: ** (7) tkEND The "end" keyword.
111928: **
111929: ** Whitespace never causes a state transition and is always ignored.
111930: ** This means that a SQL string of all whitespace is invalid.
111931: **
111932: ** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
111933: ** to recognize the end of a trigger can be omitted. All we have to do
111934: ** is look for a semicolon that is not part of an string or comment.
111935: */
111936: SQLITE_API int sqlite3_complete(const char *zSql){
111937: u8 state = 0; /* Current state, using numbers defined in header comment */
111938: u8 token; /* Value of the next token */
111939:
111940: #ifndef SQLITE_OMIT_TRIGGER
111941: /* A complex statement machine used to detect the end of a CREATE TRIGGER
111942: ** statement. This is the normal case.
111943: */
111944: static const u8 trans[8][8] = {
111945: /* Token: */
111946: /* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */
111947: /* 0 INVALID: */ { 1, 0, 2, 3, 4, 2, 2, 2, },
111948: /* 1 START: */ { 1, 1, 2, 3, 4, 2, 2, 2, },
111949: /* 2 NORMAL: */ { 1, 2, 2, 2, 2, 2, 2, 2, },
111950: /* 3 EXPLAIN: */ { 1, 3, 3, 2, 4, 2, 2, 2, },
111951: /* 4 CREATE: */ { 1, 4, 2, 2, 2, 4, 5, 2, },
111952: /* 5 TRIGGER: */ { 6, 5, 5, 5, 5, 5, 5, 5, },
111953: /* 6 SEMI: */ { 6, 6, 5, 5, 5, 5, 5, 7, },
111954: /* 7 END: */ { 1, 7, 5, 5, 5, 5, 5, 5, },
111955: };
111956: #else
111957: /* If triggers are not supported by this compile then the statement machine
111958: ** used to detect the end of a statement is much simplier
111959: */
111960: static const u8 trans[3][3] = {
111961: /* Token: */
111962: /* State: ** SEMI WS OTHER */
111963: /* 0 INVALID: */ { 1, 0, 2, },
111964: /* 1 START: */ { 1, 1, 2, },
111965: /* 2 NORMAL: */ { 1, 2, 2, },
111966: };
111967: #endif /* SQLITE_OMIT_TRIGGER */
111968:
111969: while( *zSql ){
111970: switch( *zSql ){
111971: case ';': { /* A semicolon */
111972: token = tkSEMI;
111973: break;
111974: }
111975: case ' ':
111976: case '\r':
111977: case '\t':
111978: case '\n':
111979: case '\f': { /* White space is ignored */
111980: token = tkWS;
111981: break;
111982: }
111983: case '/': { /* C-style comments */
111984: if( zSql[1]!='*' ){
111985: token = tkOTHER;
111986: break;
111987: }
111988: zSql += 2;
111989: while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
111990: if( zSql[0]==0 ) return 0;
111991: zSql++;
111992: token = tkWS;
111993: break;
111994: }
111995: case '-': { /* SQL-style comments from "--" to end of line */
111996: if( zSql[1]!='-' ){
111997: token = tkOTHER;
111998: break;
111999: }
112000: while( *zSql && *zSql!='\n' ){ zSql++; }
112001: if( *zSql==0 ) return state==1;
112002: token = tkWS;
112003: break;
112004: }
112005: case '[': { /* Microsoft-style identifiers in [...] */
112006: zSql++;
112007: while( *zSql && *zSql!=']' ){ zSql++; }
112008: if( *zSql==0 ) return 0;
112009: token = tkOTHER;
112010: break;
112011: }
112012: case '`': /* Grave-accent quoted symbols used by MySQL */
112013: case '"': /* single- and double-quoted strings */
112014: case '\'': {
112015: int c = *zSql;
112016: zSql++;
112017: while( *zSql && *zSql!=c ){ zSql++; }
112018: if( *zSql==0 ) return 0;
112019: token = tkOTHER;
112020: break;
112021: }
112022: default: {
112023: #ifdef SQLITE_EBCDIC
112024: unsigned char c;
112025: #endif
112026: if( IdChar((u8)*zSql) ){
112027: /* Keywords and unquoted identifiers */
112028: int nId;
112029: for(nId=1; IdChar(zSql[nId]); nId++){}
112030: #ifdef SQLITE_OMIT_TRIGGER
112031: token = tkOTHER;
112032: #else
112033: switch( *zSql ){
112034: case 'c': case 'C': {
112035: if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){
112036: token = tkCREATE;
112037: }else{
112038: token = tkOTHER;
112039: }
112040: break;
112041: }
112042: case 't': case 'T': {
112043: if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){
112044: token = tkTRIGGER;
112045: }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){
112046: token = tkTEMP;
112047: }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){
112048: token = tkTEMP;
112049: }else{
112050: token = tkOTHER;
112051: }
112052: break;
112053: }
112054: case 'e': case 'E': {
112055: if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){
112056: token = tkEND;
112057: }else
112058: #ifndef SQLITE_OMIT_EXPLAIN
112059: if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){
112060: token = tkEXPLAIN;
112061: }else
112062: #endif
112063: {
112064: token = tkOTHER;
112065: }
112066: break;
112067: }
112068: default: {
112069: token = tkOTHER;
112070: break;
112071: }
112072: }
112073: #endif /* SQLITE_OMIT_TRIGGER */
112074: zSql += nId-1;
112075: }else{
112076: /* Operators and special symbols */
112077: token = tkOTHER;
112078: }
112079: break;
112080: }
112081: }
112082: state = trans[state][token];
112083: zSql++;
112084: }
112085: return state==1;
112086: }
112087:
112088: #ifndef SQLITE_OMIT_UTF16
112089: /*
112090: ** This routine is the same as the sqlite3_complete() routine described
112091: ** above, except that the parameter is required to be UTF-16 encoded, not
112092: ** UTF-8.
112093: */
112094: SQLITE_API int sqlite3_complete16(const void *zSql){
112095: sqlite3_value *pVal;
112096: char const *zSql8;
112097: int rc = SQLITE_NOMEM;
112098:
112099: #ifndef SQLITE_OMIT_AUTOINIT
112100: rc = sqlite3_initialize();
112101: if( rc ) return rc;
112102: #endif
112103: pVal = sqlite3ValueNew(0);
112104: sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
112105: zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
112106: if( zSql8 ){
112107: rc = sqlite3_complete(zSql8);
112108: }else{
112109: rc = SQLITE_NOMEM;
112110: }
112111: sqlite3ValueFree(pVal);
112112: return sqlite3ApiExit(0, rc);
112113: }
112114: #endif /* SQLITE_OMIT_UTF16 */
112115: #endif /* SQLITE_OMIT_COMPLETE */
112116:
112117: /************** End of complete.c ********************************************/
112118: /************** Begin file main.c ********************************************/
112119: /*
112120: ** 2001 September 15
112121: **
112122: ** The author disclaims copyright to this source code. In place of
112123: ** a legal notice, here is a blessing:
112124: **
112125: ** May you do good and not evil.
112126: ** May you find forgiveness for yourself and forgive others.
112127: ** May you share freely, never taking more than you give.
112128: **
112129: *************************************************************************
112130: ** Main file for the SQLite library. The routines in this file
112131: ** implement the programmer interface to the library. Routines in
112132: ** other files are for internal use by SQLite and should not be
112133: ** accessed by users of the library.
112134: */
112135:
112136: #ifdef SQLITE_ENABLE_FTS3
112137: /************** Include fts3.h in the middle of main.c ***********************/
112138: /************** Begin file fts3.h ********************************************/
112139: /*
112140: ** 2006 Oct 10
112141: **
112142: ** The author disclaims copyright to this source code. In place of
112143: ** a legal notice, here is a blessing:
112144: **
112145: ** May you do good and not evil.
112146: ** May you find forgiveness for yourself and forgive others.
112147: ** May you share freely, never taking more than you give.
112148: **
112149: ******************************************************************************
112150: **
112151: ** This header file is used by programs that want to link against the
112152: ** FTS3 library. All it does is declare the sqlite3Fts3Init() interface.
112153: */
112154:
112155: #if 0
112156: extern "C" {
112157: #endif /* __cplusplus */
112158:
112159: SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db);
112160:
112161: #if 0
112162: } /* extern "C" */
112163: #endif /* __cplusplus */
112164:
112165: /************** End of fts3.h ************************************************/
112166: /************** Continuing where we left off in main.c ***********************/
112167: #endif
112168: #ifdef SQLITE_ENABLE_RTREE
112169: /************** Include rtree.h in the middle of main.c **********************/
112170: /************** Begin file rtree.h *******************************************/
112171: /*
112172: ** 2008 May 26
112173: **
112174: ** The author disclaims copyright to this source code. In place of
112175: ** a legal notice, here is a blessing:
112176: **
112177: ** May you do good and not evil.
112178: ** May you find forgiveness for yourself and forgive others.
112179: ** May you share freely, never taking more than you give.
112180: **
112181: ******************************************************************************
112182: **
112183: ** This header file is used by programs that want to link against the
112184: ** RTREE library. All it does is declare the sqlite3RtreeInit() interface.
112185: */
112186:
112187: #if 0
112188: extern "C" {
112189: #endif /* __cplusplus */
112190:
112191: SQLITE_PRIVATE int sqlite3RtreeInit(sqlite3 *db);
112192:
112193: #if 0
112194: } /* extern "C" */
112195: #endif /* __cplusplus */
112196:
112197: /************** End of rtree.h ***********************************************/
112198: /************** Continuing where we left off in main.c ***********************/
112199: #endif
112200: #ifdef SQLITE_ENABLE_ICU
112201: /************** Include sqliteicu.h in the middle of main.c ******************/
112202: /************** Begin file sqliteicu.h ***************************************/
112203: /*
112204: ** 2008 May 26
112205: **
112206: ** The author disclaims copyright to this source code. In place of
112207: ** a legal notice, here is a blessing:
112208: **
112209: ** May you do good and not evil.
112210: ** May you find forgiveness for yourself and forgive others.
112211: ** May you share freely, never taking more than you give.
112212: **
112213: ******************************************************************************
112214: **
112215: ** This header file is used by programs that want to link against the
112216: ** ICU extension. All it does is declare the sqlite3IcuInit() interface.
112217: */
112218:
112219: #if 0
112220: extern "C" {
112221: #endif /* __cplusplus */
112222:
112223: SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db);
112224:
112225: #if 0
112226: } /* extern "C" */
112227: #endif /* __cplusplus */
112228:
112229:
112230: /************** End of sqliteicu.h *******************************************/
112231: /************** Continuing where we left off in main.c ***********************/
112232: #endif
112233:
112234: #ifndef SQLITE_AMALGAMATION
112235: /* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant
112236: ** contains the text of SQLITE_VERSION macro.
112237: */
112238: SQLITE_API const char sqlite3_version[] = SQLITE_VERSION;
112239: #endif
112240:
112241: /* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns
112242: ** a pointer to the to the sqlite3_version[] string constant.
112243: */
112244: SQLITE_API const char *sqlite3_libversion(void){ return sqlite3_version; }
112245:
112246: /* IMPLEMENTATION-OF: R-63124-39300 The sqlite3_sourceid() function returns a
112247: ** pointer to a string constant whose value is the same as the
112248: ** SQLITE_SOURCE_ID C preprocessor macro.
112249: */
112250: SQLITE_API const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
112251:
112252: /* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function
112253: ** returns an integer equal to SQLITE_VERSION_NUMBER.
112254: */
112255: SQLITE_API int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
112256:
112257: /* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns
112258: ** zero if and only if SQLite was compiled with mutexing code omitted due to
112259: ** the SQLITE_THREADSAFE compile-time option being set to 0.
112260: */
112261: SQLITE_API int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
112262:
112263: #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
112264: /*
112265: ** If the following function pointer is not NULL and if
112266: ** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
112267: ** I/O active are written using this function. These messages
112268: ** are intended for debugging activity only.
112269: */
112270: SQLITE_PRIVATE void (*sqlite3IoTrace)(const char*, ...) = 0;
112271: #endif
112272:
112273: /*
112274: ** If the following global variable points to a string which is the
112275: ** name of a directory, then that directory will be used to store
112276: ** temporary files.
112277: **
112278: ** See also the "PRAGMA temp_store_directory" SQL command.
112279: */
112280: SQLITE_API char *sqlite3_temp_directory = 0;
112281:
112282: /*
112283: ** Initialize SQLite.
112284: **
112285: ** This routine must be called to initialize the memory allocation,
112286: ** VFS, and mutex subsystems prior to doing any serious work with
112287: ** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
112288: ** this routine will be called automatically by key routines such as
112289: ** sqlite3_open().
112290: **
112291: ** This routine is a no-op except on its very first call for the process,
112292: ** or for the first call after a call to sqlite3_shutdown.
112293: **
112294: ** The first thread to call this routine runs the initialization to
112295: ** completion. If subsequent threads call this routine before the first
112296: ** thread has finished the initialization process, then the subsequent
112297: ** threads must block until the first thread finishes with the initialization.
112298: **
112299: ** The first thread might call this routine recursively. Recursive
112300: ** calls to this routine should not block, of course. Otherwise the
112301: ** initialization process would never complete.
112302: **
112303: ** Let X be the first thread to enter this routine. Let Y be some other
112304: ** thread. Then while the initial invocation of this routine by X is
112305: ** incomplete, it is required that:
112306: **
112307: ** * Calls to this routine from Y must block until the outer-most
112308: ** call by X completes.
112309: **
112310: ** * Recursive calls to this routine from thread X return immediately
112311: ** without blocking.
112312: */
112313: SQLITE_API int sqlite3_initialize(void){
112314: MUTEX_LOGIC( sqlite3_mutex *pMaster; ) /* The main static mutex */
112315: int rc; /* Result code */
112316:
112317: #ifdef SQLITE_OMIT_WSD
112318: rc = sqlite3_wsd_init(4096, 24);
112319: if( rc!=SQLITE_OK ){
112320: return rc;
112321: }
112322: #endif
112323:
112324: /* If SQLite is already completely initialized, then this call
112325: ** to sqlite3_initialize() should be a no-op. But the initialization
112326: ** must be complete. So isInit must not be set until the very end
112327: ** of this routine.
112328: */
112329: if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;
112330:
112331: /* Make sure the mutex subsystem is initialized. If unable to
112332: ** initialize the mutex subsystem, return early with the error.
112333: ** If the system is so sick that we are unable to allocate a mutex,
112334: ** there is not much SQLite is going to be able to do.
112335: **
112336: ** The mutex subsystem must take care of serializing its own
112337: ** initialization.
112338: */
112339: rc = sqlite3MutexInit();
112340: if( rc ) return rc;
112341:
112342: /* Initialize the malloc() system and the recursive pInitMutex mutex.
112343: ** This operation is protected by the STATIC_MASTER mutex. Note that
112344: ** MutexAlloc() is called for a static mutex prior to initializing the
112345: ** malloc subsystem - this implies that the allocation of a static
112346: ** mutex must not require support from the malloc subsystem.
112347: */
112348: MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
112349: sqlite3_mutex_enter(pMaster);
112350: sqlite3GlobalConfig.isMutexInit = 1;
112351: if( !sqlite3GlobalConfig.isMallocInit ){
112352: rc = sqlite3MallocInit();
112353: }
112354: if( rc==SQLITE_OK ){
112355: sqlite3GlobalConfig.isMallocInit = 1;
112356: if( !sqlite3GlobalConfig.pInitMutex ){
112357: sqlite3GlobalConfig.pInitMutex =
112358: sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
112359: if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){
112360: rc = SQLITE_NOMEM;
112361: }
112362: }
112363: }
112364: if( rc==SQLITE_OK ){
112365: sqlite3GlobalConfig.nRefInitMutex++;
112366: }
112367: sqlite3_mutex_leave(pMaster);
112368:
112369: /* If rc is not SQLITE_OK at this point, then either the malloc
112370: ** subsystem could not be initialized or the system failed to allocate
112371: ** the pInitMutex mutex. Return an error in either case. */
112372: if( rc!=SQLITE_OK ){
112373: return rc;
112374: }
112375:
112376: /* Do the rest of the initialization under the recursive mutex so
112377: ** that we will be able to handle recursive calls into
112378: ** sqlite3_initialize(). The recursive calls normally come through
112379: ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
112380: ** recursive calls might also be possible.
112381: **
112382: ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
112383: ** to the xInit method, so the xInit method need not be threadsafe.
112384: **
112385: ** The following mutex is what serializes access to the appdef pcache xInit
112386: ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the
112387: ** call to sqlite3PcacheInitialize().
112388: */
112389: sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);
112390: if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){
112391: FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
112392: sqlite3GlobalConfig.inProgress = 1;
112393: memset(pHash, 0, sizeof(sqlite3GlobalFunctions));
112394: sqlite3RegisterGlobalFunctions();
112395: if( sqlite3GlobalConfig.isPCacheInit==0 ){
112396: rc = sqlite3PcacheInitialize();
112397: }
112398: if( rc==SQLITE_OK ){
112399: sqlite3GlobalConfig.isPCacheInit = 1;
112400: rc = sqlite3OsInit();
112401: }
112402: if( rc==SQLITE_OK ){
112403: sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,
112404: sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
112405: sqlite3GlobalConfig.isInit = 1;
112406: }
112407: sqlite3GlobalConfig.inProgress = 0;
112408: }
112409: sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);
112410:
112411: /* Go back under the static mutex and clean up the recursive
112412: ** mutex to prevent a resource leak.
112413: */
112414: sqlite3_mutex_enter(pMaster);
112415: sqlite3GlobalConfig.nRefInitMutex--;
112416: if( sqlite3GlobalConfig.nRefInitMutex<=0 ){
112417: assert( sqlite3GlobalConfig.nRefInitMutex==0 );
112418: sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);
112419: sqlite3GlobalConfig.pInitMutex = 0;
112420: }
112421: sqlite3_mutex_leave(pMaster);
112422:
112423: /* The following is just a sanity check to make sure SQLite has
112424: ** been compiled correctly. It is important to run this code, but
112425: ** we don't want to run it too often and soak up CPU cycles for no
112426: ** reason. So we run it once during initialization.
112427: */
112428: #ifndef NDEBUG
112429: #ifndef SQLITE_OMIT_FLOATING_POINT
112430: /* This section of code's only "output" is via assert() statements. */
112431: if ( rc==SQLITE_OK ){
112432: u64 x = (((u64)1)<<63)-1;
112433: double y;
112434: assert(sizeof(x)==8);
112435: assert(sizeof(x)==sizeof(y));
112436: memcpy(&y, &x, 8);
112437: assert( sqlite3IsNaN(y) );
112438: }
112439: #endif
112440: #endif
112441:
112442: /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT
112443: ** compile-time option.
112444: */
112445: #ifdef SQLITE_EXTRA_INIT
112446: if( rc==SQLITE_OK && sqlite3GlobalConfig.isInit ){
112447: int SQLITE_EXTRA_INIT(const char*);
112448: rc = SQLITE_EXTRA_INIT(0);
112449: }
112450: #endif
112451:
112452: return rc;
112453: }
112454:
112455: /*
112456: ** Undo the effects of sqlite3_initialize(). Must not be called while
112457: ** there are outstanding database connections or memory allocations or
112458: ** while any part of SQLite is otherwise in use in any thread. This
112459: ** routine is not threadsafe. But it is safe to invoke this routine
112460: ** on when SQLite is already shut down. If SQLite is already shut down
112461: ** when this routine is invoked, then this routine is a harmless no-op.
112462: */
112463: SQLITE_API int sqlite3_shutdown(void){
112464: if( sqlite3GlobalConfig.isInit ){
112465: #ifdef SQLITE_EXTRA_SHUTDOWN
112466: void SQLITE_EXTRA_SHUTDOWN(void);
112467: SQLITE_EXTRA_SHUTDOWN();
112468: #endif
112469: sqlite3_os_end();
112470: sqlite3_reset_auto_extension();
112471: sqlite3GlobalConfig.isInit = 0;
112472: }
112473: if( sqlite3GlobalConfig.isPCacheInit ){
112474: sqlite3PcacheShutdown();
112475: sqlite3GlobalConfig.isPCacheInit = 0;
112476: }
112477: if( sqlite3GlobalConfig.isMallocInit ){
112478: sqlite3MallocEnd();
112479: sqlite3GlobalConfig.isMallocInit = 0;
112480: }
112481: if( sqlite3GlobalConfig.isMutexInit ){
112482: sqlite3MutexEnd();
112483: sqlite3GlobalConfig.isMutexInit = 0;
112484: }
112485:
112486: return SQLITE_OK;
112487: }
112488:
112489: /*
112490: ** This API allows applications to modify the global configuration of
112491: ** the SQLite library at run-time.
112492: **
112493: ** This routine should only be called when there are no outstanding
112494: ** database connections or memory allocations. This routine is not
112495: ** threadsafe. Failure to heed these warnings can lead to unpredictable
112496: ** behavior.
112497: */
112498: SQLITE_API int sqlite3_config(int op, ...){
112499: va_list ap;
112500: int rc = SQLITE_OK;
112501:
112502: /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
112503: ** the SQLite library is in use. */
112504: if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT;
112505:
112506: va_start(ap, op);
112507: switch( op ){
112508:
112509: /* Mutex configuration options are only available in a threadsafe
112510: ** compile.
112511: */
112512: #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0
112513: case SQLITE_CONFIG_SINGLETHREAD: {
112514: /* Disable all mutexing */
112515: sqlite3GlobalConfig.bCoreMutex = 0;
112516: sqlite3GlobalConfig.bFullMutex = 0;
112517: break;
112518: }
112519: case SQLITE_CONFIG_MULTITHREAD: {
112520: /* Disable mutexing of database connections */
112521: /* Enable mutexing of core data structures */
112522: sqlite3GlobalConfig.bCoreMutex = 1;
112523: sqlite3GlobalConfig.bFullMutex = 0;
112524: break;
112525: }
112526: case SQLITE_CONFIG_SERIALIZED: {
112527: /* Enable all mutexing */
112528: sqlite3GlobalConfig.bCoreMutex = 1;
112529: sqlite3GlobalConfig.bFullMutex = 1;
112530: break;
112531: }
112532: case SQLITE_CONFIG_MUTEX: {
112533: /* Specify an alternative mutex implementation */
112534: sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
112535: break;
112536: }
112537: case SQLITE_CONFIG_GETMUTEX: {
112538: /* Retrieve the current mutex implementation */
112539: *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
112540: break;
112541: }
112542: #endif
112543:
112544:
112545: case SQLITE_CONFIG_MALLOC: {
112546: /* Specify an alternative malloc implementation */
112547: sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);
112548: break;
112549: }
112550: case SQLITE_CONFIG_GETMALLOC: {
112551: /* Retrieve the current malloc() implementation */
112552: if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
112553: *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;
112554: break;
112555: }
112556: case SQLITE_CONFIG_MEMSTATUS: {
112557: /* Enable or disable the malloc status collection */
112558: sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
112559: break;
112560: }
112561: case SQLITE_CONFIG_SCRATCH: {
112562: /* Designate a buffer for scratch memory space */
112563: sqlite3GlobalConfig.pScratch = va_arg(ap, void*);
112564: sqlite3GlobalConfig.szScratch = va_arg(ap, int);
112565: sqlite3GlobalConfig.nScratch = va_arg(ap, int);
112566: break;
112567: }
112568: case SQLITE_CONFIG_PAGECACHE: {
112569: /* Designate a buffer for page cache memory space */
112570: sqlite3GlobalConfig.pPage = va_arg(ap, void*);
112571: sqlite3GlobalConfig.szPage = va_arg(ap, int);
112572: sqlite3GlobalConfig.nPage = va_arg(ap, int);
112573: break;
112574: }
112575:
112576: case SQLITE_CONFIG_PCACHE: {
112577: /* no-op */
112578: break;
112579: }
112580: case SQLITE_CONFIG_GETPCACHE: {
112581: /* now an error */
112582: rc = SQLITE_ERROR;
112583: break;
112584: }
112585:
112586: case SQLITE_CONFIG_PCACHE2: {
112587: /* Specify an alternative page cache implementation */
112588: sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);
112589: break;
112590: }
112591: case SQLITE_CONFIG_GETPCACHE2: {
112592: if( sqlite3GlobalConfig.pcache2.xInit==0 ){
112593: sqlite3PCacheSetDefault();
112594: }
112595: *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;
112596: break;
112597: }
112598:
112599: #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
112600: case SQLITE_CONFIG_HEAP: {
112601: /* Designate a buffer for heap memory space */
112602: sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
112603: sqlite3GlobalConfig.nHeap = va_arg(ap, int);
112604: sqlite3GlobalConfig.mnReq = va_arg(ap, int);
112605:
112606: if( sqlite3GlobalConfig.mnReq<1 ){
112607: sqlite3GlobalConfig.mnReq = 1;
112608: }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){
112609: /* cap min request size at 2^12 */
112610: sqlite3GlobalConfig.mnReq = (1<<12);
112611: }
112612:
112613: if( sqlite3GlobalConfig.pHeap==0 ){
112614: /* If the heap pointer is NULL, then restore the malloc implementation
112615: ** back to NULL pointers too. This will cause the malloc to go
112616: ** back to its default implementation when sqlite3_initialize() is
112617: ** run.
112618: */
112619: memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
112620: }else{
112621: /* The heap pointer is not NULL, then install one of the
112622: ** mem5.c/mem3.c methods. If neither ENABLE_MEMSYS3 nor
112623: ** ENABLE_MEMSYS5 is defined, return an error.
112624: */
112625: #ifdef SQLITE_ENABLE_MEMSYS3
112626: sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
112627: #endif
112628: #ifdef SQLITE_ENABLE_MEMSYS5
112629: sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
112630: #endif
112631: }
112632: break;
112633: }
112634: #endif
112635:
112636: case SQLITE_CONFIG_LOOKASIDE: {
112637: sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
112638: sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
112639: break;
112640: }
112641:
112642: /* Record a pointer to the logger funcction and its first argument.
112643: ** The default is NULL. Logging is disabled if the function pointer is
112644: ** NULL.
112645: */
112646: case SQLITE_CONFIG_LOG: {
112647: /* MSVC is picky about pulling func ptrs from va lists.
112648: ** http://support.microsoft.com/kb/47961
112649: ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
112650: */
112651: typedef void(*LOGFUNC_t)(void*,int,const char*);
112652: sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);
112653: sqlite3GlobalConfig.pLogArg = va_arg(ap, void*);
112654: break;
112655: }
112656:
112657: case SQLITE_CONFIG_URI: {
112658: sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);
112659: break;
112660: }
112661:
112662: default: {
112663: rc = SQLITE_ERROR;
112664: break;
112665: }
112666: }
112667: va_end(ap);
112668: return rc;
112669: }
112670:
112671: /*
112672: ** Set up the lookaside buffers for a database connection.
112673: ** Return SQLITE_OK on success.
112674: ** If lookaside is already active, return SQLITE_BUSY.
112675: **
112676: ** The sz parameter is the number of bytes in each lookaside slot.
112677: ** The cnt parameter is the number of slots. If pStart is NULL the
112678: ** space for the lookaside memory is obtained from sqlite3_malloc().
112679: ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
112680: ** the lookaside memory.
112681: */
112682: static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
112683: void *pStart;
112684: if( db->lookaside.nOut ){
112685: return SQLITE_BUSY;
112686: }
112687: /* Free any existing lookaside buffer for this handle before
112688: ** allocating a new one so we don't have to have space for
112689: ** both at the same time.
112690: */
112691: if( db->lookaside.bMalloced ){
112692: sqlite3_free(db->lookaside.pStart);
112693: }
112694: /* The size of a lookaside slot after ROUNDDOWN8 needs to be larger
112695: ** than a pointer to be useful.
112696: */
112697: sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */
112698: if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0;
112699: if( cnt<0 ) cnt = 0;
112700: if( sz==0 || cnt==0 ){
112701: sz = 0;
112702: pStart = 0;
112703: }else if( pBuf==0 ){
112704: sqlite3BeginBenignMalloc();
112705: pStart = sqlite3Malloc( sz*cnt ); /* IMP: R-61949-35727 */
112706: sqlite3EndBenignMalloc();
112707: if( pStart ) cnt = sqlite3MallocSize(pStart)/sz;
112708: }else{
112709: pStart = pBuf;
112710: }
112711: db->lookaside.pStart = pStart;
112712: db->lookaside.pFree = 0;
112713: db->lookaside.sz = (u16)sz;
112714: if( pStart ){
112715: int i;
112716: LookasideSlot *p;
112717: assert( sz > (int)sizeof(LookasideSlot*) );
112718: p = (LookasideSlot*)pStart;
112719: for(i=cnt-1; i>=0; i--){
112720: p->pNext = db->lookaside.pFree;
112721: db->lookaside.pFree = p;
112722: p = (LookasideSlot*)&((u8*)p)[sz];
112723: }
112724: db->lookaside.pEnd = p;
112725: db->lookaside.bEnabled = 1;
112726: db->lookaside.bMalloced = pBuf==0 ?1:0;
112727: }else{
112728: db->lookaside.pEnd = 0;
112729: db->lookaside.bEnabled = 0;
112730: db->lookaside.bMalloced = 0;
112731: }
112732: return SQLITE_OK;
112733: }
112734:
112735: /*
112736: ** Return the mutex associated with a database connection.
112737: */
112738: SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3 *db){
112739: return db->mutex;
112740: }
112741:
112742: /*
112743: ** Free up as much memory as we can from the given database
112744: ** connection.
112745: */
112746: SQLITE_API int sqlite3_db_release_memory(sqlite3 *db){
112747: int i;
112748: sqlite3_mutex_enter(db->mutex);
112749: sqlite3BtreeEnterAll(db);
112750: for(i=0; i<db->nDb; i++){
112751: Btree *pBt = db->aDb[i].pBt;
112752: if( pBt ){
112753: Pager *pPager = sqlite3BtreePager(pBt);
112754: sqlite3PagerShrink(pPager);
112755: }
112756: }
112757: sqlite3BtreeLeaveAll(db);
112758: sqlite3_mutex_leave(db->mutex);
112759: return SQLITE_OK;
112760: }
112761:
112762: /*
112763: ** Configuration settings for an individual database connection
112764: */
112765: SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){
112766: va_list ap;
112767: int rc;
112768: va_start(ap, op);
112769: switch( op ){
112770: case SQLITE_DBCONFIG_LOOKASIDE: {
112771: void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */
112772: int sz = va_arg(ap, int); /* IMP: R-47871-25994 */
112773: int cnt = va_arg(ap, int); /* IMP: R-04460-53386 */
112774: rc = setupLookaside(db, pBuf, sz, cnt);
112775: break;
112776: }
112777: default: {
112778: static const struct {
112779: int op; /* The opcode */
112780: u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */
112781: } aFlagOp[] = {
112782: { SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_ForeignKeys },
112783: { SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_EnableTrigger },
112784: };
112785: unsigned int i;
112786: rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
112787: for(i=0; i<ArraySize(aFlagOp); i++){
112788: if( aFlagOp[i].op==op ){
112789: int onoff = va_arg(ap, int);
112790: int *pRes = va_arg(ap, int*);
112791: int oldFlags = db->flags;
112792: if( onoff>0 ){
112793: db->flags |= aFlagOp[i].mask;
112794: }else if( onoff==0 ){
112795: db->flags &= ~aFlagOp[i].mask;
112796: }
112797: if( oldFlags!=db->flags ){
112798: sqlite3ExpirePreparedStatements(db);
112799: }
112800: if( pRes ){
112801: *pRes = (db->flags & aFlagOp[i].mask)!=0;
112802: }
112803: rc = SQLITE_OK;
112804: break;
112805: }
112806: }
112807: break;
112808: }
112809: }
112810: va_end(ap);
112811: return rc;
112812: }
112813:
112814:
112815: /*
112816: ** Return true if the buffer z[0..n-1] contains all spaces.
112817: */
112818: static int allSpaces(const char *z, int n){
112819: while( n>0 && z[n-1]==' ' ){ n--; }
112820: return n==0;
112821: }
112822:
112823: /*
112824: ** This is the default collating function named "BINARY" which is always
112825: ** available.
112826: **
112827: ** If the padFlag argument is not NULL then space padding at the end
112828: ** of strings is ignored. This implements the RTRIM collation.
112829: */
112830: static int binCollFunc(
112831: void *padFlag,
112832: int nKey1, const void *pKey1,
112833: int nKey2, const void *pKey2
112834: ){
112835: int rc, n;
112836: n = nKey1<nKey2 ? nKey1 : nKey2;
112837: rc = memcmp(pKey1, pKey2, n);
112838: if( rc==0 ){
112839: if( padFlag
112840: && allSpaces(((char*)pKey1)+n, nKey1-n)
112841: && allSpaces(((char*)pKey2)+n, nKey2-n)
112842: ){
112843: /* Leave rc unchanged at 0 */
112844: }else{
112845: rc = nKey1 - nKey2;
112846: }
112847: }
112848: return rc;
112849: }
112850:
112851: /*
112852: ** Another built-in collating sequence: NOCASE.
112853: **
112854: ** This collating sequence is intended to be used for "case independant
112855: ** comparison". SQLite's knowledge of upper and lower case equivalents
112856: ** extends only to the 26 characters used in the English language.
112857: **
112858: ** At the moment there is only a UTF-8 implementation.
112859: */
112860: static int nocaseCollatingFunc(
112861: void *NotUsed,
112862: int nKey1, const void *pKey1,
112863: int nKey2, const void *pKey2
112864: ){
112865: int r = sqlite3StrNICmp(
112866: (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
112867: UNUSED_PARAMETER(NotUsed);
112868: if( 0==r ){
112869: r = nKey1-nKey2;
112870: }
112871: return r;
112872: }
112873:
112874: /*
112875: ** Return the ROWID of the most recent insert
112876: */
112877: SQLITE_API sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
112878: return db->lastRowid;
112879: }
112880:
112881: /*
112882: ** Return the number of changes in the most recent call to sqlite3_exec().
112883: */
112884: SQLITE_API int sqlite3_changes(sqlite3 *db){
112885: return db->nChange;
112886: }
112887:
112888: /*
112889: ** Return the number of changes since the database handle was opened.
112890: */
112891: SQLITE_API int sqlite3_total_changes(sqlite3 *db){
112892: return db->nTotalChange;
112893: }
112894:
112895: /*
112896: ** Close all open savepoints. This function only manipulates fields of the
112897: ** database handle object, it does not close any savepoints that may be open
112898: ** at the b-tree/pager level.
112899: */
112900: SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *db){
112901: while( db->pSavepoint ){
112902: Savepoint *pTmp = db->pSavepoint;
112903: db->pSavepoint = pTmp->pNext;
112904: sqlite3DbFree(db, pTmp);
112905: }
112906: db->nSavepoint = 0;
112907: db->nStatement = 0;
112908: db->isTransactionSavepoint = 0;
112909: }
112910:
112911: /*
112912: ** Invoke the destructor function associated with FuncDef p, if any. Except,
112913: ** if this is not the last copy of the function, do not invoke it. Multiple
112914: ** copies of a single function are created when create_function() is called
112915: ** with SQLITE_ANY as the encoding.
112916: */
112917: static void functionDestroy(sqlite3 *db, FuncDef *p){
112918: FuncDestructor *pDestructor = p->pDestructor;
112919: if( pDestructor ){
112920: pDestructor->nRef--;
112921: if( pDestructor->nRef==0 ){
112922: pDestructor->xDestroy(pDestructor->pUserData);
112923: sqlite3DbFree(db, pDestructor);
112924: }
112925: }
112926: }
112927:
112928: /*
112929: ** Close an existing SQLite database
112930: */
112931: SQLITE_API int sqlite3_close(sqlite3 *db){
112932: HashElem *i; /* Hash table iterator */
112933: int j;
112934:
112935: if( !db ){
112936: return SQLITE_OK;
112937: }
112938: if( !sqlite3SafetyCheckSickOrOk(db) ){
112939: return SQLITE_MISUSE_BKPT;
112940: }
112941: sqlite3_mutex_enter(db->mutex);
112942:
112943: /* Force xDestroy calls on all virtual tables */
112944: sqlite3ResetInternalSchema(db, -1);
112945:
112946: /* If a transaction is open, the ResetInternalSchema() call above
112947: ** will not have called the xDisconnect() method on any virtual
112948: ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
112949: ** call will do so. We need to do this before the check for active
112950: ** SQL statements below, as the v-table implementation may be storing
112951: ** some prepared statements internally.
112952: */
112953: sqlite3VtabRollback(db);
112954:
112955: /* If there are any outstanding VMs, return SQLITE_BUSY. */
112956: if( db->pVdbe ){
112957: sqlite3Error(db, SQLITE_BUSY,
112958: "unable to close due to unfinalised statements");
112959: sqlite3_mutex_leave(db->mutex);
112960: return SQLITE_BUSY;
112961: }
112962: assert( sqlite3SafetyCheckSickOrOk(db) );
112963:
112964: for(j=0; j<db->nDb; j++){
112965: Btree *pBt = db->aDb[j].pBt;
112966: if( pBt && sqlite3BtreeIsInBackup(pBt) ){
112967: sqlite3Error(db, SQLITE_BUSY,
112968: "unable to close due to unfinished backup operation");
112969: sqlite3_mutex_leave(db->mutex);
112970: return SQLITE_BUSY;
112971: }
112972: }
112973:
112974: /* Free any outstanding Savepoint structures. */
112975: sqlite3CloseSavepoints(db);
112976:
112977: for(j=0; j<db->nDb; j++){
112978: struct Db *pDb = &db->aDb[j];
112979: if( pDb->pBt ){
112980: sqlite3BtreeClose(pDb->pBt);
112981: pDb->pBt = 0;
112982: if( j!=1 ){
112983: pDb->pSchema = 0;
112984: }
112985: }
112986: }
112987: sqlite3ResetInternalSchema(db, -1);
112988:
112989: /* Tell the code in notify.c that the connection no longer holds any
112990: ** locks and does not require any further unlock-notify callbacks.
112991: */
112992: sqlite3ConnectionClosed(db);
112993:
112994: assert( db->nDb<=2 );
112995: assert( db->aDb==db->aDbStatic );
112996: for(j=0; j<ArraySize(db->aFunc.a); j++){
112997: FuncDef *pNext, *pHash, *p;
112998: for(p=db->aFunc.a[j]; p; p=pHash){
112999: pHash = p->pHash;
113000: while( p ){
113001: functionDestroy(db, p);
113002: pNext = p->pNext;
113003: sqlite3DbFree(db, p);
113004: p = pNext;
113005: }
113006: }
113007: }
113008: for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
113009: CollSeq *pColl = (CollSeq *)sqliteHashData(i);
113010: /* Invoke any destructors registered for collation sequence user data. */
113011: for(j=0; j<3; j++){
113012: if( pColl[j].xDel ){
113013: pColl[j].xDel(pColl[j].pUser);
113014: }
113015: }
113016: sqlite3DbFree(db, pColl);
113017: }
113018: sqlite3HashClear(&db->aCollSeq);
113019: #ifndef SQLITE_OMIT_VIRTUALTABLE
113020: for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
113021: Module *pMod = (Module *)sqliteHashData(i);
113022: if( pMod->xDestroy ){
113023: pMod->xDestroy(pMod->pAux);
113024: }
113025: sqlite3DbFree(db, pMod);
113026: }
113027: sqlite3HashClear(&db->aModule);
113028: #endif
113029:
113030: sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
113031: if( db->pErr ){
113032: sqlite3ValueFree(db->pErr);
113033: }
113034: sqlite3CloseExtensions(db);
113035:
113036: db->magic = SQLITE_MAGIC_ERROR;
113037:
113038: /* The temp-database schema is allocated differently from the other schema
113039: ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
113040: ** So it needs to be freed here. Todo: Why not roll the temp schema into
113041: ** the same sqliteMalloc() as the one that allocates the database
113042: ** structure?
113043: */
113044: sqlite3DbFree(db, db->aDb[1].pSchema);
113045: sqlite3_mutex_leave(db->mutex);
113046: db->magic = SQLITE_MAGIC_CLOSED;
113047: sqlite3_mutex_free(db->mutex);
113048: assert( db->lookaside.nOut==0 ); /* Fails on a lookaside memory leak */
113049: if( db->lookaside.bMalloced ){
113050: sqlite3_free(db->lookaside.pStart);
113051: }
113052: sqlite3_free(db);
113053: return SQLITE_OK;
113054: }
113055:
113056: /*
113057: ** Rollback all database files.
113058: */
113059: SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db){
113060: int i;
113061: int inTrans = 0;
113062: assert( sqlite3_mutex_held(db->mutex) );
113063: sqlite3BeginBenignMalloc();
113064: for(i=0; i<db->nDb; i++){
113065: if( db->aDb[i].pBt ){
113066: if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
113067: inTrans = 1;
113068: }
113069: sqlite3BtreeRollback(db->aDb[i].pBt);
113070: db->aDb[i].inTrans = 0;
113071: }
113072: }
113073: sqlite3VtabRollback(db);
113074: sqlite3EndBenignMalloc();
113075:
113076: if( db->flags&SQLITE_InternChanges ){
113077: sqlite3ExpirePreparedStatements(db);
113078: sqlite3ResetInternalSchema(db, -1);
113079: }
113080:
113081: /* Any deferred constraint violations have now been resolved. */
113082: db->nDeferredCons = 0;
113083:
113084: /* If one has been configured, invoke the rollback-hook callback */
113085: if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
113086: db->xRollbackCallback(db->pRollbackArg);
113087: }
113088: }
113089:
113090: /*
113091: ** Return a static string that describes the kind of error specified in the
113092: ** argument.
113093: */
113094: SQLITE_PRIVATE const char *sqlite3ErrStr(int rc){
113095: static const char* const aMsg[] = {
113096: /* SQLITE_OK */ "not an error",
113097: /* SQLITE_ERROR */ "SQL logic error or missing database",
113098: /* SQLITE_INTERNAL */ 0,
113099: /* SQLITE_PERM */ "access permission denied",
113100: /* SQLITE_ABORT */ "callback requested query abort",
113101: /* SQLITE_BUSY */ "database is locked",
113102: /* SQLITE_LOCKED */ "database table is locked",
113103: /* SQLITE_NOMEM */ "out of memory",
113104: /* SQLITE_READONLY */ "attempt to write a readonly database",
113105: /* SQLITE_INTERRUPT */ "interrupted",
113106: /* SQLITE_IOERR */ "disk I/O error",
113107: /* SQLITE_CORRUPT */ "database disk image is malformed",
113108: /* SQLITE_NOTFOUND */ "unknown operation",
113109: /* SQLITE_FULL */ "database or disk is full",
113110: /* SQLITE_CANTOPEN */ "unable to open database file",
113111: /* SQLITE_PROTOCOL */ "locking protocol",
113112: /* SQLITE_EMPTY */ "table contains no data",
113113: /* SQLITE_SCHEMA */ "database schema has changed",
113114: /* SQLITE_TOOBIG */ "string or blob too big",
113115: /* SQLITE_CONSTRAINT */ "constraint failed",
113116: /* SQLITE_MISMATCH */ "datatype mismatch",
113117: /* SQLITE_MISUSE */ "library routine called out of sequence",
113118: /* SQLITE_NOLFS */ "large file support is disabled",
113119: /* SQLITE_AUTH */ "authorization denied",
113120: /* SQLITE_FORMAT */ "auxiliary database format error",
113121: /* SQLITE_RANGE */ "bind or column index out of range",
113122: /* SQLITE_NOTADB */ "file is encrypted or is not a database",
113123: };
113124: rc &= 0xff;
113125: if( ALWAYS(rc>=0) && rc<(int)(sizeof(aMsg)/sizeof(aMsg[0])) && aMsg[rc]!=0 ){
113126: return aMsg[rc];
113127: }else{
113128: return "unknown error";
113129: }
113130: }
113131:
113132: /*
113133: ** This routine implements a busy callback that sleeps and tries
113134: ** again until a timeout value is reached. The timeout value is
113135: ** an integer number of milliseconds passed in as the first
113136: ** argument.
113137: */
113138: static int sqliteDefaultBusyCallback(
113139: void *ptr, /* Database connection */
113140: int count /* Number of times table has been busy */
113141: ){
113142: #if SQLITE_OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
113143: static const u8 delays[] =
113144: { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
113145: static const u8 totals[] =
113146: { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
113147: # define NDELAY ArraySize(delays)
113148: sqlite3 *db = (sqlite3 *)ptr;
113149: int timeout = db->busyTimeout;
113150: int delay, prior;
113151:
113152: assert( count>=0 );
113153: if( count < NDELAY ){
113154: delay = delays[count];
113155: prior = totals[count];
113156: }else{
113157: delay = delays[NDELAY-1];
113158: prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
113159: }
113160: if( prior + delay > timeout ){
113161: delay = timeout - prior;
113162: if( delay<=0 ) return 0;
113163: }
113164: sqlite3OsSleep(db->pVfs, delay*1000);
113165: return 1;
113166: #else
113167: sqlite3 *db = (sqlite3 *)ptr;
113168: int timeout = ((sqlite3 *)ptr)->busyTimeout;
113169: if( (count+1)*1000 > timeout ){
113170: return 0;
113171: }
113172: sqlite3OsSleep(db->pVfs, 1000000);
113173: return 1;
113174: #endif
113175: }
113176:
113177: /*
113178: ** Invoke the given busy handler.
113179: **
113180: ** This routine is called when an operation failed with a lock.
113181: ** If this routine returns non-zero, the lock is retried. If it
113182: ** returns 0, the operation aborts with an SQLITE_BUSY error.
113183: */
113184: SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler *p){
113185: int rc;
113186: if( NEVER(p==0) || p->xFunc==0 || p->nBusy<0 ) return 0;
113187: rc = p->xFunc(p->pArg, p->nBusy);
113188: if( rc==0 ){
113189: p->nBusy = -1;
113190: }else{
113191: p->nBusy++;
113192: }
113193: return rc;
113194: }
113195:
113196: /*
113197: ** This routine sets the busy callback for an Sqlite database to the
113198: ** given callback function with the given argument.
113199: */
113200: SQLITE_API int sqlite3_busy_handler(
113201: sqlite3 *db,
113202: int (*xBusy)(void*,int),
113203: void *pArg
113204: ){
113205: sqlite3_mutex_enter(db->mutex);
113206: db->busyHandler.xFunc = xBusy;
113207: db->busyHandler.pArg = pArg;
113208: db->busyHandler.nBusy = 0;
113209: sqlite3_mutex_leave(db->mutex);
113210: return SQLITE_OK;
113211: }
113212:
113213: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
113214: /*
113215: ** This routine sets the progress callback for an Sqlite database to the
113216: ** given callback function with the given argument. The progress callback will
113217: ** be invoked every nOps opcodes.
113218: */
113219: SQLITE_API void sqlite3_progress_handler(
113220: sqlite3 *db,
113221: int nOps,
113222: int (*xProgress)(void*),
113223: void *pArg
113224: ){
113225: sqlite3_mutex_enter(db->mutex);
113226: if( nOps>0 ){
113227: db->xProgress = xProgress;
113228: db->nProgressOps = nOps;
113229: db->pProgressArg = pArg;
113230: }else{
113231: db->xProgress = 0;
113232: db->nProgressOps = 0;
113233: db->pProgressArg = 0;
113234: }
113235: sqlite3_mutex_leave(db->mutex);
113236: }
113237: #endif
113238:
113239:
113240: /*
113241: ** This routine installs a default busy handler that waits for the
113242: ** specified number of milliseconds before returning 0.
113243: */
113244: SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms){
113245: if( ms>0 ){
113246: db->busyTimeout = ms;
113247: sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
113248: }else{
113249: sqlite3_busy_handler(db, 0, 0);
113250: }
113251: return SQLITE_OK;
113252: }
113253:
113254: /*
113255: ** Cause any pending operation to stop at its earliest opportunity.
113256: */
113257: SQLITE_API void sqlite3_interrupt(sqlite3 *db){
113258: db->u1.isInterrupted = 1;
113259: }
113260:
113261:
113262: /*
113263: ** This function is exactly the same as sqlite3_create_function(), except
113264: ** that it is designed to be called by internal code. The difference is
113265: ** that if a malloc() fails in sqlite3_create_function(), an error code
113266: ** is returned and the mallocFailed flag cleared.
113267: */
113268: SQLITE_PRIVATE int sqlite3CreateFunc(
113269: sqlite3 *db,
113270: const char *zFunctionName,
113271: int nArg,
113272: int enc,
113273: void *pUserData,
113274: void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
113275: void (*xStep)(sqlite3_context*,int,sqlite3_value **),
113276: void (*xFinal)(sqlite3_context*),
113277: FuncDestructor *pDestructor
113278: ){
113279: FuncDef *p;
113280: int nName;
113281:
113282: assert( sqlite3_mutex_held(db->mutex) );
113283: if( zFunctionName==0 ||
113284: (xFunc && (xFinal || xStep)) ||
113285: (!xFunc && (xFinal && !xStep)) ||
113286: (!xFunc && (!xFinal && xStep)) ||
113287: (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) ||
113288: (255<(nName = sqlite3Strlen30( zFunctionName))) ){
113289: return SQLITE_MISUSE_BKPT;
113290: }
113291:
113292: #ifndef SQLITE_OMIT_UTF16
113293: /* If SQLITE_UTF16 is specified as the encoding type, transform this
113294: ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
113295: ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
113296: **
113297: ** If SQLITE_ANY is specified, add three versions of the function
113298: ** to the hash table.
113299: */
113300: if( enc==SQLITE_UTF16 ){
113301: enc = SQLITE_UTF16NATIVE;
113302: }else if( enc==SQLITE_ANY ){
113303: int rc;
113304: rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
113305: pUserData, xFunc, xStep, xFinal, pDestructor);
113306: if( rc==SQLITE_OK ){
113307: rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
113308: pUserData, xFunc, xStep, xFinal, pDestructor);
113309: }
113310: if( rc!=SQLITE_OK ){
113311: return rc;
113312: }
113313: enc = SQLITE_UTF16BE;
113314: }
113315: #else
113316: enc = SQLITE_UTF8;
113317: #endif
113318:
113319: /* Check if an existing function is being overridden or deleted. If so,
113320: ** and there are active VMs, then return SQLITE_BUSY. If a function
113321: ** is being overridden/deleted but there are no active VMs, allow the
113322: ** operation to continue but invalidate all precompiled statements.
113323: */
113324: p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0);
113325: if( p && p->iPrefEnc==enc && p->nArg==nArg ){
113326: if( db->activeVdbeCnt ){
113327: sqlite3Error(db, SQLITE_BUSY,
113328: "unable to delete/modify user-function due to active statements");
113329: assert( !db->mallocFailed );
113330: return SQLITE_BUSY;
113331: }else{
113332: sqlite3ExpirePreparedStatements(db);
113333: }
113334: }
113335:
113336: p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 1);
113337: assert(p || db->mallocFailed);
113338: if( !p ){
113339: return SQLITE_NOMEM;
113340: }
113341:
113342: /* If an older version of the function with a configured destructor is
113343: ** being replaced invoke the destructor function here. */
113344: functionDestroy(db, p);
113345:
113346: if( pDestructor ){
113347: pDestructor->nRef++;
113348: }
113349: p->pDestructor = pDestructor;
113350: p->flags = 0;
113351: p->xFunc = xFunc;
113352: p->xStep = xStep;
113353: p->xFinalize = xFinal;
113354: p->pUserData = pUserData;
113355: p->nArg = (u16)nArg;
113356: return SQLITE_OK;
113357: }
113358:
113359: /*
113360: ** Create new user functions.
113361: */
113362: SQLITE_API int sqlite3_create_function(
113363: sqlite3 *db,
113364: const char *zFunc,
113365: int nArg,
113366: int enc,
113367: void *p,
113368: void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
113369: void (*xStep)(sqlite3_context*,int,sqlite3_value **),
113370: void (*xFinal)(sqlite3_context*)
113371: ){
113372: return sqlite3_create_function_v2(db, zFunc, nArg, enc, p, xFunc, xStep,
113373: xFinal, 0);
113374: }
113375:
113376: SQLITE_API int sqlite3_create_function_v2(
113377: sqlite3 *db,
113378: const char *zFunc,
113379: int nArg,
113380: int enc,
113381: void *p,
113382: void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
113383: void (*xStep)(sqlite3_context*,int,sqlite3_value **),
113384: void (*xFinal)(sqlite3_context*),
113385: void (*xDestroy)(void *)
113386: ){
113387: int rc = SQLITE_ERROR;
113388: FuncDestructor *pArg = 0;
113389: sqlite3_mutex_enter(db->mutex);
113390: if( xDestroy ){
113391: pArg = (FuncDestructor *)sqlite3DbMallocZero(db, sizeof(FuncDestructor));
113392: if( !pArg ){
113393: xDestroy(p);
113394: goto out;
113395: }
113396: pArg->xDestroy = xDestroy;
113397: pArg->pUserData = p;
113398: }
113399: rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg);
113400: if( pArg && pArg->nRef==0 ){
113401: assert( rc!=SQLITE_OK );
113402: xDestroy(p);
113403: sqlite3DbFree(db, pArg);
113404: }
113405:
113406: out:
113407: rc = sqlite3ApiExit(db, rc);
113408: sqlite3_mutex_leave(db->mutex);
113409: return rc;
113410: }
113411:
113412: #ifndef SQLITE_OMIT_UTF16
113413: SQLITE_API int sqlite3_create_function16(
113414: sqlite3 *db,
113415: const void *zFunctionName,
113416: int nArg,
113417: int eTextRep,
113418: void *p,
113419: void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
113420: void (*xStep)(sqlite3_context*,int,sqlite3_value**),
113421: void (*xFinal)(sqlite3_context*)
113422: ){
113423: int rc;
113424: char *zFunc8;
113425: sqlite3_mutex_enter(db->mutex);
113426: assert( !db->mallocFailed );
113427: zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);
113428: rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal,0);
113429: sqlite3DbFree(db, zFunc8);
113430: rc = sqlite3ApiExit(db, rc);
113431: sqlite3_mutex_leave(db->mutex);
113432: return rc;
113433: }
113434: #endif
113435:
113436:
113437: /*
113438: ** Declare that a function has been overloaded by a virtual table.
113439: **
113440: ** If the function already exists as a regular global function, then
113441: ** this routine is a no-op. If the function does not exist, then create
113442: ** a new one that always throws a run-time error.
113443: **
113444: ** When virtual tables intend to provide an overloaded function, they
113445: ** should call this routine to make sure the global function exists.
113446: ** A global function must exist in order for name resolution to work
113447: ** properly.
113448: */
113449: SQLITE_API int sqlite3_overload_function(
113450: sqlite3 *db,
113451: const char *zName,
113452: int nArg
113453: ){
113454: int nName = sqlite3Strlen30(zName);
113455: int rc = SQLITE_OK;
113456: sqlite3_mutex_enter(db->mutex);
113457: if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
113458: rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
113459: 0, sqlite3InvalidFunction, 0, 0, 0);
113460: }
113461: rc = sqlite3ApiExit(db, rc);
113462: sqlite3_mutex_leave(db->mutex);
113463: return rc;
113464: }
113465:
113466: #ifndef SQLITE_OMIT_TRACE
113467: /*
113468: ** Register a trace function. The pArg from the previously registered trace
113469: ** is returned.
113470: **
113471: ** A NULL trace function means that no tracing is executes. A non-NULL
113472: ** trace is a pointer to a function that is invoked at the start of each
113473: ** SQL statement.
113474: */
113475: SQLITE_API void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
113476: void *pOld;
113477: sqlite3_mutex_enter(db->mutex);
113478: pOld = db->pTraceArg;
113479: db->xTrace = xTrace;
113480: db->pTraceArg = pArg;
113481: sqlite3_mutex_leave(db->mutex);
113482: return pOld;
113483: }
113484: /*
113485: ** Register a profile function. The pArg from the previously registered
113486: ** profile function is returned.
113487: **
113488: ** A NULL profile function means that no profiling is executes. A non-NULL
113489: ** profile is a pointer to a function that is invoked at the conclusion of
113490: ** each SQL statement that is run.
113491: */
113492: SQLITE_API void *sqlite3_profile(
113493: sqlite3 *db,
113494: void (*xProfile)(void*,const char*,sqlite_uint64),
113495: void *pArg
113496: ){
113497: void *pOld;
113498: sqlite3_mutex_enter(db->mutex);
113499: pOld = db->pProfileArg;
113500: db->xProfile = xProfile;
113501: db->pProfileArg = pArg;
113502: sqlite3_mutex_leave(db->mutex);
113503: return pOld;
113504: }
113505: #endif /* SQLITE_OMIT_TRACE */
113506:
113507: /*** EXPERIMENTAL ***
113508: **
113509: ** Register a function to be invoked when a transaction comments.
113510: ** If the invoked function returns non-zero, then the commit becomes a
113511: ** rollback.
113512: */
113513: SQLITE_API void *sqlite3_commit_hook(
113514: sqlite3 *db, /* Attach the hook to this database */
113515: int (*xCallback)(void*), /* Function to invoke on each commit */
113516: void *pArg /* Argument to the function */
113517: ){
113518: void *pOld;
113519: sqlite3_mutex_enter(db->mutex);
113520: pOld = db->pCommitArg;
113521: db->xCommitCallback = xCallback;
113522: db->pCommitArg = pArg;
113523: sqlite3_mutex_leave(db->mutex);
113524: return pOld;
113525: }
113526:
113527: /*
113528: ** Register a callback to be invoked each time a row is updated,
113529: ** inserted or deleted using this database connection.
113530: */
113531: SQLITE_API void *sqlite3_update_hook(
113532: sqlite3 *db, /* Attach the hook to this database */
113533: void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
113534: void *pArg /* Argument to the function */
113535: ){
113536: void *pRet;
113537: sqlite3_mutex_enter(db->mutex);
113538: pRet = db->pUpdateArg;
113539: db->xUpdateCallback = xCallback;
113540: db->pUpdateArg = pArg;
113541: sqlite3_mutex_leave(db->mutex);
113542: return pRet;
113543: }
113544:
113545: /*
113546: ** Register a callback to be invoked each time a transaction is rolled
113547: ** back by this database connection.
113548: */
113549: SQLITE_API void *sqlite3_rollback_hook(
113550: sqlite3 *db, /* Attach the hook to this database */
113551: void (*xCallback)(void*), /* Callback function */
113552: void *pArg /* Argument to the function */
113553: ){
113554: void *pRet;
113555: sqlite3_mutex_enter(db->mutex);
113556: pRet = db->pRollbackArg;
113557: db->xRollbackCallback = xCallback;
113558: db->pRollbackArg = pArg;
113559: sqlite3_mutex_leave(db->mutex);
113560: return pRet;
113561: }
113562:
113563: #ifndef SQLITE_OMIT_WAL
113564: /*
113565: ** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint().
113566: ** Invoke sqlite3_wal_checkpoint if the number of frames in the log file
113567: ** is greater than sqlite3.pWalArg cast to an integer (the value configured by
113568: ** wal_autocheckpoint()).
113569: */
113570: SQLITE_PRIVATE int sqlite3WalDefaultHook(
113571: void *pClientData, /* Argument */
113572: sqlite3 *db, /* Connection */
113573: const char *zDb, /* Database */
113574: int nFrame /* Size of WAL */
113575: ){
113576: if( nFrame>=SQLITE_PTR_TO_INT(pClientData) ){
113577: sqlite3BeginBenignMalloc();
113578: sqlite3_wal_checkpoint(db, zDb);
113579: sqlite3EndBenignMalloc();
113580: }
113581: return SQLITE_OK;
113582: }
113583: #endif /* SQLITE_OMIT_WAL */
113584:
113585: /*
113586: ** Configure an sqlite3_wal_hook() callback to automatically checkpoint
113587: ** a database after committing a transaction if there are nFrame or
113588: ** more frames in the log file. Passing zero or a negative value as the
113589: ** nFrame parameter disables automatic checkpoints entirely.
113590: **
113591: ** The callback registered by this function replaces any existing callback
113592: ** registered using sqlite3_wal_hook(). Likewise, registering a callback
113593: ** using sqlite3_wal_hook() disables the automatic checkpoint mechanism
113594: ** configured by this function.
113595: */
113596: SQLITE_API int sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){
113597: #ifdef SQLITE_OMIT_WAL
113598: UNUSED_PARAMETER(db);
113599: UNUSED_PARAMETER(nFrame);
113600: #else
113601: if( nFrame>0 ){
113602: sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame));
113603: }else{
113604: sqlite3_wal_hook(db, 0, 0);
113605: }
113606: #endif
113607: return SQLITE_OK;
113608: }
113609:
113610: /*
113611: ** Register a callback to be invoked each time a transaction is written
113612: ** into the write-ahead-log by this database connection.
113613: */
113614: SQLITE_API void *sqlite3_wal_hook(
113615: sqlite3 *db, /* Attach the hook to this db handle */
113616: int(*xCallback)(void *, sqlite3*, const char*, int),
113617: void *pArg /* First argument passed to xCallback() */
113618: ){
113619: #ifndef SQLITE_OMIT_WAL
113620: void *pRet;
113621: sqlite3_mutex_enter(db->mutex);
113622: pRet = db->pWalArg;
113623: db->xWalCallback = xCallback;
113624: db->pWalArg = pArg;
113625: sqlite3_mutex_leave(db->mutex);
113626: return pRet;
113627: #else
113628: return 0;
113629: #endif
113630: }
113631:
113632: /*
113633: ** Checkpoint database zDb.
113634: */
113635: SQLITE_API int sqlite3_wal_checkpoint_v2(
113636: sqlite3 *db, /* Database handle */
113637: const char *zDb, /* Name of attached database (or NULL) */
113638: int eMode, /* SQLITE_CHECKPOINT_* value */
113639: int *pnLog, /* OUT: Size of WAL log in frames */
113640: int *pnCkpt /* OUT: Total number of frames checkpointed */
113641: ){
113642: #ifdef SQLITE_OMIT_WAL
113643: return SQLITE_OK;
113644: #else
113645: int rc; /* Return code */
113646: int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */
113647:
113648: /* Initialize the output variables to -1 in case an error occurs. */
113649: if( pnLog ) *pnLog = -1;
113650: if( pnCkpt ) *pnCkpt = -1;
113651:
113652: assert( SQLITE_CHECKPOINT_FULL>SQLITE_CHECKPOINT_PASSIVE );
113653: assert( SQLITE_CHECKPOINT_FULL<SQLITE_CHECKPOINT_RESTART );
113654: assert( SQLITE_CHECKPOINT_PASSIVE+2==SQLITE_CHECKPOINT_RESTART );
113655: if( eMode<SQLITE_CHECKPOINT_PASSIVE || eMode>SQLITE_CHECKPOINT_RESTART ){
113656: return SQLITE_MISUSE;
113657: }
113658:
113659: sqlite3_mutex_enter(db->mutex);
113660: if( zDb && zDb[0] ){
113661: iDb = sqlite3FindDbName(db, zDb);
113662: }
113663: if( iDb<0 ){
113664: rc = SQLITE_ERROR;
113665: sqlite3Error(db, SQLITE_ERROR, "unknown database: %s", zDb);
113666: }else{
113667: rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
113668: sqlite3Error(db, rc, 0);
113669: }
113670: rc = sqlite3ApiExit(db, rc);
113671: sqlite3_mutex_leave(db->mutex);
113672: return rc;
113673: #endif
113674: }
113675:
113676:
113677: /*
113678: ** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
113679: ** to contains a zero-length string, all attached databases are
113680: ** checkpointed.
113681: */
113682: SQLITE_API int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
113683: return sqlite3_wal_checkpoint_v2(db, zDb, SQLITE_CHECKPOINT_PASSIVE, 0, 0);
113684: }
113685:
113686: #ifndef SQLITE_OMIT_WAL
113687: /*
113688: ** Run a checkpoint on database iDb. This is a no-op if database iDb is
113689: ** not currently open in WAL mode.
113690: **
113691: ** If a transaction is open on the database being checkpointed, this
113692: ** function returns SQLITE_LOCKED and a checkpoint is not attempted. If
113693: ** an error occurs while running the checkpoint, an SQLite error code is
113694: ** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
113695: **
113696: ** The mutex on database handle db should be held by the caller. The mutex
113697: ** associated with the specific b-tree being checkpointed is taken by
113698: ** this function while the checkpoint is running.
113699: **
113700: ** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
113701: ** checkpointed. If an error is encountered it is returned immediately -
113702: ** no attempt is made to checkpoint any remaining databases.
113703: **
113704: ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
113705: */
113706: SQLITE_PRIVATE int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
113707: int rc = SQLITE_OK; /* Return code */
113708: int i; /* Used to iterate through attached dbs */
113709: int bBusy = 0; /* True if SQLITE_BUSY has been encountered */
113710:
113711: assert( sqlite3_mutex_held(db->mutex) );
113712: assert( !pnLog || *pnLog==-1 );
113713: assert( !pnCkpt || *pnCkpt==-1 );
113714:
113715: for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
113716: if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){
113717: rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
113718: pnLog = 0;
113719: pnCkpt = 0;
113720: if( rc==SQLITE_BUSY ){
113721: bBusy = 1;
113722: rc = SQLITE_OK;
113723: }
113724: }
113725: }
113726:
113727: return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
113728: }
113729: #endif /* SQLITE_OMIT_WAL */
113730:
113731: /*
113732: ** This function returns true if main-memory should be used instead of
113733: ** a temporary file for transient pager files and statement journals.
113734: ** The value returned depends on the value of db->temp_store (runtime
113735: ** parameter) and the compile time value of SQLITE_TEMP_STORE. The
113736: ** following table describes the relationship between these two values
113737: ** and this functions return value.
113738: **
113739: ** SQLITE_TEMP_STORE db->temp_store Location of temporary database
113740: ** ----------------- -------------- ------------------------------
113741: ** 0 any file (return 0)
113742: ** 1 1 file (return 0)
113743: ** 1 2 memory (return 1)
113744: ** 1 0 file (return 0)
113745: ** 2 1 file (return 0)
113746: ** 2 2 memory (return 1)
113747: ** 2 0 memory (return 1)
113748: ** 3 any memory (return 1)
113749: */
113750: SQLITE_PRIVATE int sqlite3TempInMemory(const sqlite3 *db){
113751: #if SQLITE_TEMP_STORE==1
113752: return ( db->temp_store==2 );
113753: #endif
113754: #if SQLITE_TEMP_STORE==2
113755: return ( db->temp_store!=1 );
113756: #endif
113757: #if SQLITE_TEMP_STORE==3
113758: return 1;
113759: #endif
113760: #if SQLITE_TEMP_STORE<1 || SQLITE_TEMP_STORE>3
113761: return 0;
113762: #endif
113763: }
113764:
113765: /*
113766: ** Return UTF-8 encoded English language explanation of the most recent
113767: ** error.
113768: */
113769: SQLITE_API const char *sqlite3_errmsg(sqlite3 *db){
113770: const char *z;
113771: if( !db ){
113772: return sqlite3ErrStr(SQLITE_NOMEM);
113773: }
113774: if( !sqlite3SafetyCheckSickOrOk(db) ){
113775: return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
113776: }
113777: sqlite3_mutex_enter(db->mutex);
113778: if( db->mallocFailed ){
113779: z = sqlite3ErrStr(SQLITE_NOMEM);
113780: }else{
113781: z = (char*)sqlite3_value_text(db->pErr);
113782: assert( !db->mallocFailed );
113783: if( z==0 ){
113784: z = sqlite3ErrStr(db->errCode);
113785: }
113786: }
113787: sqlite3_mutex_leave(db->mutex);
113788: return z;
113789: }
113790:
113791: #ifndef SQLITE_OMIT_UTF16
113792: /*
113793: ** Return UTF-16 encoded English language explanation of the most recent
113794: ** error.
113795: */
113796: SQLITE_API const void *sqlite3_errmsg16(sqlite3 *db){
113797: static const u16 outOfMem[] = {
113798: 'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
113799: };
113800: static const u16 misuse[] = {
113801: 'l', 'i', 'b', 'r', 'a', 'r', 'y', ' ',
113802: 'r', 'o', 'u', 't', 'i', 'n', 'e', ' ',
113803: 'c', 'a', 'l', 'l', 'e', 'd', ' ',
113804: 'o', 'u', 't', ' ',
113805: 'o', 'f', ' ',
113806: 's', 'e', 'q', 'u', 'e', 'n', 'c', 'e', 0
113807: };
113808:
113809: const void *z;
113810: if( !db ){
113811: return (void *)outOfMem;
113812: }
113813: if( !sqlite3SafetyCheckSickOrOk(db) ){
113814: return (void *)misuse;
113815: }
113816: sqlite3_mutex_enter(db->mutex);
113817: if( db->mallocFailed ){
113818: z = (void *)outOfMem;
113819: }else{
113820: z = sqlite3_value_text16(db->pErr);
113821: if( z==0 ){
113822: sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
113823: SQLITE_UTF8, SQLITE_STATIC);
113824: z = sqlite3_value_text16(db->pErr);
113825: }
113826: /* A malloc() may have failed within the call to sqlite3_value_text16()
113827: ** above. If this is the case, then the db->mallocFailed flag needs to
113828: ** be cleared before returning. Do this directly, instead of via
113829: ** sqlite3ApiExit(), to avoid setting the database handle error message.
113830: */
113831: db->mallocFailed = 0;
113832: }
113833: sqlite3_mutex_leave(db->mutex);
113834: return z;
113835: }
113836: #endif /* SQLITE_OMIT_UTF16 */
113837:
113838: /*
113839: ** Return the most recent error code generated by an SQLite routine. If NULL is
113840: ** passed to this function, we assume a malloc() failed during sqlite3_open().
113841: */
113842: SQLITE_API int sqlite3_errcode(sqlite3 *db){
113843: if( db && !sqlite3SafetyCheckSickOrOk(db) ){
113844: return SQLITE_MISUSE_BKPT;
113845: }
113846: if( !db || db->mallocFailed ){
113847: return SQLITE_NOMEM;
113848: }
113849: return db->errCode & db->errMask;
113850: }
113851: SQLITE_API int sqlite3_extended_errcode(sqlite3 *db){
113852: if( db && !sqlite3SafetyCheckSickOrOk(db) ){
113853: return SQLITE_MISUSE_BKPT;
113854: }
113855: if( !db || db->mallocFailed ){
113856: return SQLITE_NOMEM;
113857: }
113858: return db->errCode;
113859: }
113860:
113861: /*
113862: ** Create a new collating function for database "db". The name is zName
113863: ** and the encoding is enc.
113864: */
113865: static int createCollation(
113866: sqlite3* db,
113867: const char *zName,
113868: u8 enc,
113869: void* pCtx,
113870: int(*xCompare)(void*,int,const void*,int,const void*),
113871: void(*xDel)(void*)
113872: ){
113873: CollSeq *pColl;
113874: int enc2;
113875: int nName = sqlite3Strlen30(zName);
113876:
113877: assert( sqlite3_mutex_held(db->mutex) );
113878:
113879: /* If SQLITE_UTF16 is specified as the encoding type, transform this
113880: ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
113881: ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
113882: */
113883: enc2 = enc;
113884: testcase( enc2==SQLITE_UTF16 );
113885: testcase( enc2==SQLITE_UTF16_ALIGNED );
113886: if( enc2==SQLITE_UTF16 || enc2==SQLITE_UTF16_ALIGNED ){
113887: enc2 = SQLITE_UTF16NATIVE;
113888: }
113889: if( enc2<SQLITE_UTF8 || enc2>SQLITE_UTF16BE ){
113890: return SQLITE_MISUSE_BKPT;
113891: }
113892:
113893: /* Check if this call is removing or replacing an existing collation
113894: ** sequence. If so, and there are active VMs, return busy. If there
113895: ** are no active VMs, invalidate any pre-compiled statements.
113896: */
113897: pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
113898: if( pColl && pColl->xCmp ){
113899: if( db->activeVdbeCnt ){
113900: sqlite3Error(db, SQLITE_BUSY,
113901: "unable to delete/modify collation sequence due to active statements");
113902: return SQLITE_BUSY;
113903: }
113904: sqlite3ExpirePreparedStatements(db);
113905:
113906: /* If collation sequence pColl was created directly by a call to
113907: ** sqlite3_create_collation, and not generated by synthCollSeq(),
113908: ** then any copies made by synthCollSeq() need to be invalidated.
113909: ** Also, collation destructor - CollSeq.xDel() - function may need
113910: ** to be called.
113911: */
113912: if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
113913: CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
113914: int j;
113915: for(j=0; j<3; j++){
113916: CollSeq *p = &aColl[j];
113917: if( p->enc==pColl->enc ){
113918: if( p->xDel ){
113919: p->xDel(p->pUser);
113920: }
113921: p->xCmp = 0;
113922: }
113923: }
113924: }
113925: }
113926:
113927: pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
113928: if( pColl==0 ) return SQLITE_NOMEM;
113929: pColl->xCmp = xCompare;
113930: pColl->pUser = pCtx;
113931: pColl->xDel = xDel;
113932: pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED));
113933: sqlite3Error(db, SQLITE_OK, 0);
113934: return SQLITE_OK;
113935: }
113936:
113937:
113938: /*
113939: ** This array defines hard upper bounds on limit values. The
113940: ** initializer must be kept in sync with the SQLITE_LIMIT_*
113941: ** #defines in sqlite3.h.
113942: */
113943: static const int aHardLimit[] = {
113944: SQLITE_MAX_LENGTH,
113945: SQLITE_MAX_SQL_LENGTH,
113946: SQLITE_MAX_COLUMN,
113947: SQLITE_MAX_EXPR_DEPTH,
113948: SQLITE_MAX_COMPOUND_SELECT,
113949: SQLITE_MAX_VDBE_OP,
113950: SQLITE_MAX_FUNCTION_ARG,
113951: SQLITE_MAX_ATTACHED,
113952: SQLITE_MAX_LIKE_PATTERN_LENGTH,
113953: SQLITE_MAX_VARIABLE_NUMBER,
113954: SQLITE_MAX_TRIGGER_DEPTH,
113955: };
113956:
113957: /*
113958: ** Make sure the hard limits are set to reasonable values
113959: */
113960: #if SQLITE_MAX_LENGTH<100
113961: # error SQLITE_MAX_LENGTH must be at least 100
113962: #endif
113963: #if SQLITE_MAX_SQL_LENGTH<100
113964: # error SQLITE_MAX_SQL_LENGTH must be at least 100
113965: #endif
113966: #if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
113967: # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
113968: #endif
113969: #if SQLITE_MAX_COMPOUND_SELECT<2
113970: # error SQLITE_MAX_COMPOUND_SELECT must be at least 2
113971: #endif
113972: #if SQLITE_MAX_VDBE_OP<40
113973: # error SQLITE_MAX_VDBE_OP must be at least 40
113974: #endif
113975: #if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>1000
113976: # error SQLITE_MAX_FUNCTION_ARG must be between 0 and 1000
113977: #endif
113978: #if SQLITE_MAX_ATTACHED<0 || SQLITE_MAX_ATTACHED>62
113979: # error SQLITE_MAX_ATTACHED must be between 0 and 62
113980: #endif
113981: #if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
113982: # error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
113983: #endif
113984: #if SQLITE_MAX_COLUMN>32767
113985: # error SQLITE_MAX_COLUMN must not exceed 32767
113986: #endif
113987: #if SQLITE_MAX_TRIGGER_DEPTH<1
113988: # error SQLITE_MAX_TRIGGER_DEPTH must be at least 1
113989: #endif
113990:
113991:
113992: /*
113993: ** Change the value of a limit. Report the old value.
113994: ** If an invalid limit index is supplied, report -1.
113995: ** Make no changes but still report the old value if the
113996: ** new limit is negative.
113997: **
113998: ** A new lower limit does not shrink existing constructs.
113999: ** It merely prevents new constructs that exceed the limit
114000: ** from forming.
114001: */
114002: SQLITE_API int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
114003: int oldLimit;
114004:
114005:
114006: /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME
114007: ** there is a hard upper bound set at compile-time by a C preprocessor
114008: ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to
114009: ** "_MAX_".)
114010: */
114011: assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
114012: assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
114013: assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
114014: assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
114015: assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
114016: assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
114017: assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
114018: assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
114019: assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
114020: SQLITE_MAX_LIKE_PATTERN_LENGTH );
114021: assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
114022: assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
114023: assert( SQLITE_LIMIT_TRIGGER_DEPTH==(SQLITE_N_LIMIT-1) );
114024:
114025:
114026: if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
114027: return -1;
114028: }
114029: oldLimit = db->aLimit[limitId];
114030: if( newLimit>=0 ){ /* IMP: R-52476-28732 */
114031: if( newLimit>aHardLimit[limitId] ){
114032: newLimit = aHardLimit[limitId]; /* IMP: R-51463-25634 */
114033: }
114034: db->aLimit[limitId] = newLimit;
114035: }
114036: return oldLimit; /* IMP: R-53341-35419 */
114037: }
114038:
114039: /*
114040: ** This function is used to parse both URIs and non-URI filenames passed by the
114041: ** user to API functions sqlite3_open() or sqlite3_open_v2(), and for database
114042: ** URIs specified as part of ATTACH statements.
114043: **
114044: ** The first argument to this function is the name of the VFS to use (or
114045: ** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx"
114046: ** query parameter. The second argument contains the URI (or non-URI filename)
114047: ** itself. When this function is called the *pFlags variable should contain
114048: ** the default flags to open the database handle with. The value stored in
114049: ** *pFlags may be updated before returning if the URI filename contains
114050: ** "cache=xxx" or "mode=xxx" query parameters.
114051: **
114052: ** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
114053: ** the VFS that should be used to open the database file. *pzFile is set to
114054: ** point to a buffer containing the name of the file to open. It is the
114055: ** responsibility of the caller to eventually call sqlite3_free() to release
114056: ** this buffer.
114057: **
114058: ** If an error occurs, then an SQLite error code is returned and *pzErrMsg
114059: ** may be set to point to a buffer containing an English language error
114060: ** message. It is the responsibility of the caller to eventually release
114061: ** this buffer by calling sqlite3_free().
114062: */
114063: SQLITE_PRIVATE int sqlite3ParseUri(
114064: const char *zDefaultVfs, /* VFS to use if no "vfs=xxx" query option */
114065: const char *zUri, /* Nul-terminated URI to parse */
114066: unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */
114067: sqlite3_vfs **ppVfs, /* OUT: VFS to use */
114068: char **pzFile, /* OUT: Filename component of URI */
114069: char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
114070: ){
114071: int rc = SQLITE_OK;
114072: unsigned int flags = *pFlags;
114073: const char *zVfs = zDefaultVfs;
114074: char *zFile;
114075: char c;
114076: int nUri = sqlite3Strlen30(zUri);
114077:
114078: assert( *pzErrMsg==0 );
114079:
114080: if( ((flags & SQLITE_OPEN_URI) || sqlite3GlobalConfig.bOpenUri)
114081: && nUri>=5 && memcmp(zUri, "file:", 5)==0
114082: ){
114083: char *zOpt;
114084: int eState; /* Parser state when parsing URI */
114085: int iIn; /* Input character index */
114086: int iOut = 0; /* Output character index */
114087: int nByte = nUri+2; /* Bytes of space to allocate */
114088:
114089: /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen
114090: ** method that there may be extra parameters following the file-name. */
114091: flags |= SQLITE_OPEN_URI;
114092:
114093: for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
114094: zFile = sqlite3_malloc(nByte);
114095: if( !zFile ) return SQLITE_NOMEM;
114096:
114097: /* Discard the scheme and authority segments of the URI. */
114098: if( zUri[5]=='/' && zUri[6]=='/' ){
114099: iIn = 7;
114100: while( zUri[iIn] && zUri[iIn]!='/' ) iIn++;
114101:
114102: if( iIn!=7 && (iIn!=16 || memcmp("localhost", &zUri[7], 9)) ){
114103: *pzErrMsg = sqlite3_mprintf("invalid uri authority: %.*s",
114104: iIn-7, &zUri[7]);
114105: rc = SQLITE_ERROR;
114106: goto parse_uri_out;
114107: }
114108: }else{
114109: iIn = 5;
114110: }
114111:
114112: /* Copy the filename and any query parameters into the zFile buffer.
114113: ** Decode %HH escape codes along the way.
114114: **
114115: ** Within this loop, variable eState may be set to 0, 1 or 2, depending
114116: ** on the parsing context. As follows:
114117: **
114118: ** 0: Parsing file-name.
114119: ** 1: Parsing name section of a name=value query parameter.
114120: ** 2: Parsing value section of a name=value query parameter.
114121: */
114122: eState = 0;
114123: while( (c = zUri[iIn])!=0 && c!='#' ){
114124: iIn++;
114125: if( c=='%'
114126: && sqlite3Isxdigit(zUri[iIn])
114127: && sqlite3Isxdigit(zUri[iIn+1])
114128: ){
114129: int octet = (sqlite3HexToInt(zUri[iIn++]) << 4);
114130: octet += sqlite3HexToInt(zUri[iIn++]);
114131:
114132: assert( octet>=0 && octet<256 );
114133: if( octet==0 ){
114134: /* This branch is taken when "%00" appears within the URI. In this
114135: ** case we ignore all text in the remainder of the path, name or
114136: ** value currently being parsed. So ignore the current character
114137: ** and skip to the next "?", "=" or "&", as appropriate. */
114138: while( (c = zUri[iIn])!=0 && c!='#'
114139: && (eState!=0 || c!='?')
114140: && (eState!=1 || (c!='=' && c!='&'))
114141: && (eState!=2 || c!='&')
114142: ){
114143: iIn++;
114144: }
114145: continue;
114146: }
114147: c = octet;
114148: }else if( eState==1 && (c=='&' || c=='=') ){
114149: if( zFile[iOut-1]==0 ){
114150: /* An empty option name. Ignore this option altogether. */
114151: while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++;
114152: continue;
114153: }
114154: if( c=='&' ){
114155: zFile[iOut++] = '\0';
114156: }else{
114157: eState = 2;
114158: }
114159: c = 0;
114160: }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){
114161: c = 0;
114162: eState = 1;
114163: }
114164: zFile[iOut++] = c;
114165: }
114166: if( eState==1 ) zFile[iOut++] = '\0';
114167: zFile[iOut++] = '\0';
114168: zFile[iOut++] = '\0';
114169:
114170: /* Check if there were any options specified that should be interpreted
114171: ** here. Options that are interpreted here include "vfs" and those that
114172: ** correspond to flags that may be passed to the sqlite3_open_v2()
114173: ** method. */
114174: zOpt = &zFile[sqlite3Strlen30(zFile)+1];
114175: while( zOpt[0] ){
114176: int nOpt = sqlite3Strlen30(zOpt);
114177: char *zVal = &zOpt[nOpt+1];
114178: int nVal = sqlite3Strlen30(zVal);
114179:
114180: if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){
114181: zVfs = zVal;
114182: }else{
114183: struct OpenMode {
114184: const char *z;
114185: int mode;
114186: } *aMode = 0;
114187: char *zModeType = 0;
114188: int mask = 0;
114189: int limit = 0;
114190:
114191: if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){
114192: static struct OpenMode aCacheMode[] = {
114193: { "shared", SQLITE_OPEN_SHAREDCACHE },
114194: { "private", SQLITE_OPEN_PRIVATECACHE },
114195: { 0, 0 }
114196: };
114197:
114198: mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE;
114199: aMode = aCacheMode;
114200: limit = mask;
114201: zModeType = "cache";
114202: }
114203: if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
114204: static struct OpenMode aOpenMode[] = {
114205: { "ro", SQLITE_OPEN_READONLY },
114206: { "rw", SQLITE_OPEN_READWRITE },
114207: { "rwc", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE },
114208: { 0, 0 }
114209: };
114210:
114211: mask = SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
114212: aMode = aOpenMode;
114213: limit = mask & flags;
114214: zModeType = "access";
114215: }
114216:
114217: if( aMode ){
114218: int i;
114219: int mode = 0;
114220: for(i=0; aMode[i].z; i++){
114221: const char *z = aMode[i].z;
114222: if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){
114223: mode = aMode[i].mode;
114224: break;
114225: }
114226: }
114227: if( mode==0 ){
114228: *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal);
114229: rc = SQLITE_ERROR;
114230: goto parse_uri_out;
114231: }
114232: if( mode>limit ){
114233: *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
114234: zModeType, zVal);
114235: rc = SQLITE_PERM;
114236: goto parse_uri_out;
114237: }
114238: flags = (flags & ~mask) | mode;
114239: }
114240: }
114241:
114242: zOpt = &zVal[nVal+1];
114243: }
114244:
114245: }else{
114246: zFile = sqlite3_malloc(nUri+2);
114247: if( !zFile ) return SQLITE_NOMEM;
114248: memcpy(zFile, zUri, nUri);
114249: zFile[nUri] = '\0';
114250: zFile[nUri+1] = '\0';
114251: }
114252:
114253: *ppVfs = sqlite3_vfs_find(zVfs);
114254: if( *ppVfs==0 ){
114255: *pzErrMsg = sqlite3_mprintf("no such vfs: %s", zVfs);
114256: rc = SQLITE_ERROR;
114257: }
114258: parse_uri_out:
114259: if( rc!=SQLITE_OK ){
114260: sqlite3_free(zFile);
114261: zFile = 0;
114262: }
114263: *pFlags = flags;
114264: *pzFile = zFile;
114265: return rc;
114266: }
114267:
114268:
114269: /*
114270: ** This routine does the work of opening a database on behalf of
114271: ** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
114272: ** is UTF-8 encoded.
114273: */
114274: static int openDatabase(
114275: const char *zFilename, /* Database filename UTF-8 encoded */
114276: sqlite3 **ppDb, /* OUT: Returned database handle */
114277: unsigned int flags, /* Operational flags */
114278: const char *zVfs /* Name of the VFS to use */
114279: ){
114280: sqlite3 *db; /* Store allocated handle here */
114281: int rc; /* Return code */
114282: int isThreadsafe; /* True for threadsafe connections */
114283: char *zOpen = 0; /* Filename argument to pass to BtreeOpen() */
114284: char *zErrMsg = 0; /* Error message from sqlite3ParseUri() */
114285:
114286: *ppDb = 0;
114287: #ifndef SQLITE_OMIT_AUTOINIT
114288: rc = sqlite3_initialize();
114289: if( rc ) return rc;
114290: #endif
114291:
114292: /* Only allow sensible combinations of bits in the flags argument.
114293: ** Throw an error if any non-sense combination is used. If we
114294: ** do not block illegal combinations here, it could trigger
114295: ** assert() statements in deeper layers. Sensible combinations
114296: ** are:
114297: **
114298: ** 1: SQLITE_OPEN_READONLY
114299: ** 2: SQLITE_OPEN_READWRITE
114300: ** 6: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
114301: */
114302: assert( SQLITE_OPEN_READONLY == 0x01 );
114303: assert( SQLITE_OPEN_READWRITE == 0x02 );
114304: assert( SQLITE_OPEN_CREATE == 0x04 );
114305: testcase( (1<<(flags&7))==0x02 ); /* READONLY */
114306: testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
114307: testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
114308: if( ((1<<(flags&7)) & 0x46)==0 ) return SQLITE_MISUSE_BKPT;
114309:
114310: if( sqlite3GlobalConfig.bCoreMutex==0 ){
114311: isThreadsafe = 0;
114312: }else if( flags & SQLITE_OPEN_NOMUTEX ){
114313: isThreadsafe = 0;
114314: }else if( flags & SQLITE_OPEN_FULLMUTEX ){
114315: isThreadsafe = 1;
114316: }else{
114317: isThreadsafe = sqlite3GlobalConfig.bFullMutex;
114318: }
114319: if( flags & SQLITE_OPEN_PRIVATECACHE ){
114320: flags &= ~SQLITE_OPEN_SHAREDCACHE;
114321: }else if( sqlite3GlobalConfig.sharedCacheEnabled ){
114322: flags |= SQLITE_OPEN_SHAREDCACHE;
114323: }
114324:
114325: /* Remove harmful bits from the flags parameter
114326: **
114327: ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were
114328: ** dealt with in the previous code block. Besides these, the only
114329: ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
114330: ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE,
114331: ** SQLITE_OPEN_PRIVATECACHE, and some reserved bits. Silently mask
114332: ** off all other flags.
114333: */
114334: flags &= ~( SQLITE_OPEN_DELETEONCLOSE |
114335: SQLITE_OPEN_EXCLUSIVE |
114336: SQLITE_OPEN_MAIN_DB |
114337: SQLITE_OPEN_TEMP_DB |
114338: SQLITE_OPEN_TRANSIENT_DB |
114339: SQLITE_OPEN_MAIN_JOURNAL |
114340: SQLITE_OPEN_TEMP_JOURNAL |
114341: SQLITE_OPEN_SUBJOURNAL |
114342: SQLITE_OPEN_MASTER_JOURNAL |
114343: SQLITE_OPEN_NOMUTEX |
114344: SQLITE_OPEN_FULLMUTEX |
114345: SQLITE_OPEN_WAL
114346: );
114347:
114348: /* Allocate the sqlite data structure */
114349: db = sqlite3MallocZero( sizeof(sqlite3) );
114350: if( db==0 ) goto opendb_out;
114351: if( isThreadsafe ){
114352: db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
114353: if( db->mutex==0 ){
114354: sqlite3_free(db);
114355: db = 0;
114356: goto opendb_out;
114357: }
114358: }
114359: sqlite3_mutex_enter(db->mutex);
114360: db->errMask = 0xff;
114361: db->nDb = 2;
114362: db->magic = SQLITE_MAGIC_BUSY;
114363: db->aDb = db->aDbStatic;
114364:
114365: assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
114366: memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
114367: db->autoCommit = 1;
114368: db->nextAutovac = -1;
114369: db->nextPagesize = 0;
114370: db->flags |= SQLITE_ShortColNames | SQLITE_AutoIndex | SQLITE_EnableTrigger
114371: #if SQLITE_DEFAULT_FILE_FORMAT<4
114372: | SQLITE_LegacyFileFmt
114373: #endif
114374: #ifdef SQLITE_ENABLE_LOAD_EXTENSION
114375: | SQLITE_LoadExtension
114376: #endif
114377: #if SQLITE_DEFAULT_RECURSIVE_TRIGGERS
114378: | SQLITE_RecTriggers
114379: #endif
114380: #if defined(SQLITE_DEFAULT_FOREIGN_KEYS) && SQLITE_DEFAULT_FOREIGN_KEYS
114381: | SQLITE_ForeignKeys
114382: #endif
114383: ;
114384: sqlite3HashInit(&db->aCollSeq);
114385: #ifndef SQLITE_OMIT_VIRTUALTABLE
114386: sqlite3HashInit(&db->aModule);
114387: #endif
114388:
114389: /* Add the default collation sequence BINARY. BINARY works for both UTF-8
114390: ** and UTF-16, so add a version for each to avoid any unnecessary
114391: ** conversions. The only error that can occur here is a malloc() failure.
114392: */
114393: createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0);
114394: createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);
114395: createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);
114396: createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
114397: if( db->mallocFailed ){
114398: goto opendb_out;
114399: }
114400: db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 0);
114401: assert( db->pDfltColl!=0 );
114402:
114403: /* Also add a UTF-8 case-insensitive collation sequence. */
114404: createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
114405:
114406: /* Parse the filename/URI argument. */
114407: db->openFlags = flags;
114408: rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
114409: if( rc!=SQLITE_OK ){
114410: if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
114411: sqlite3Error(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
114412: sqlite3_free(zErrMsg);
114413: goto opendb_out;
114414: }
114415:
114416: /* Open the backend database driver */
114417: rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
114418: flags | SQLITE_OPEN_MAIN_DB);
114419: if( rc!=SQLITE_OK ){
114420: if( rc==SQLITE_IOERR_NOMEM ){
114421: rc = SQLITE_NOMEM;
114422: }
114423: sqlite3Error(db, rc, 0);
114424: goto opendb_out;
114425: }
114426: db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
114427: db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
114428:
114429:
114430: /* The default safety_level for the main database is 'full'; for the temp
114431: ** database it is 'NONE'. This matches the pager layer defaults.
114432: */
114433: db->aDb[0].zName = "main";
114434: db->aDb[0].safety_level = 3;
114435: db->aDb[1].zName = "temp";
114436: db->aDb[1].safety_level = 1;
114437:
114438: db->magic = SQLITE_MAGIC_OPEN;
114439: if( db->mallocFailed ){
114440: goto opendb_out;
114441: }
114442:
114443: /* Register all built-in functions, but do not attempt to read the
114444: ** database schema yet. This is delayed until the first time the database
114445: ** is accessed.
114446: */
114447: sqlite3Error(db, SQLITE_OK, 0);
114448: sqlite3RegisterBuiltinFunctions(db);
114449:
114450: /* Load automatic extensions - extensions that have been registered
114451: ** using the sqlite3_automatic_extension() API.
114452: */
114453: rc = sqlite3_errcode(db);
114454: if( rc==SQLITE_OK ){
114455: sqlite3AutoLoadExtensions(db);
114456: rc = sqlite3_errcode(db);
114457: if( rc!=SQLITE_OK ){
114458: goto opendb_out;
114459: }
114460: }
114461:
114462: #ifdef SQLITE_ENABLE_FTS1
114463: if( !db->mallocFailed ){
114464: extern int sqlite3Fts1Init(sqlite3*);
114465: rc = sqlite3Fts1Init(db);
114466: }
114467: #endif
114468:
114469: #ifdef SQLITE_ENABLE_FTS2
114470: if( !db->mallocFailed && rc==SQLITE_OK ){
114471: extern int sqlite3Fts2Init(sqlite3*);
114472: rc = sqlite3Fts2Init(db);
114473: }
114474: #endif
114475:
114476: #ifdef SQLITE_ENABLE_FTS3
114477: if( !db->mallocFailed && rc==SQLITE_OK ){
114478: rc = sqlite3Fts3Init(db);
114479: }
114480: #endif
114481:
114482: #ifdef SQLITE_ENABLE_ICU
114483: if( !db->mallocFailed && rc==SQLITE_OK ){
114484: rc = sqlite3IcuInit(db);
114485: }
114486: #endif
114487:
114488: #ifdef SQLITE_ENABLE_RTREE
114489: if( !db->mallocFailed && rc==SQLITE_OK){
114490: rc = sqlite3RtreeInit(db);
114491: }
114492: #endif
114493:
114494: sqlite3Error(db, rc, 0);
114495:
114496: /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
114497: ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
114498: ** mode. Doing nothing at all also makes NORMAL the default.
114499: */
114500: #ifdef SQLITE_DEFAULT_LOCKING_MODE
114501: db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
114502: sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
114503: SQLITE_DEFAULT_LOCKING_MODE);
114504: #endif
114505:
114506: /* Enable the lookaside-malloc subsystem */
114507: setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside,
114508: sqlite3GlobalConfig.nLookaside);
114509:
114510: sqlite3_wal_autocheckpoint(db, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT);
114511:
114512: opendb_out:
114513: sqlite3_free(zOpen);
114514: if( db ){
114515: assert( db->mutex!=0 || isThreadsafe==0 || sqlite3GlobalConfig.bFullMutex==0 );
114516: sqlite3_mutex_leave(db->mutex);
114517: }
114518: rc = sqlite3_errcode(db);
114519: assert( db!=0 || rc==SQLITE_NOMEM );
114520: if( rc==SQLITE_NOMEM ){
114521: sqlite3_close(db);
114522: db = 0;
114523: }else if( rc!=SQLITE_OK ){
114524: db->magic = SQLITE_MAGIC_SICK;
114525: }
114526: *ppDb = db;
114527: return sqlite3ApiExit(0, rc);
114528: }
114529:
114530: /*
114531: ** Open a new database handle.
114532: */
114533: SQLITE_API int sqlite3_open(
114534: const char *zFilename,
114535: sqlite3 **ppDb
114536: ){
114537: return openDatabase(zFilename, ppDb,
114538: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
114539: }
114540: SQLITE_API int sqlite3_open_v2(
114541: const char *filename, /* Database filename (UTF-8) */
114542: sqlite3 **ppDb, /* OUT: SQLite db handle */
114543: int flags, /* Flags */
114544: const char *zVfs /* Name of VFS module to use */
114545: ){
114546: return openDatabase(filename, ppDb, (unsigned int)flags, zVfs);
114547: }
114548:
114549: #ifndef SQLITE_OMIT_UTF16
114550: /*
114551: ** Open a new database handle.
114552: */
114553: SQLITE_API int sqlite3_open16(
114554: const void *zFilename,
114555: sqlite3 **ppDb
114556: ){
114557: char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
114558: sqlite3_value *pVal;
114559: int rc;
114560:
114561: assert( zFilename );
114562: assert( ppDb );
114563: *ppDb = 0;
114564: #ifndef SQLITE_OMIT_AUTOINIT
114565: rc = sqlite3_initialize();
114566: if( rc ) return rc;
114567: #endif
114568: pVal = sqlite3ValueNew(0);
114569: sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
114570: zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
114571: if( zFilename8 ){
114572: rc = openDatabase(zFilename8, ppDb,
114573: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
114574: assert( *ppDb || rc==SQLITE_NOMEM );
114575: if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
114576: ENC(*ppDb) = SQLITE_UTF16NATIVE;
114577: }
114578: }else{
114579: rc = SQLITE_NOMEM;
114580: }
114581: sqlite3ValueFree(pVal);
114582:
114583: return sqlite3ApiExit(0, rc);
114584: }
114585: #endif /* SQLITE_OMIT_UTF16 */
114586:
114587: /*
114588: ** Register a new collation sequence with the database handle db.
114589: */
114590: SQLITE_API int sqlite3_create_collation(
114591: sqlite3* db,
114592: const char *zName,
114593: int enc,
114594: void* pCtx,
114595: int(*xCompare)(void*,int,const void*,int,const void*)
114596: ){
114597: int rc;
114598: sqlite3_mutex_enter(db->mutex);
114599: assert( !db->mallocFailed );
114600: rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, 0);
114601: rc = sqlite3ApiExit(db, rc);
114602: sqlite3_mutex_leave(db->mutex);
114603: return rc;
114604: }
114605:
114606: /*
114607: ** Register a new collation sequence with the database handle db.
114608: */
114609: SQLITE_API int sqlite3_create_collation_v2(
114610: sqlite3* db,
114611: const char *zName,
114612: int enc,
114613: void* pCtx,
114614: int(*xCompare)(void*,int,const void*,int,const void*),
114615: void(*xDel)(void*)
114616: ){
114617: int rc;
114618: sqlite3_mutex_enter(db->mutex);
114619: assert( !db->mallocFailed );
114620: rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
114621: rc = sqlite3ApiExit(db, rc);
114622: sqlite3_mutex_leave(db->mutex);
114623: return rc;
114624: }
114625:
114626: #ifndef SQLITE_OMIT_UTF16
114627: /*
114628: ** Register a new collation sequence with the database handle db.
114629: */
114630: SQLITE_API int sqlite3_create_collation16(
114631: sqlite3* db,
114632: const void *zName,
114633: int enc,
114634: void* pCtx,
114635: int(*xCompare)(void*,int,const void*,int,const void*)
114636: ){
114637: int rc = SQLITE_OK;
114638: char *zName8;
114639: sqlite3_mutex_enter(db->mutex);
114640: assert( !db->mallocFailed );
114641: zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
114642: if( zName8 ){
114643: rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
114644: sqlite3DbFree(db, zName8);
114645: }
114646: rc = sqlite3ApiExit(db, rc);
114647: sqlite3_mutex_leave(db->mutex);
114648: return rc;
114649: }
114650: #endif /* SQLITE_OMIT_UTF16 */
114651:
114652: /*
114653: ** Register a collation sequence factory callback with the database handle
114654: ** db. Replace any previously installed collation sequence factory.
114655: */
114656: SQLITE_API int sqlite3_collation_needed(
114657: sqlite3 *db,
114658: void *pCollNeededArg,
114659: void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
114660: ){
114661: sqlite3_mutex_enter(db->mutex);
114662: db->xCollNeeded = xCollNeeded;
114663: db->xCollNeeded16 = 0;
114664: db->pCollNeededArg = pCollNeededArg;
114665: sqlite3_mutex_leave(db->mutex);
114666: return SQLITE_OK;
114667: }
114668:
114669: #ifndef SQLITE_OMIT_UTF16
114670: /*
114671: ** Register a collation sequence factory callback with the database handle
114672: ** db. Replace any previously installed collation sequence factory.
114673: */
114674: SQLITE_API int sqlite3_collation_needed16(
114675: sqlite3 *db,
114676: void *pCollNeededArg,
114677: void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
114678: ){
114679: sqlite3_mutex_enter(db->mutex);
114680: db->xCollNeeded = 0;
114681: db->xCollNeeded16 = xCollNeeded16;
114682: db->pCollNeededArg = pCollNeededArg;
114683: sqlite3_mutex_leave(db->mutex);
114684: return SQLITE_OK;
114685: }
114686: #endif /* SQLITE_OMIT_UTF16 */
114687:
114688: #ifndef SQLITE_OMIT_DEPRECATED
114689: /*
114690: ** This function is now an anachronism. It used to be used to recover from a
114691: ** malloc() failure, but SQLite now does this automatically.
114692: */
114693: SQLITE_API int sqlite3_global_recover(void){
114694: return SQLITE_OK;
114695: }
114696: #endif
114697:
114698: /*
114699: ** Test to see whether or not the database connection is in autocommit
114700: ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
114701: ** by default. Autocommit is disabled by a BEGIN statement and reenabled
114702: ** by the next COMMIT or ROLLBACK.
114703: **
114704: ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
114705: */
114706: SQLITE_API int sqlite3_get_autocommit(sqlite3 *db){
114707: return db->autoCommit;
114708: }
114709:
114710: /*
114711: ** The following routines are subtitutes for constants SQLITE_CORRUPT,
114712: ** SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_IOERR and possibly other error
114713: ** constants. They server two purposes:
114714: **
114715: ** 1. Serve as a convenient place to set a breakpoint in a debugger
114716: ** to detect when version error conditions occurs.
114717: **
114718: ** 2. Invoke sqlite3_log() to provide the source code location where
114719: ** a low-level error is first detected.
114720: */
114721: SQLITE_PRIVATE int sqlite3CorruptError(int lineno){
114722: testcase( sqlite3GlobalConfig.xLog!=0 );
114723: sqlite3_log(SQLITE_CORRUPT,
114724: "database corruption at line %d of [%.10s]",
114725: lineno, 20+sqlite3_sourceid());
114726: return SQLITE_CORRUPT;
114727: }
114728: SQLITE_PRIVATE int sqlite3MisuseError(int lineno){
114729: testcase( sqlite3GlobalConfig.xLog!=0 );
114730: sqlite3_log(SQLITE_MISUSE,
114731: "misuse at line %d of [%.10s]",
114732: lineno, 20+sqlite3_sourceid());
114733: return SQLITE_MISUSE;
114734: }
114735: SQLITE_PRIVATE int sqlite3CantopenError(int lineno){
114736: testcase( sqlite3GlobalConfig.xLog!=0 );
114737: sqlite3_log(SQLITE_CANTOPEN,
114738: "cannot open file at line %d of [%.10s]",
114739: lineno, 20+sqlite3_sourceid());
114740: return SQLITE_CANTOPEN;
114741: }
114742:
114743:
114744: #ifndef SQLITE_OMIT_DEPRECATED
114745: /*
114746: ** This is a convenience routine that makes sure that all thread-specific
114747: ** data for this thread has been deallocated.
114748: **
114749: ** SQLite no longer uses thread-specific data so this routine is now a
114750: ** no-op. It is retained for historical compatibility.
114751: */
114752: SQLITE_API void sqlite3_thread_cleanup(void){
114753: }
114754: #endif
114755:
114756: /*
114757: ** Return meta information about a specific column of a database table.
114758: ** See comment in sqlite3.h (sqlite.h.in) for details.
114759: */
114760: #ifdef SQLITE_ENABLE_COLUMN_METADATA
114761: SQLITE_API int sqlite3_table_column_metadata(
114762: sqlite3 *db, /* Connection handle */
114763: const char *zDbName, /* Database name or NULL */
114764: const char *zTableName, /* Table name */
114765: const char *zColumnName, /* Column name */
114766: char const **pzDataType, /* OUTPUT: Declared data type */
114767: char const **pzCollSeq, /* OUTPUT: Collation sequence name */
114768: int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
114769: int *pPrimaryKey, /* OUTPUT: True if column part of PK */
114770: int *pAutoinc /* OUTPUT: True if column is auto-increment */
114771: ){
114772: int rc;
114773: char *zErrMsg = 0;
114774: Table *pTab = 0;
114775: Column *pCol = 0;
114776: int iCol;
114777:
114778: char const *zDataType = 0;
114779: char const *zCollSeq = 0;
114780: int notnull = 0;
114781: int primarykey = 0;
114782: int autoinc = 0;
114783:
114784: /* Ensure the database schema has been loaded */
114785: sqlite3_mutex_enter(db->mutex);
114786: sqlite3BtreeEnterAll(db);
114787: rc = sqlite3Init(db, &zErrMsg);
114788: if( SQLITE_OK!=rc ){
114789: goto error_out;
114790: }
114791:
114792: /* Locate the table in question */
114793: pTab = sqlite3FindTable(db, zTableName, zDbName);
114794: if( !pTab || pTab->pSelect ){
114795: pTab = 0;
114796: goto error_out;
114797: }
114798:
114799: /* Find the column for which info is requested */
114800: if( sqlite3IsRowid(zColumnName) ){
114801: iCol = pTab->iPKey;
114802: if( iCol>=0 ){
114803: pCol = &pTab->aCol[iCol];
114804: }
114805: }else{
114806: for(iCol=0; iCol<pTab->nCol; iCol++){
114807: pCol = &pTab->aCol[iCol];
114808: if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
114809: break;
114810: }
114811: }
114812: if( iCol==pTab->nCol ){
114813: pTab = 0;
114814: goto error_out;
114815: }
114816: }
114817:
114818: /* The following block stores the meta information that will be returned
114819: ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
114820: ** and autoinc. At this point there are two possibilities:
114821: **
114822: ** 1. The specified column name was rowid", "oid" or "_rowid_"
114823: ** and there is no explicitly declared IPK column.
114824: **
114825: ** 2. The table is not a view and the column name identified an
114826: ** explicitly declared column. Copy meta information from *pCol.
114827: */
114828: if( pCol ){
114829: zDataType = pCol->zType;
114830: zCollSeq = pCol->zColl;
114831: notnull = pCol->notNull!=0;
114832: primarykey = pCol->isPrimKey!=0;
114833: autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
114834: }else{
114835: zDataType = "INTEGER";
114836: primarykey = 1;
114837: }
114838: if( !zCollSeq ){
114839: zCollSeq = "BINARY";
114840: }
114841:
114842: error_out:
114843: sqlite3BtreeLeaveAll(db);
114844:
114845: /* Whether the function call succeeded or failed, set the output parameters
114846: ** to whatever their local counterparts contain. If an error did occur,
114847: ** this has the effect of zeroing all output parameters.
114848: */
114849: if( pzDataType ) *pzDataType = zDataType;
114850: if( pzCollSeq ) *pzCollSeq = zCollSeq;
114851: if( pNotNull ) *pNotNull = notnull;
114852: if( pPrimaryKey ) *pPrimaryKey = primarykey;
114853: if( pAutoinc ) *pAutoinc = autoinc;
114854:
114855: if( SQLITE_OK==rc && !pTab ){
114856: sqlite3DbFree(db, zErrMsg);
114857: zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
114858: zColumnName);
114859: rc = SQLITE_ERROR;
114860: }
114861: sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
114862: sqlite3DbFree(db, zErrMsg);
114863: rc = sqlite3ApiExit(db, rc);
114864: sqlite3_mutex_leave(db->mutex);
114865: return rc;
114866: }
114867: #endif
114868:
114869: /*
114870: ** Sleep for a little while. Return the amount of time slept.
114871: */
114872: SQLITE_API int sqlite3_sleep(int ms){
114873: sqlite3_vfs *pVfs;
114874: int rc;
114875: pVfs = sqlite3_vfs_find(0);
114876: if( pVfs==0 ) return 0;
114877:
114878: /* This function works in milliseconds, but the underlying OsSleep()
114879: ** API uses microseconds. Hence the 1000's.
114880: */
114881: rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
114882: return rc;
114883: }
114884:
114885: /*
114886: ** Enable or disable the extended result codes.
114887: */
114888: SQLITE_API int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
114889: sqlite3_mutex_enter(db->mutex);
114890: db->errMask = onoff ? 0xffffffff : 0xff;
114891: sqlite3_mutex_leave(db->mutex);
114892: return SQLITE_OK;
114893: }
114894:
114895: /*
114896: ** Invoke the xFileControl method on a particular database.
114897: */
114898: SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
114899: int rc = SQLITE_ERROR;
114900: int iDb;
114901: sqlite3_mutex_enter(db->mutex);
114902: if( zDbName==0 ){
114903: iDb = 0;
114904: }else{
114905: for(iDb=0; iDb<db->nDb; iDb++){
114906: if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
114907: }
114908: }
114909: if( iDb<db->nDb ){
114910: Btree *pBtree = db->aDb[iDb].pBt;
114911: if( pBtree ){
114912: Pager *pPager;
114913: sqlite3_file *fd;
114914: sqlite3BtreeEnter(pBtree);
114915: pPager = sqlite3BtreePager(pBtree);
114916: assert( pPager!=0 );
114917: fd = sqlite3PagerFile(pPager);
114918: assert( fd!=0 );
114919: if( op==SQLITE_FCNTL_FILE_POINTER ){
114920: *(sqlite3_file**)pArg = fd;
114921: rc = SQLITE_OK;
114922: }else if( fd->pMethods ){
114923: rc = sqlite3OsFileControl(fd, op, pArg);
114924: }else{
114925: rc = SQLITE_NOTFOUND;
114926: }
114927: sqlite3BtreeLeave(pBtree);
114928: }
114929: }
114930: sqlite3_mutex_leave(db->mutex);
114931: return rc;
114932: }
114933:
114934: /*
114935: ** Interface to the testing logic.
114936: */
114937: SQLITE_API int sqlite3_test_control(int op, ...){
114938: int rc = 0;
114939: #ifndef SQLITE_OMIT_BUILTIN_TEST
114940: va_list ap;
114941: va_start(ap, op);
114942: switch( op ){
114943:
114944: /*
114945: ** Save the current state of the PRNG.
114946: */
114947: case SQLITE_TESTCTRL_PRNG_SAVE: {
114948: sqlite3PrngSaveState();
114949: break;
114950: }
114951:
114952: /*
114953: ** Restore the state of the PRNG to the last state saved using
114954: ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
114955: ** this verb acts like PRNG_RESET.
114956: */
114957: case SQLITE_TESTCTRL_PRNG_RESTORE: {
114958: sqlite3PrngRestoreState();
114959: break;
114960: }
114961:
114962: /*
114963: ** Reset the PRNG back to its uninitialized state. The next call
114964: ** to sqlite3_randomness() will reseed the PRNG using a single call
114965: ** to the xRandomness method of the default VFS.
114966: */
114967: case SQLITE_TESTCTRL_PRNG_RESET: {
114968: sqlite3PrngResetState();
114969: break;
114970: }
114971:
114972: /*
114973: ** sqlite3_test_control(BITVEC_TEST, size, program)
114974: **
114975: ** Run a test against a Bitvec object of size. The program argument
114976: ** is an array of integers that defines the test. Return -1 on a
114977: ** memory allocation error, 0 on success, or non-zero for an error.
114978: ** See the sqlite3BitvecBuiltinTest() for additional information.
114979: */
114980: case SQLITE_TESTCTRL_BITVEC_TEST: {
114981: int sz = va_arg(ap, int);
114982: int *aProg = va_arg(ap, int*);
114983: rc = sqlite3BitvecBuiltinTest(sz, aProg);
114984: break;
114985: }
114986:
114987: /*
114988: ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
114989: **
114990: ** Register hooks to call to indicate which malloc() failures
114991: ** are benign.
114992: */
114993: case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
114994: typedef void (*void_function)(void);
114995: void_function xBenignBegin;
114996: void_function xBenignEnd;
114997: xBenignBegin = va_arg(ap, void_function);
114998: xBenignEnd = va_arg(ap, void_function);
114999: sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
115000: break;
115001: }
115002:
115003: /*
115004: ** sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X)
115005: **
115006: ** Set the PENDING byte to the value in the argument, if X>0.
115007: ** Make no changes if X==0. Return the value of the pending byte
115008: ** as it existing before this routine was called.
115009: **
115010: ** IMPORTANT: Changing the PENDING byte from 0x40000000 results in
115011: ** an incompatible database file format. Changing the PENDING byte
115012: ** while any database connection is open results in undefined and
115013: ** dileterious behavior.
115014: */
115015: case SQLITE_TESTCTRL_PENDING_BYTE: {
115016: rc = PENDING_BYTE;
115017: #ifndef SQLITE_OMIT_WSD
115018: {
115019: unsigned int newVal = va_arg(ap, unsigned int);
115020: if( newVal ) sqlite3PendingByte = newVal;
115021: }
115022: #endif
115023: break;
115024: }
115025:
115026: /*
115027: ** sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X)
115028: **
115029: ** This action provides a run-time test to see whether or not
115030: ** assert() was enabled at compile-time. If X is true and assert()
115031: ** is enabled, then the return value is true. If X is true and
115032: ** assert() is disabled, then the return value is zero. If X is
115033: ** false and assert() is enabled, then the assertion fires and the
115034: ** process aborts. If X is false and assert() is disabled, then the
115035: ** return value is zero.
115036: */
115037: case SQLITE_TESTCTRL_ASSERT: {
115038: volatile int x = 0;
115039: assert( (x = va_arg(ap,int))!=0 );
115040: rc = x;
115041: break;
115042: }
115043:
115044:
115045: /*
115046: ** sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X)
115047: **
115048: ** This action provides a run-time test to see how the ALWAYS and
115049: ** NEVER macros were defined at compile-time.
115050: **
115051: ** The return value is ALWAYS(X).
115052: **
115053: ** The recommended test is X==2. If the return value is 2, that means
115054: ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
115055: ** default setting. If the return value is 1, then ALWAYS() is either
115056: ** hard-coded to true or else it asserts if its argument is false.
115057: ** The first behavior (hard-coded to true) is the case if
115058: ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second
115059: ** behavior (assert if the argument to ALWAYS() is false) is the case if
115060: ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled.
115061: **
115062: ** The run-time test procedure might look something like this:
115063: **
115064: ** if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){
115065: ** // ALWAYS() and NEVER() are no-op pass-through macros
115066: ** }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){
115067: ** // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
115068: ** }else{
115069: ** // ALWAYS(x) is a constant 1. NEVER(x) is a constant 0.
115070: ** }
115071: */
115072: case SQLITE_TESTCTRL_ALWAYS: {
115073: int x = va_arg(ap,int);
115074: rc = ALWAYS(x);
115075: break;
115076: }
115077:
115078: /* sqlite3_test_control(SQLITE_TESTCTRL_RESERVE, sqlite3 *db, int N)
115079: **
115080: ** Set the nReserve size to N for the main database on the database
115081: ** connection db.
115082: */
115083: case SQLITE_TESTCTRL_RESERVE: {
115084: sqlite3 *db = va_arg(ap, sqlite3*);
115085: int x = va_arg(ap,int);
115086: sqlite3_mutex_enter(db->mutex);
115087: sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
115088: sqlite3_mutex_leave(db->mutex);
115089: break;
115090: }
115091:
115092: /* sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
115093: **
115094: ** Enable or disable various optimizations for testing purposes. The
115095: ** argument N is a bitmask of optimizations to be disabled. For normal
115096: ** operation N should be 0. The idea is that a test program (like the
115097: ** SQL Logic Test or SLT test module) can run the same SQL multiple times
115098: ** with various optimizations disabled to verify that the same answer
115099: ** is obtained in every case.
115100: */
115101: case SQLITE_TESTCTRL_OPTIMIZATIONS: {
115102: sqlite3 *db = va_arg(ap, sqlite3*);
115103: int x = va_arg(ap,int);
115104: db->flags = (x & SQLITE_OptMask) | (db->flags & ~SQLITE_OptMask);
115105: break;
115106: }
115107:
115108: #ifdef SQLITE_N_KEYWORD
115109: /* sqlite3_test_control(SQLITE_TESTCTRL_ISKEYWORD, const char *zWord)
115110: **
115111: ** If zWord is a keyword recognized by the parser, then return the
115112: ** number of keywords. Or if zWord is not a keyword, return 0.
115113: **
115114: ** This test feature is only available in the amalgamation since
115115: ** the SQLITE_N_KEYWORD macro is not defined in this file if SQLite
115116: ** is built using separate source files.
115117: */
115118: case SQLITE_TESTCTRL_ISKEYWORD: {
115119: const char *zWord = va_arg(ap, const char*);
115120: int n = sqlite3Strlen30(zWord);
115121: rc = (sqlite3KeywordCode((u8*)zWord, n)!=TK_ID) ? SQLITE_N_KEYWORD : 0;
115122: break;
115123: }
115124: #endif
115125:
115126: /* sqlite3_test_control(SQLITE_TESTCTRL_SCRATCHMALLOC, sz, &pNew, pFree);
115127: **
115128: ** Pass pFree into sqlite3ScratchFree().
115129: ** If sz>0 then allocate a scratch buffer into pNew.
115130: */
115131: case SQLITE_TESTCTRL_SCRATCHMALLOC: {
115132: void *pFree, **ppNew;
115133: int sz;
115134: sz = va_arg(ap, int);
115135: ppNew = va_arg(ap, void**);
115136: pFree = va_arg(ap, void*);
115137: if( sz ) *ppNew = sqlite3ScratchMalloc(sz);
115138: sqlite3ScratchFree(pFree);
115139: break;
115140: }
115141:
115142: /* sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
115143: **
115144: ** If parameter onoff is non-zero, configure the wrappers so that all
115145: ** subsequent calls to localtime() and variants fail. If onoff is zero,
115146: ** undo this setting.
115147: */
115148: case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
115149: sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
115150: break;
115151: }
115152:
115153: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
115154: /* sqlite3_test_control(SQLITE_TESTCTRL_EXPLAIN_STMT,
115155: ** sqlite3_stmt*,const char**);
115156: **
115157: ** If compiled with SQLITE_ENABLE_TREE_EXPLAIN, each sqlite3_stmt holds
115158: ** a string that describes the optimized parse tree. This test-control
115159: ** returns a pointer to that string.
115160: */
115161: case SQLITE_TESTCTRL_EXPLAIN_STMT: {
115162: sqlite3_stmt *pStmt = va_arg(ap, sqlite3_stmt*);
115163: const char **pzRet = va_arg(ap, const char**);
115164: *pzRet = sqlite3VdbeExplanation((Vdbe*)pStmt);
115165: break;
115166: }
115167: #endif
115168:
115169: }
115170: va_end(ap);
115171: #endif /* SQLITE_OMIT_BUILTIN_TEST */
115172: return rc;
115173: }
115174:
115175: /*
115176: ** This is a utility routine, useful to VFS implementations, that checks
115177: ** to see if a database file was a URI that contained a specific query
115178: ** parameter, and if so obtains the value of the query parameter.
115179: **
115180: ** The zFilename argument is the filename pointer passed into the xOpen()
115181: ** method of a VFS implementation. The zParam argument is the name of the
115182: ** query parameter we seek. This routine returns the value of the zParam
115183: ** parameter if it exists. If the parameter does not exist, this routine
115184: ** returns a NULL pointer.
115185: */
115186: SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam){
115187: if( zFilename==0 ) return 0;
115188: zFilename += sqlite3Strlen30(zFilename) + 1;
115189: while( zFilename[0] ){
115190: int x = strcmp(zFilename, zParam);
115191: zFilename += sqlite3Strlen30(zFilename) + 1;
115192: if( x==0 ) return zFilename;
115193: zFilename += sqlite3Strlen30(zFilename) + 1;
115194: }
115195: return 0;
115196: }
115197:
115198: /*
115199: ** Return a boolean value for a query parameter.
115200: */
115201: SQLITE_API int sqlite3_uri_boolean(const char *zFilename, const char *zParam, int bDflt){
115202: const char *z = sqlite3_uri_parameter(zFilename, zParam);
115203: return z ? sqlite3GetBoolean(z) : (bDflt!=0);
115204: }
115205:
115206: /*
115207: ** Return a 64-bit integer value for a query parameter.
115208: */
115209: SQLITE_API sqlite3_int64 sqlite3_uri_int64(
115210: const char *zFilename, /* Filename as passed to xOpen */
115211: const char *zParam, /* URI parameter sought */
115212: sqlite3_int64 bDflt /* return if parameter is missing */
115213: ){
115214: const char *z = sqlite3_uri_parameter(zFilename, zParam);
115215: sqlite3_int64 v;
115216: if( z && sqlite3Atoi64(z, &v, sqlite3Strlen30(z), SQLITE_UTF8)==SQLITE_OK ){
115217: bDflt = v;
115218: }
115219: return bDflt;
115220: }
115221:
115222: /*
115223: ** Return the filename of the database associated with a database
115224: ** connection.
115225: */
115226: SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName){
115227: int i;
115228: for(i=0; i<db->nDb; i++){
115229: if( db->aDb[i].pBt && sqlite3StrICmp(zDbName, db->aDb[i].zName)==0 ){
115230: return sqlite3BtreeGetFilename(db->aDb[i].pBt);
115231: }
115232: }
115233: return 0;
115234: }
115235:
115236: /************** End of main.c ************************************************/
115237: /************** Begin file notify.c ******************************************/
115238: /*
115239: ** 2009 March 3
115240: **
115241: ** The author disclaims copyright to this source code. In place of
115242: ** a legal notice, here is a blessing:
115243: **
115244: ** May you do good and not evil.
115245: ** May you find forgiveness for yourself and forgive others.
115246: ** May you share freely, never taking more than you give.
115247: **
115248: *************************************************************************
115249: **
115250: ** This file contains the implementation of the sqlite3_unlock_notify()
115251: ** API method and its associated functionality.
115252: */
115253:
115254: /* Omit this entire file if SQLITE_ENABLE_UNLOCK_NOTIFY is not defined. */
115255: #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
115256:
115257: /*
115258: ** Public interfaces:
115259: **
115260: ** sqlite3ConnectionBlocked()
115261: ** sqlite3ConnectionUnlocked()
115262: ** sqlite3ConnectionClosed()
115263: ** sqlite3_unlock_notify()
115264: */
115265:
115266: #define assertMutexHeld() \
115267: assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) )
115268:
115269: /*
115270: ** Head of a linked list of all sqlite3 objects created by this process
115271: ** for which either sqlite3.pBlockingConnection or sqlite3.pUnlockConnection
115272: ** is not NULL. This variable may only accessed while the STATIC_MASTER
115273: ** mutex is held.
115274: */
115275: static sqlite3 *SQLITE_WSD sqlite3BlockedList = 0;
115276:
115277: #ifndef NDEBUG
115278: /*
115279: ** This function is a complex assert() that verifies the following
115280: ** properties of the blocked connections list:
115281: **
115282: ** 1) Each entry in the list has a non-NULL value for either
115283: ** pUnlockConnection or pBlockingConnection, or both.
115284: **
115285: ** 2) All entries in the list that share a common value for
115286: ** xUnlockNotify are grouped together.
115287: **
115288: ** 3) If the argument db is not NULL, then none of the entries in the
115289: ** blocked connections list have pUnlockConnection or pBlockingConnection
115290: ** set to db. This is used when closing connection db.
115291: */
115292: static void checkListProperties(sqlite3 *db){
115293: sqlite3 *p;
115294: for(p=sqlite3BlockedList; p; p=p->pNextBlocked){
115295: int seen = 0;
115296: sqlite3 *p2;
115297:
115298: /* Verify property (1) */
115299: assert( p->pUnlockConnection || p->pBlockingConnection );
115300:
115301: /* Verify property (2) */
115302: for(p2=sqlite3BlockedList; p2!=p; p2=p2->pNextBlocked){
115303: if( p2->xUnlockNotify==p->xUnlockNotify ) seen = 1;
115304: assert( p2->xUnlockNotify==p->xUnlockNotify || !seen );
115305: assert( db==0 || p->pUnlockConnection!=db );
115306: assert( db==0 || p->pBlockingConnection!=db );
115307: }
115308: }
115309: }
115310: #else
115311: # define checkListProperties(x)
115312: #endif
115313:
115314: /*
115315: ** Remove connection db from the blocked connections list. If connection
115316: ** db is not currently a part of the list, this function is a no-op.
115317: */
115318: static void removeFromBlockedList(sqlite3 *db){
115319: sqlite3 **pp;
115320: assertMutexHeld();
115321: for(pp=&sqlite3BlockedList; *pp; pp = &(*pp)->pNextBlocked){
115322: if( *pp==db ){
115323: *pp = (*pp)->pNextBlocked;
115324: break;
115325: }
115326: }
115327: }
115328:
115329: /*
115330: ** Add connection db to the blocked connections list. It is assumed
115331: ** that it is not already a part of the list.
115332: */
115333: static void addToBlockedList(sqlite3 *db){
115334: sqlite3 **pp;
115335: assertMutexHeld();
115336: for(
115337: pp=&sqlite3BlockedList;
115338: *pp && (*pp)->xUnlockNotify!=db->xUnlockNotify;
115339: pp=&(*pp)->pNextBlocked
115340: );
115341: db->pNextBlocked = *pp;
115342: *pp = db;
115343: }
115344:
115345: /*
115346: ** Obtain the STATIC_MASTER mutex.
115347: */
115348: static void enterMutex(void){
115349: sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
115350: checkListProperties(0);
115351: }
115352:
115353: /*
115354: ** Release the STATIC_MASTER mutex.
115355: */
115356: static void leaveMutex(void){
115357: assertMutexHeld();
115358: checkListProperties(0);
115359: sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
115360: }
115361:
115362: /*
115363: ** Register an unlock-notify callback.
115364: **
115365: ** This is called after connection "db" has attempted some operation
115366: ** but has received an SQLITE_LOCKED error because another connection
115367: ** (call it pOther) in the same process was busy using the same shared
115368: ** cache. pOther is found by looking at db->pBlockingConnection.
115369: **
115370: ** If there is no blocking connection, the callback is invoked immediately,
115371: ** before this routine returns.
115372: **
115373: ** If pOther is already blocked on db, then report SQLITE_LOCKED, to indicate
115374: ** a deadlock.
115375: **
115376: ** Otherwise, make arrangements to invoke xNotify when pOther drops
115377: ** its locks.
115378: **
115379: ** Each call to this routine overrides any prior callbacks registered
115380: ** on the same "db". If xNotify==0 then any prior callbacks are immediately
115381: ** cancelled.
115382: */
115383: SQLITE_API int sqlite3_unlock_notify(
115384: sqlite3 *db,
115385: void (*xNotify)(void **, int),
115386: void *pArg
115387: ){
115388: int rc = SQLITE_OK;
115389:
115390: sqlite3_mutex_enter(db->mutex);
115391: enterMutex();
115392:
115393: if( xNotify==0 ){
115394: removeFromBlockedList(db);
115395: db->pBlockingConnection = 0;
115396: db->pUnlockConnection = 0;
115397: db->xUnlockNotify = 0;
115398: db->pUnlockArg = 0;
115399: }else if( 0==db->pBlockingConnection ){
115400: /* The blocking transaction has been concluded. Or there never was a
115401: ** blocking transaction. In either case, invoke the notify callback
115402: ** immediately.
115403: */
115404: xNotify(&pArg, 1);
115405: }else{
115406: sqlite3 *p;
115407:
115408: for(p=db->pBlockingConnection; p && p!=db; p=p->pUnlockConnection){}
115409: if( p ){
115410: rc = SQLITE_LOCKED; /* Deadlock detected. */
115411: }else{
115412: db->pUnlockConnection = db->pBlockingConnection;
115413: db->xUnlockNotify = xNotify;
115414: db->pUnlockArg = pArg;
115415: removeFromBlockedList(db);
115416: addToBlockedList(db);
115417: }
115418: }
115419:
115420: leaveMutex();
115421: assert( !db->mallocFailed );
115422: sqlite3Error(db, rc, (rc?"database is deadlocked":0));
115423: sqlite3_mutex_leave(db->mutex);
115424: return rc;
115425: }
115426:
115427: /*
115428: ** This function is called while stepping or preparing a statement
115429: ** associated with connection db. The operation will return SQLITE_LOCKED
115430: ** to the user because it requires a lock that will not be available
115431: ** until connection pBlocker concludes its current transaction.
115432: */
115433: SQLITE_PRIVATE void sqlite3ConnectionBlocked(sqlite3 *db, sqlite3 *pBlocker){
115434: enterMutex();
115435: if( db->pBlockingConnection==0 && db->pUnlockConnection==0 ){
115436: addToBlockedList(db);
115437: }
115438: db->pBlockingConnection = pBlocker;
115439: leaveMutex();
115440: }
115441:
115442: /*
115443: ** This function is called when
115444: ** the transaction opened by database db has just finished. Locks held
115445: ** by database connection db have been released.
115446: **
115447: ** This function loops through each entry in the blocked connections
115448: ** list and does the following:
115449: **
115450: ** 1) If the sqlite3.pBlockingConnection member of a list entry is
115451: ** set to db, then set pBlockingConnection=0.
115452: **
115453: ** 2) If the sqlite3.pUnlockConnection member of a list entry is
115454: ** set to db, then invoke the configured unlock-notify callback and
115455: ** set pUnlockConnection=0.
115456: **
115457: ** 3) If the two steps above mean that pBlockingConnection==0 and
115458: ** pUnlockConnection==0, remove the entry from the blocked connections
115459: ** list.
115460: */
115461: SQLITE_PRIVATE void sqlite3ConnectionUnlocked(sqlite3 *db){
115462: void (*xUnlockNotify)(void **, int) = 0; /* Unlock-notify cb to invoke */
115463: int nArg = 0; /* Number of entries in aArg[] */
115464: sqlite3 **pp; /* Iterator variable */
115465: void **aArg; /* Arguments to the unlock callback */
115466: void **aDyn = 0; /* Dynamically allocated space for aArg[] */
115467: void *aStatic[16]; /* Starter space for aArg[]. No malloc required */
115468:
115469: aArg = aStatic;
115470: enterMutex(); /* Enter STATIC_MASTER mutex */
115471:
115472: /* This loop runs once for each entry in the blocked-connections list. */
115473: for(pp=&sqlite3BlockedList; *pp; /* no-op */ ){
115474: sqlite3 *p = *pp;
115475:
115476: /* Step 1. */
115477: if( p->pBlockingConnection==db ){
115478: p->pBlockingConnection = 0;
115479: }
115480:
115481: /* Step 2. */
115482: if( p->pUnlockConnection==db ){
115483: assert( p->xUnlockNotify );
115484: if( p->xUnlockNotify!=xUnlockNotify && nArg!=0 ){
115485: xUnlockNotify(aArg, nArg);
115486: nArg = 0;
115487: }
115488:
115489: sqlite3BeginBenignMalloc();
115490: assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) );
115491: assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn );
115492: if( (!aDyn && nArg==(int)ArraySize(aStatic))
115493: || (aDyn && nArg==(int)(sqlite3MallocSize(aDyn)/sizeof(void*)))
115494: ){
115495: /* The aArg[] array needs to grow. */
115496: void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
115497: if( pNew ){
115498: memcpy(pNew, aArg, nArg*sizeof(void *));
115499: sqlite3_free(aDyn);
115500: aDyn = aArg = pNew;
115501: }else{
115502: /* This occurs when the array of context pointers that need to
115503: ** be passed to the unlock-notify callback is larger than the
115504: ** aStatic[] array allocated on the stack and the attempt to
115505: ** allocate a larger array from the heap has failed.
115506: **
115507: ** This is a difficult situation to handle. Returning an error
115508: ** code to the caller is insufficient, as even if an error code
115509: ** is returned the transaction on connection db will still be
115510: ** closed and the unlock-notify callbacks on blocked connections
115511: ** will go unissued. This might cause the application to wait
115512: ** indefinitely for an unlock-notify callback that will never
115513: ** arrive.
115514: **
115515: ** Instead, invoke the unlock-notify callback with the context
115516: ** array already accumulated. We can then clear the array and
115517: ** begin accumulating any further context pointers without
115518: ** requiring any dynamic allocation. This is sub-optimal because
115519: ** it means that instead of one callback with a large array of
115520: ** context pointers the application will receive two or more
115521: ** callbacks with smaller arrays of context pointers, which will
115522: ** reduce the applications ability to prioritize multiple
115523: ** connections. But it is the best that can be done under the
115524: ** circumstances.
115525: */
115526: xUnlockNotify(aArg, nArg);
115527: nArg = 0;
115528: }
115529: }
115530: sqlite3EndBenignMalloc();
115531:
115532: aArg[nArg++] = p->pUnlockArg;
115533: xUnlockNotify = p->xUnlockNotify;
115534: p->pUnlockConnection = 0;
115535: p->xUnlockNotify = 0;
115536: p->pUnlockArg = 0;
115537: }
115538:
115539: /* Step 3. */
115540: if( p->pBlockingConnection==0 && p->pUnlockConnection==0 ){
115541: /* Remove connection p from the blocked connections list. */
115542: *pp = p->pNextBlocked;
115543: p->pNextBlocked = 0;
115544: }else{
115545: pp = &p->pNextBlocked;
115546: }
115547: }
115548:
115549: if( nArg!=0 ){
115550: xUnlockNotify(aArg, nArg);
115551: }
115552: sqlite3_free(aDyn);
115553: leaveMutex(); /* Leave STATIC_MASTER mutex */
115554: }
115555:
115556: /*
115557: ** This is called when the database connection passed as an argument is
115558: ** being closed. The connection is removed from the blocked list.
115559: */
115560: SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db){
115561: sqlite3ConnectionUnlocked(db);
115562: enterMutex();
115563: removeFromBlockedList(db);
115564: checkListProperties(db);
115565: leaveMutex();
115566: }
115567: #endif
115568:
115569: /************** End of notify.c **********************************************/
115570: /************** Begin file fts3.c ********************************************/
115571: /*
115572: ** 2006 Oct 10
115573: **
115574: ** The author disclaims copyright to this source code. In place of
115575: ** a legal notice, here is a blessing:
115576: **
115577: ** May you do good and not evil.
115578: ** May you find forgiveness for yourself and forgive others.
115579: ** May you share freely, never taking more than you give.
115580: **
115581: ******************************************************************************
115582: **
115583: ** This is an SQLite module implementing full-text search.
115584: */
115585:
115586: /*
115587: ** The code in this file is only compiled if:
115588: **
115589: ** * The FTS3 module is being built as an extension
115590: ** (in which case SQLITE_CORE is not defined), or
115591: **
115592: ** * The FTS3 module is being built into the core of
115593: ** SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
115594: */
115595:
115596: /* The full-text index is stored in a series of b+tree (-like)
115597: ** structures called segments which map terms to doclists. The
115598: ** structures are like b+trees in layout, but are constructed from the
115599: ** bottom up in optimal fashion and are not updatable. Since trees
115600: ** are built from the bottom up, things will be described from the
115601: ** bottom up.
115602: **
115603: **
115604: **** Varints ****
115605: ** The basic unit of encoding is a variable-length integer called a
115606: ** varint. We encode variable-length integers in little-endian order
115607: ** using seven bits * per byte as follows:
115608: **
115609: ** KEY:
115610: ** A = 0xxxxxxx 7 bits of data and one flag bit
115611: ** B = 1xxxxxxx 7 bits of data and one flag bit
115612: **
115613: ** 7 bits - A
115614: ** 14 bits - BA
115615: ** 21 bits - BBA
115616: ** and so on.
115617: **
115618: ** This is similar in concept to how sqlite encodes "varints" but
115619: ** the encoding is not the same. SQLite varints are big-endian
115620: ** are are limited to 9 bytes in length whereas FTS3 varints are
115621: ** little-endian and can be up to 10 bytes in length (in theory).
115622: **
115623: ** Example encodings:
115624: **
115625: ** 1: 0x01
115626: ** 127: 0x7f
115627: ** 128: 0x81 0x00
115628: **
115629: **
115630: **** Document lists ****
115631: ** A doclist (document list) holds a docid-sorted list of hits for a
115632: ** given term. Doclists hold docids and associated token positions.
115633: ** A docid is the unique integer identifier for a single document.
115634: ** A position is the index of a word within the document. The first
115635: ** word of the document has a position of 0.
115636: **
115637: ** FTS3 used to optionally store character offsets using a compile-time
115638: ** option. But that functionality is no longer supported.
115639: **
115640: ** A doclist is stored like this:
115641: **
115642: ** array {
115643: ** varint docid;
115644: ** array { (position list for column 0)
115645: ** varint position; (2 more than the delta from previous position)
115646: ** }
115647: ** array {
115648: ** varint POS_COLUMN; (marks start of position list for new column)
115649: ** varint column; (index of new column)
115650: ** array {
115651: ** varint position; (2 more than the delta from previous position)
115652: ** }
115653: ** }
115654: ** varint POS_END; (marks end of positions for this document.
115655: ** }
115656: **
115657: ** Here, array { X } means zero or more occurrences of X, adjacent in
115658: ** memory. A "position" is an index of a token in the token stream
115659: ** generated by the tokenizer. Note that POS_END and POS_COLUMN occur
115660: ** in the same logical place as the position element, and act as sentinals
115661: ** ending a position list array. POS_END is 0. POS_COLUMN is 1.
115662: ** The positions numbers are not stored literally but rather as two more
115663: ** than the difference from the prior position, or the just the position plus
115664: ** 2 for the first position. Example:
115665: **
115666: ** label: A B C D E F G H I J K
115667: ** value: 123 5 9 1 1 14 35 0 234 72 0
115668: **
115669: ** The 123 value is the first docid. For column zero in this document
115670: ** there are two matches at positions 3 and 10 (5-2 and 9-2+3). The 1
115671: ** at D signals the start of a new column; the 1 at E indicates that the
115672: ** new column is column number 1. There are two positions at 12 and 45
115673: ** (14-2 and 35-2+12). The 0 at H indicate the end-of-document. The
115674: ** 234 at I is the next docid. It has one position 72 (72-2) and then
115675: ** terminates with the 0 at K.
115676: **
115677: ** A "position-list" is the list of positions for multiple columns for
115678: ** a single docid. A "column-list" is the set of positions for a single
115679: ** column. Hence, a position-list consists of one or more column-lists,
115680: ** a document record consists of a docid followed by a position-list and
115681: ** a doclist consists of one or more document records.
115682: **
115683: ** A bare doclist omits the position information, becoming an
115684: ** array of varint-encoded docids.
115685: **
115686: **** Segment leaf nodes ****
115687: ** Segment leaf nodes store terms and doclists, ordered by term. Leaf
115688: ** nodes are written using LeafWriter, and read using LeafReader (to
115689: ** iterate through a single leaf node's data) and LeavesReader (to
115690: ** iterate through a segment's entire leaf layer). Leaf nodes have
115691: ** the format:
115692: **
115693: ** varint iHeight; (height from leaf level, always 0)
115694: ** varint nTerm; (length of first term)
115695: ** char pTerm[nTerm]; (content of first term)
115696: ** varint nDoclist; (length of term's associated doclist)
115697: ** char pDoclist[nDoclist]; (content of doclist)
115698: ** array {
115699: ** (further terms are delta-encoded)
115700: ** varint nPrefix; (length of prefix shared with previous term)
115701: ** varint nSuffix; (length of unshared suffix)
115702: ** char pTermSuffix[nSuffix];(unshared suffix of next term)
115703: ** varint nDoclist; (length of term's associated doclist)
115704: ** char pDoclist[nDoclist]; (content of doclist)
115705: ** }
115706: **
115707: ** Here, array { X } means zero or more occurrences of X, adjacent in
115708: ** memory.
115709: **
115710: ** Leaf nodes are broken into blocks which are stored contiguously in
115711: ** the %_segments table in sorted order. This means that when the end
115712: ** of a node is reached, the next term is in the node with the next
115713: ** greater node id.
115714: **
115715: ** New data is spilled to a new leaf node when the current node
115716: ** exceeds LEAF_MAX bytes (default 2048). New data which itself is
115717: ** larger than STANDALONE_MIN (default 1024) is placed in a standalone
115718: ** node (a leaf node with a single term and doclist). The goal of
115719: ** these settings is to pack together groups of small doclists while
115720: ** making it efficient to directly access large doclists. The
115721: ** assumption is that large doclists represent terms which are more
115722: ** likely to be query targets.
115723: **
115724: ** TODO(shess) It may be useful for blocking decisions to be more
115725: ** dynamic. For instance, it may make more sense to have a 2.5k leaf
115726: ** node rather than splitting into 2k and .5k nodes. My intuition is
115727: ** that this might extend through 2x or 4x the pagesize.
115728: **
115729: **
115730: **** Segment interior nodes ****
115731: ** Segment interior nodes store blockids for subtree nodes and terms
115732: ** to describe what data is stored by the each subtree. Interior
115733: ** nodes are written using InteriorWriter, and read using
115734: ** InteriorReader. InteriorWriters are created as needed when
115735: ** SegmentWriter creates new leaf nodes, or when an interior node
115736: ** itself grows too big and must be split. The format of interior
115737: ** nodes:
115738: **
115739: ** varint iHeight; (height from leaf level, always >0)
115740: ** varint iBlockid; (block id of node's leftmost subtree)
115741: ** optional {
115742: ** varint nTerm; (length of first term)
115743: ** char pTerm[nTerm]; (content of first term)
115744: ** array {
115745: ** (further terms are delta-encoded)
115746: ** varint nPrefix; (length of shared prefix with previous term)
115747: ** varint nSuffix; (length of unshared suffix)
115748: ** char pTermSuffix[nSuffix]; (unshared suffix of next term)
115749: ** }
115750: ** }
115751: **
115752: ** Here, optional { X } means an optional element, while array { X }
115753: ** means zero or more occurrences of X, adjacent in memory.
115754: **
115755: ** An interior node encodes n terms separating n+1 subtrees. The
115756: ** subtree blocks are contiguous, so only the first subtree's blockid
115757: ** is encoded. The subtree at iBlockid will contain all terms less
115758: ** than the first term encoded (or all terms if no term is encoded).
115759: ** Otherwise, for terms greater than or equal to pTerm[i] but less
115760: ** than pTerm[i+1], the subtree for that term will be rooted at
115761: ** iBlockid+i. Interior nodes only store enough term data to
115762: ** distinguish adjacent children (if the rightmost term of the left
115763: ** child is "something", and the leftmost term of the right child is
115764: ** "wicked", only "w" is stored).
115765: **
115766: ** New data is spilled to a new interior node at the same height when
115767: ** the current node exceeds INTERIOR_MAX bytes (default 2048).
115768: ** INTERIOR_MIN_TERMS (default 7) keeps large terms from monopolizing
115769: ** interior nodes and making the tree too skinny. The interior nodes
115770: ** at a given height are naturally tracked by interior nodes at
115771: ** height+1, and so on.
115772: **
115773: **
115774: **** Segment directory ****
115775: ** The segment directory in table %_segdir stores meta-information for
115776: ** merging and deleting segments, and also the root node of the
115777: ** segment's tree.
115778: **
115779: ** The root node is the top node of the segment's tree after encoding
115780: ** the entire segment, restricted to ROOT_MAX bytes (default 1024).
115781: ** This could be either a leaf node or an interior node. If the top
115782: ** node requires more than ROOT_MAX bytes, it is flushed to %_segments
115783: ** and a new root interior node is generated (which should always fit
115784: ** within ROOT_MAX because it only needs space for 2 varints, the
115785: ** height and the blockid of the previous root).
115786: **
115787: ** The meta-information in the segment directory is:
115788: ** level - segment level (see below)
115789: ** idx - index within level
115790: ** - (level,idx uniquely identify a segment)
115791: ** start_block - first leaf node
115792: ** leaves_end_block - last leaf node
115793: ** end_block - last block (including interior nodes)
115794: ** root - contents of root node
115795: **
115796: ** If the root node is a leaf node, then start_block,
115797: ** leaves_end_block, and end_block are all 0.
115798: **
115799: **
115800: **** Segment merging ****
115801: ** To amortize update costs, segments are grouped into levels and
115802: ** merged in batches. Each increase in level represents exponentially
115803: ** more documents.
115804: **
115805: ** New documents (actually, document updates) are tokenized and
115806: ** written individually (using LeafWriter) to a level 0 segment, with
115807: ** incrementing idx. When idx reaches MERGE_COUNT (default 16), all
115808: ** level 0 segments are merged into a single level 1 segment. Level 1
115809: ** is populated like level 0, and eventually MERGE_COUNT level 1
115810: ** segments are merged to a single level 2 segment (representing
115811: ** MERGE_COUNT^2 updates), and so on.
115812: **
115813: ** A segment merge traverses all segments at a given level in
115814: ** parallel, performing a straightforward sorted merge. Since segment
115815: ** leaf nodes are written in to the %_segments table in order, this
115816: ** merge traverses the underlying sqlite disk structures efficiently.
115817: ** After the merge, all segment blocks from the merged level are
115818: ** deleted.
115819: **
115820: ** MERGE_COUNT controls how often we merge segments. 16 seems to be
115821: ** somewhat of a sweet spot for insertion performance. 32 and 64 show
115822: ** very similar performance numbers to 16 on insertion, though they're
115823: ** a tiny bit slower (perhaps due to more overhead in merge-time
115824: ** sorting). 8 is about 20% slower than 16, 4 about 50% slower than
115825: ** 16, 2 about 66% slower than 16.
115826: **
115827: ** At query time, high MERGE_COUNT increases the number of segments
115828: ** which need to be scanned and merged. For instance, with 100k docs
115829: ** inserted:
115830: **
115831: ** MERGE_COUNT segments
115832: ** 16 25
115833: ** 8 12
115834: ** 4 10
115835: ** 2 6
115836: **
115837: ** This appears to have only a moderate impact on queries for very
115838: ** frequent terms (which are somewhat dominated by segment merge
115839: ** costs), and infrequent and non-existent terms still seem to be fast
115840: ** even with many segments.
115841: **
115842: ** TODO(shess) That said, it would be nice to have a better query-side
115843: ** argument for MERGE_COUNT of 16. Also, it is possible/likely that
115844: ** optimizations to things like doclist merging will swing the sweet
115845: ** spot around.
115846: **
115847: **
115848: **
115849: **** Handling of deletions and updates ****
115850: ** Since we're using a segmented structure, with no docid-oriented
115851: ** index into the term index, we clearly cannot simply update the term
115852: ** index when a document is deleted or updated. For deletions, we
115853: ** write an empty doclist (varint(docid) varint(POS_END)), for updates
115854: ** we simply write the new doclist. Segment merges overwrite older
115855: ** data for a particular docid with newer data, so deletes or updates
115856: ** will eventually overtake the earlier data and knock it out. The
115857: ** query logic likewise merges doclists so that newer data knocks out
115858: ** older data.
115859: **
115860: ** TODO(shess) Provide a VACUUM type operation to clear out all
115861: ** deletions and duplications. This would basically be a forced merge
115862: ** into a single segment.
115863: */
115864:
115865: /************** Include fts3Int.h in the middle of fts3.c ********************/
115866: /************** Begin file fts3Int.h *****************************************/
115867: /*
115868: ** 2009 Nov 12
115869: **
115870: ** The author disclaims copyright to this source code. In place of
115871: ** a legal notice, here is a blessing:
115872: **
115873: ** May you do good and not evil.
115874: ** May you find forgiveness for yourself and forgive others.
115875: ** May you share freely, never taking more than you give.
115876: **
115877: ******************************************************************************
115878: **
115879: */
115880: #ifndef _FTSINT_H
115881: #define _FTSINT_H
115882:
115883: #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
115884: # define NDEBUG 1
115885: #endif
115886:
115887: /*
115888: ** FTS4 is really an extension for FTS3. It is enabled using the
115889: ** SQLITE_ENABLE_FTS3 macro. But to avoid confusion we also all
115890: ** the SQLITE_ENABLE_FTS4 macro to serve as an alisse for SQLITE_ENABLE_FTS3.
115891: */
115892: #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3)
115893: # define SQLITE_ENABLE_FTS3
115894: #endif
115895:
115896: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
115897:
115898: /* If not building as part of the core, include sqlite3ext.h. */
115899: #ifndef SQLITE_CORE
115900: SQLITE_API extern const sqlite3_api_routines *sqlite3_api;
115901: #endif
115902:
115903: /************** Include fts3_tokenizer.h in the middle of fts3Int.h **********/
115904: /************** Begin file fts3_tokenizer.h **********************************/
115905: /*
115906: ** 2006 July 10
115907: **
115908: ** The author disclaims copyright to this source code.
115909: **
115910: *************************************************************************
115911: ** Defines the interface to tokenizers used by fulltext-search. There
115912: ** are three basic components:
115913: **
115914: ** sqlite3_tokenizer_module is a singleton defining the tokenizer
115915: ** interface functions. This is essentially the class structure for
115916: ** tokenizers.
115917: **
115918: ** sqlite3_tokenizer is used to define a particular tokenizer, perhaps
115919: ** including customization information defined at creation time.
115920: **
115921: ** sqlite3_tokenizer_cursor is generated by a tokenizer to generate
115922: ** tokens from a particular input.
115923: */
115924: #ifndef _FTS3_TOKENIZER_H_
115925: #define _FTS3_TOKENIZER_H_
115926:
115927: /* TODO(shess) Only used for SQLITE_OK and SQLITE_DONE at this time.
115928: ** If tokenizers are to be allowed to call sqlite3_*() functions, then
115929: ** we will need a way to register the API consistently.
115930: */
115931:
115932: /*
115933: ** Structures used by the tokenizer interface. When a new tokenizer
115934: ** implementation is registered, the caller provides a pointer to
115935: ** an sqlite3_tokenizer_module containing pointers to the callback
115936: ** functions that make up an implementation.
115937: **
115938: ** When an fts3 table is created, it passes any arguments passed to
115939: ** the tokenizer clause of the CREATE VIRTUAL TABLE statement to the
115940: ** sqlite3_tokenizer_module.xCreate() function of the requested tokenizer
115941: ** implementation. The xCreate() function in turn returns an
115942: ** sqlite3_tokenizer structure representing the specific tokenizer to
115943: ** be used for the fts3 table (customized by the tokenizer clause arguments).
115944: **
115945: ** To tokenize an input buffer, the sqlite3_tokenizer_module.xOpen()
115946: ** method is called. It returns an sqlite3_tokenizer_cursor object
115947: ** that may be used to tokenize a specific input buffer based on
115948: ** the tokenization rules supplied by a specific sqlite3_tokenizer
115949: ** object.
115950: */
115951: typedef struct sqlite3_tokenizer_module sqlite3_tokenizer_module;
115952: typedef struct sqlite3_tokenizer sqlite3_tokenizer;
115953: typedef struct sqlite3_tokenizer_cursor sqlite3_tokenizer_cursor;
115954:
115955: struct sqlite3_tokenizer_module {
115956:
115957: /*
115958: ** Structure version. Should always be set to 0.
115959: */
115960: int iVersion;
115961:
115962: /*
115963: ** Create a new tokenizer. The values in the argv[] array are the
115964: ** arguments passed to the "tokenizer" clause of the CREATE VIRTUAL
115965: ** TABLE statement that created the fts3 table. For example, if
115966: ** the following SQL is executed:
115967: **
115968: ** CREATE .. USING fts3( ... , tokenizer <tokenizer-name> arg1 arg2)
115969: **
115970: ** then argc is set to 2, and the argv[] array contains pointers
115971: ** to the strings "arg1" and "arg2".
115972: **
115973: ** This method should return either SQLITE_OK (0), or an SQLite error
115974: ** code. If SQLITE_OK is returned, then *ppTokenizer should be set
115975: ** to point at the newly created tokenizer structure. The generic
115976: ** sqlite3_tokenizer.pModule variable should not be initialised by
115977: ** this callback. The caller will do so.
115978: */
115979: int (*xCreate)(
115980: int argc, /* Size of argv array */
115981: const char *const*argv, /* Tokenizer argument strings */
115982: sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */
115983: );
115984:
115985: /*
115986: ** Destroy an existing tokenizer. The fts3 module calls this method
115987: ** exactly once for each successful call to xCreate().
115988: */
115989: int (*xDestroy)(sqlite3_tokenizer *pTokenizer);
115990:
115991: /*
115992: ** Create a tokenizer cursor to tokenize an input buffer. The caller
115993: ** is responsible for ensuring that the input buffer remains valid
115994: ** until the cursor is closed (using the xClose() method).
115995: */
115996: int (*xOpen)(
115997: sqlite3_tokenizer *pTokenizer, /* Tokenizer object */
115998: const char *pInput, int nBytes, /* Input buffer */
115999: sqlite3_tokenizer_cursor **ppCursor /* OUT: Created tokenizer cursor */
116000: );
116001:
116002: /*
116003: ** Destroy an existing tokenizer cursor. The fts3 module calls this
116004: ** method exactly once for each successful call to xOpen().
116005: */
116006: int (*xClose)(sqlite3_tokenizer_cursor *pCursor);
116007:
116008: /*
116009: ** Retrieve the next token from the tokenizer cursor pCursor. This
116010: ** method should either return SQLITE_OK and set the values of the
116011: ** "OUT" variables identified below, or SQLITE_DONE to indicate that
116012: ** the end of the buffer has been reached, or an SQLite error code.
116013: **
116014: ** *ppToken should be set to point at a buffer containing the
116015: ** normalized version of the token (i.e. after any case-folding and/or
116016: ** stemming has been performed). *pnBytes should be set to the length
116017: ** of this buffer in bytes. The input text that generated the token is
116018: ** identified by the byte offsets returned in *piStartOffset and
116019: ** *piEndOffset. *piStartOffset should be set to the index of the first
116020: ** byte of the token in the input buffer. *piEndOffset should be set
116021: ** to the index of the first byte just past the end of the token in
116022: ** the input buffer.
116023: **
116024: ** The buffer *ppToken is set to point at is managed by the tokenizer
116025: ** implementation. It is only required to be valid until the next call
116026: ** to xNext() or xClose().
116027: */
116028: /* TODO(shess) current implementation requires pInput to be
116029: ** nul-terminated. This should either be fixed, or pInput/nBytes
116030: ** should be converted to zInput.
116031: */
116032: int (*xNext)(
116033: sqlite3_tokenizer_cursor *pCursor, /* Tokenizer cursor */
116034: const char **ppToken, int *pnBytes, /* OUT: Normalized text for token */
116035: int *piStartOffset, /* OUT: Byte offset of token in input buffer */
116036: int *piEndOffset, /* OUT: Byte offset of end of token in input buffer */
116037: int *piPosition /* OUT: Number of tokens returned before this one */
116038: );
116039: };
116040:
116041: struct sqlite3_tokenizer {
116042: const sqlite3_tokenizer_module *pModule; /* The module for this tokenizer */
116043: /* Tokenizer implementations will typically add additional fields */
116044: };
116045:
116046: struct sqlite3_tokenizer_cursor {
116047: sqlite3_tokenizer *pTokenizer; /* Tokenizer for this cursor. */
116048: /* Tokenizer implementations will typically add additional fields */
116049: };
116050:
116051: int fts3_global_term_cnt(int iTerm, int iCol);
116052: int fts3_term_cnt(int iTerm, int iCol);
116053:
116054:
116055: #endif /* _FTS3_TOKENIZER_H_ */
116056:
116057: /************** End of fts3_tokenizer.h **************************************/
116058: /************** Continuing where we left off in fts3Int.h ********************/
116059: /************** Include fts3_hash.h in the middle of fts3Int.h ***************/
116060: /************** Begin file fts3_hash.h ***************************************/
116061: /*
116062: ** 2001 September 22
116063: **
116064: ** The author disclaims copyright to this source code. In place of
116065: ** a legal notice, here is a blessing:
116066: **
116067: ** May you do good and not evil.
116068: ** May you find forgiveness for yourself and forgive others.
116069: ** May you share freely, never taking more than you give.
116070: **
116071: *************************************************************************
116072: ** This is the header file for the generic hash-table implemenation
116073: ** used in SQLite. We've modified it slightly to serve as a standalone
116074: ** hash table implementation for the full-text indexing module.
116075: **
116076: */
116077: #ifndef _FTS3_HASH_H_
116078: #define _FTS3_HASH_H_
116079:
116080: /* Forward declarations of structures. */
116081: typedef struct Fts3Hash Fts3Hash;
116082: typedef struct Fts3HashElem Fts3HashElem;
116083:
116084: /* A complete hash table is an instance of the following structure.
116085: ** The internals of this structure are intended to be opaque -- client
116086: ** code should not attempt to access or modify the fields of this structure
116087: ** directly. Change this structure only by using the routines below.
116088: ** However, many of the "procedures" and "functions" for modifying and
116089: ** accessing this structure are really macros, so we can't really make
116090: ** this structure opaque.
116091: */
116092: struct Fts3Hash {
116093: char keyClass; /* HASH_INT, _POINTER, _STRING, _BINARY */
116094: char copyKey; /* True if copy of key made on insert */
116095: int count; /* Number of entries in this table */
116096: Fts3HashElem *first; /* The first element of the array */
116097: int htsize; /* Number of buckets in the hash table */
116098: struct _fts3ht { /* the hash table */
116099: int count; /* Number of entries with this hash */
116100: Fts3HashElem *chain; /* Pointer to first entry with this hash */
116101: } *ht;
116102: };
116103:
116104: /* Each element in the hash table is an instance of the following
116105: ** structure. All elements are stored on a single doubly-linked list.
116106: **
116107: ** Again, this structure is intended to be opaque, but it can't really
116108: ** be opaque because it is used by macros.
116109: */
116110: struct Fts3HashElem {
116111: Fts3HashElem *next, *prev; /* Next and previous elements in the table */
116112: void *data; /* Data associated with this element */
116113: void *pKey; int nKey; /* Key associated with this element */
116114: };
116115:
116116: /*
116117: ** There are 2 different modes of operation for a hash table:
116118: **
116119: ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
116120: ** (including the null-terminator, if any). Case
116121: ** is respected in comparisons.
116122: **
116123: ** FTS3_HASH_BINARY pKey points to binary data nKey bytes long.
116124: ** memcmp() is used to compare keys.
116125: **
116126: ** A copy of the key is made if the copyKey parameter to fts3HashInit is 1.
116127: */
116128: #define FTS3_HASH_STRING 1
116129: #define FTS3_HASH_BINARY 2
116130:
116131: /*
116132: ** Access routines. To delete, insert a NULL pointer.
116133: */
116134: SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey);
116135: SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
116136: SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
116137: SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash*);
116138: SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const void *, int);
116139:
116140: /*
116141: ** Shorthand for the functions above
116142: */
116143: #define fts3HashInit sqlite3Fts3HashInit
116144: #define fts3HashInsert sqlite3Fts3HashInsert
116145: #define fts3HashFind sqlite3Fts3HashFind
116146: #define fts3HashClear sqlite3Fts3HashClear
116147: #define fts3HashFindElem sqlite3Fts3HashFindElem
116148:
116149: /*
116150: ** Macros for looping over all elements of a hash table. The idiom is
116151: ** like this:
116152: **
116153: ** Fts3Hash h;
116154: ** Fts3HashElem *p;
116155: ** ...
116156: ** for(p=fts3HashFirst(&h); p; p=fts3HashNext(p)){
116157: ** SomeStructure *pData = fts3HashData(p);
116158: ** // do something with pData
116159: ** }
116160: */
116161: #define fts3HashFirst(H) ((H)->first)
116162: #define fts3HashNext(E) ((E)->next)
116163: #define fts3HashData(E) ((E)->data)
116164: #define fts3HashKey(E) ((E)->pKey)
116165: #define fts3HashKeysize(E) ((E)->nKey)
116166:
116167: /*
116168: ** Number of entries in a hash table
116169: */
116170: #define fts3HashCount(H) ((H)->count)
116171:
116172: #endif /* _FTS3_HASH_H_ */
116173:
116174: /************** End of fts3_hash.h *******************************************/
116175: /************** Continuing where we left off in fts3Int.h ********************/
116176:
116177: /*
116178: ** This constant controls how often segments are merged. Once there are
116179: ** FTS3_MERGE_COUNT segments of level N, they are merged into a single
116180: ** segment of level N+1.
116181: */
116182: #define FTS3_MERGE_COUNT 16
116183:
116184: /*
116185: ** This is the maximum amount of data (in bytes) to store in the
116186: ** Fts3Table.pendingTerms hash table. Normally, the hash table is
116187: ** populated as documents are inserted/updated/deleted in a transaction
116188: ** and used to create a new segment when the transaction is committed.
116189: ** However if this limit is reached midway through a transaction, a new
116190: ** segment is created and the hash table cleared immediately.
116191: */
116192: #define FTS3_MAX_PENDING_DATA (1*1024*1024)
116193:
116194: /*
116195: ** Macro to return the number of elements in an array. SQLite has a
116196: ** similar macro called ArraySize(). Use a different name to avoid
116197: ** a collision when building an amalgamation with built-in FTS3.
116198: */
116199: #define SizeofArray(X) ((int)(sizeof(X)/sizeof(X[0])))
116200:
116201:
116202: #ifndef MIN
116203: # define MIN(x,y) ((x)<(y)?(x):(y))
116204: #endif
116205:
116206: /*
116207: ** Maximum length of a varint encoded integer. The varint format is different
116208: ** from that used by SQLite, so the maximum length is 10, not 9.
116209: */
116210: #define FTS3_VARINT_MAX 10
116211:
116212: /*
116213: ** FTS4 virtual tables may maintain multiple indexes - one index of all terms
116214: ** in the document set and zero or more prefix indexes. All indexes are stored
116215: ** as one or more b+-trees in the %_segments and %_segdir tables.
116216: **
116217: ** It is possible to determine which index a b+-tree belongs to based on the
116218: ** value stored in the "%_segdir.level" column. Given this value L, the index
116219: ** that the b+-tree belongs to is (L<<10). In other words, all b+-trees with
116220: ** level values between 0 and 1023 (inclusive) belong to index 0, all levels
116221: ** between 1024 and 2047 to index 1, and so on.
116222: **
116223: ** It is considered impossible for an index to use more than 1024 levels. In
116224: ** theory though this may happen, but only after at least
116225: ** (FTS3_MERGE_COUNT^1024) separate flushes of the pending-terms tables.
116226: */
116227: #define FTS3_SEGDIR_MAXLEVEL 1024
116228: #define FTS3_SEGDIR_MAXLEVEL_STR "1024"
116229:
116230: /*
116231: ** The testcase() macro is only used by the amalgamation. If undefined,
116232: ** make it a no-op.
116233: */
116234: #ifndef testcase
116235: # define testcase(X)
116236: #endif
116237:
116238: /*
116239: ** Terminator values for position-lists and column-lists.
116240: */
116241: #define POS_COLUMN (1) /* Column-list terminator */
116242: #define POS_END (0) /* Position-list terminator */
116243:
116244: /*
116245: ** This section provides definitions to allow the
116246: ** FTS3 extension to be compiled outside of the
116247: ** amalgamation.
116248: */
116249: #ifndef SQLITE_AMALGAMATION
116250: /*
116251: ** Macros indicating that conditional expressions are always true or
116252: ** false.
116253: */
116254: #ifdef SQLITE_COVERAGE_TEST
116255: # define ALWAYS(x) (1)
116256: # define NEVER(X) (0)
116257: #else
116258: # define ALWAYS(x) (x)
116259: # define NEVER(X) (x)
116260: #endif
116261:
116262: /*
116263: ** Internal types used by SQLite.
116264: */
116265: typedef unsigned char u8; /* 1-byte (or larger) unsigned integer */
116266: typedef short int i16; /* 2-byte (or larger) signed integer */
116267: typedef unsigned int u32; /* 4-byte unsigned integer */
116268: typedef sqlite3_uint64 u64; /* 8-byte unsigned integer */
116269:
116270: /*
116271: ** Macro used to suppress compiler warnings for unused parameters.
116272: */
116273: #define UNUSED_PARAMETER(x) (void)(x)
116274:
116275: /*
116276: ** Activate assert() only if SQLITE_TEST is enabled.
116277: */
116278: #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
116279: # define NDEBUG 1
116280: #endif
116281:
116282: /*
116283: ** The TESTONLY macro is used to enclose variable declarations or
116284: ** other bits of code that are needed to support the arguments
116285: ** within testcase() and assert() macros.
116286: */
116287: #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
116288: # define TESTONLY(X) X
116289: #else
116290: # define TESTONLY(X)
116291: #endif
116292:
116293: #endif /* SQLITE_AMALGAMATION */
116294:
116295: #ifdef SQLITE_DEBUG
116296: SQLITE_PRIVATE int sqlite3Fts3Corrupt(void);
116297: # define FTS_CORRUPT_VTAB sqlite3Fts3Corrupt()
116298: #else
116299: # define FTS_CORRUPT_VTAB SQLITE_CORRUPT_VTAB
116300: #endif
116301:
116302: typedef struct Fts3Table Fts3Table;
116303: typedef struct Fts3Cursor Fts3Cursor;
116304: typedef struct Fts3Expr Fts3Expr;
116305: typedef struct Fts3Phrase Fts3Phrase;
116306: typedef struct Fts3PhraseToken Fts3PhraseToken;
116307:
116308: typedef struct Fts3Doclist Fts3Doclist;
116309: typedef struct Fts3SegFilter Fts3SegFilter;
116310: typedef struct Fts3DeferredToken Fts3DeferredToken;
116311: typedef struct Fts3SegReader Fts3SegReader;
116312: typedef struct Fts3MultiSegReader Fts3MultiSegReader;
116313:
116314: /*
116315: ** A connection to a fulltext index is an instance of the following
116316: ** structure. The xCreate and xConnect methods create an instance
116317: ** of this structure and xDestroy and xDisconnect free that instance.
116318: ** All other methods receive a pointer to the structure as one of their
116319: ** arguments.
116320: */
116321: struct Fts3Table {
116322: sqlite3_vtab base; /* Base class used by SQLite core */
116323: sqlite3 *db; /* The database connection */
116324: const char *zDb; /* logical database name */
116325: const char *zName; /* virtual table name */
116326: int nColumn; /* number of named columns in virtual table */
116327: char **azColumn; /* column names. malloced */
116328: sqlite3_tokenizer *pTokenizer; /* tokenizer for inserts and queries */
116329: char *zContentTbl; /* content=xxx option, or NULL */
116330:
116331: /* Precompiled statements used by the implementation. Each of these
116332: ** statements is run and reset within a single virtual table API call.
116333: */
116334: sqlite3_stmt *aStmt[27];
116335:
116336: char *zReadExprlist;
116337: char *zWriteExprlist;
116338:
116339: int nNodeSize; /* Soft limit for node size */
116340: u8 bHasStat; /* True if %_stat table exists */
116341: u8 bHasDocsize; /* True if %_docsize table exists */
116342: u8 bDescIdx; /* True if doclists are in reverse order */
116343: int nPgsz; /* Page size for host database */
116344: char *zSegmentsTbl; /* Name of %_segments table */
116345: sqlite3_blob *pSegments; /* Blob handle open on %_segments table */
116346:
116347: /* TODO: Fix the first paragraph of this comment.
116348: **
116349: ** The following hash table is used to buffer pending index updates during
116350: ** transactions. Variable nPendingData estimates the memory size of the
116351: ** pending data, including hash table overhead, but not malloc overhead.
116352: ** When nPendingData exceeds nMaxPendingData, the buffer is flushed
116353: ** automatically. Variable iPrevDocid is the docid of the most recently
116354: ** inserted record.
116355: **
116356: ** A single FTS4 table may have multiple full-text indexes. For each index
116357: ** there is an entry in the aIndex[] array. Index 0 is an index of all the
116358: ** terms that appear in the document set. Each subsequent index in aIndex[]
116359: ** is an index of prefixes of a specific length.
116360: */
116361: int nIndex; /* Size of aIndex[] */
116362: struct Fts3Index {
116363: int nPrefix; /* Prefix length (0 for main terms index) */
116364: Fts3Hash hPending; /* Pending terms table for this index */
116365: } *aIndex;
116366: int nMaxPendingData; /* Max pending data before flush to disk */
116367: int nPendingData; /* Current bytes of pending data */
116368: sqlite_int64 iPrevDocid; /* Docid of most recently inserted document */
116369:
116370: #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
116371: /* State variables used for validating that the transaction control
116372: ** methods of the virtual table are called at appropriate times. These
116373: ** values do not contribution to the FTS computation; they are used for
116374: ** verifying the SQLite core.
116375: */
116376: int inTransaction; /* True after xBegin but before xCommit/xRollback */
116377: int mxSavepoint; /* Largest valid xSavepoint integer */
116378: #endif
116379: };
116380:
116381: /*
116382: ** When the core wants to read from the virtual table, it creates a
116383: ** virtual table cursor (an instance of the following structure) using
116384: ** the xOpen method. Cursors are destroyed using the xClose method.
116385: */
116386: struct Fts3Cursor {
116387: sqlite3_vtab_cursor base; /* Base class used by SQLite core */
116388: i16 eSearch; /* Search strategy (see below) */
116389: u8 isEof; /* True if at End Of Results */
116390: u8 isRequireSeek; /* True if must seek pStmt to %_content row */
116391: sqlite3_stmt *pStmt; /* Prepared statement in use by the cursor */
116392: Fts3Expr *pExpr; /* Parsed MATCH query string */
116393: int nPhrase; /* Number of matchable phrases in query */
116394: Fts3DeferredToken *pDeferred; /* Deferred search tokens, if any */
116395: sqlite3_int64 iPrevId; /* Previous id read from aDoclist */
116396: char *pNextId; /* Pointer into the body of aDoclist */
116397: char *aDoclist; /* List of docids for full-text queries */
116398: int nDoclist; /* Size of buffer at aDoclist */
116399: u8 bDesc; /* True to sort in descending order */
116400: int eEvalmode; /* An FTS3_EVAL_XX constant */
116401: int nRowAvg; /* Average size of database rows, in pages */
116402: sqlite3_int64 nDoc; /* Documents in table */
116403:
116404: int isMatchinfoNeeded; /* True when aMatchinfo[] needs filling in */
116405: u32 *aMatchinfo; /* Information about most recent match */
116406: int nMatchinfo; /* Number of elements in aMatchinfo[] */
116407: char *zMatchinfo; /* Matchinfo specification */
116408: };
116409:
116410: #define FTS3_EVAL_FILTER 0
116411: #define FTS3_EVAL_NEXT 1
116412: #define FTS3_EVAL_MATCHINFO 2
116413:
116414: /*
116415: ** The Fts3Cursor.eSearch member is always set to one of the following.
116416: ** Actualy, Fts3Cursor.eSearch can be greater than or equal to
116417: ** FTS3_FULLTEXT_SEARCH. If so, then Fts3Cursor.eSearch - 2 is the index
116418: ** of the column to be searched. For example, in
116419: **
116420: ** CREATE VIRTUAL TABLE ex1 USING fts3(a,b,c,d);
116421: ** SELECT docid FROM ex1 WHERE b MATCH 'one two three';
116422: **
116423: ** Because the LHS of the MATCH operator is 2nd column "b",
116424: ** Fts3Cursor.eSearch will be set to FTS3_FULLTEXT_SEARCH+1. (+0 for a,
116425: ** +1 for b, +2 for c, +3 for d.) If the LHS of MATCH were "ex1"
116426: ** indicating that all columns should be searched,
116427: ** then eSearch would be set to FTS3_FULLTEXT_SEARCH+4.
116428: */
116429: #define FTS3_FULLSCAN_SEARCH 0 /* Linear scan of %_content table */
116430: #define FTS3_DOCID_SEARCH 1 /* Lookup by rowid on %_content table */
116431: #define FTS3_FULLTEXT_SEARCH 2 /* Full-text index search */
116432:
116433:
116434: struct Fts3Doclist {
116435: char *aAll; /* Array containing doclist (or NULL) */
116436: int nAll; /* Size of a[] in bytes */
116437: char *pNextDocid; /* Pointer to next docid */
116438:
116439: sqlite3_int64 iDocid; /* Current docid (if pList!=0) */
116440: int bFreeList; /* True if pList should be sqlite3_free()d */
116441: char *pList; /* Pointer to position list following iDocid */
116442: int nList; /* Length of position list */
116443: };
116444:
116445: /*
116446: ** A "phrase" is a sequence of one or more tokens that must match in
116447: ** sequence. A single token is the base case and the most common case.
116448: ** For a sequence of tokens contained in double-quotes (i.e. "one two three")
116449: ** nToken will be the number of tokens in the string.
116450: */
116451: struct Fts3PhraseToken {
116452: char *z; /* Text of the token */
116453: int n; /* Number of bytes in buffer z */
116454: int isPrefix; /* True if token ends with a "*" character */
116455: int bFirst; /* True if token must appear at position 0 */
116456:
116457: /* Variables above this point are populated when the expression is
116458: ** parsed (by code in fts3_expr.c). Below this point the variables are
116459: ** used when evaluating the expression. */
116460: Fts3DeferredToken *pDeferred; /* Deferred token object for this token */
116461: Fts3MultiSegReader *pSegcsr; /* Segment-reader for this token */
116462: };
116463:
116464: struct Fts3Phrase {
116465: /* Cache of doclist for this phrase. */
116466: Fts3Doclist doclist;
116467: int bIncr; /* True if doclist is loaded incrementally */
116468: int iDoclistToken;
116469:
116470: /* Variables below this point are populated by fts3_expr.c when parsing
116471: ** a MATCH expression. Everything above is part of the evaluation phase.
116472: */
116473: int nToken; /* Number of tokens in the phrase */
116474: int iColumn; /* Index of column this phrase must match */
116475: Fts3PhraseToken aToken[1]; /* One entry for each token in the phrase */
116476: };
116477:
116478: /*
116479: ** A tree of these objects forms the RHS of a MATCH operator.
116480: **
116481: ** If Fts3Expr.eType is FTSQUERY_PHRASE and isLoaded is true, then aDoclist
116482: ** points to a malloced buffer, size nDoclist bytes, containing the results
116483: ** of this phrase query in FTS3 doclist format. As usual, the initial
116484: ** "Length" field found in doclists stored on disk is omitted from this
116485: ** buffer.
116486: **
116487: ** Variable aMI is used only for FTSQUERY_NEAR nodes to store the global
116488: ** matchinfo data. If it is not NULL, it points to an array of size nCol*3,
116489: ** where nCol is the number of columns in the queried FTS table. The array
116490: ** is populated as follows:
116491: **
116492: ** aMI[iCol*3 + 0] = Undefined
116493: ** aMI[iCol*3 + 1] = Number of occurrences
116494: ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
116495: **
116496: ** The aMI array is allocated using sqlite3_malloc(). It should be freed
116497: ** when the expression node is.
116498: */
116499: struct Fts3Expr {
116500: int eType; /* One of the FTSQUERY_XXX values defined below */
116501: int nNear; /* Valid if eType==FTSQUERY_NEAR */
116502: Fts3Expr *pParent; /* pParent->pLeft==this or pParent->pRight==this */
116503: Fts3Expr *pLeft; /* Left operand */
116504: Fts3Expr *pRight; /* Right operand */
116505: Fts3Phrase *pPhrase; /* Valid if eType==FTSQUERY_PHRASE */
116506:
116507: /* The following are used by the fts3_eval.c module. */
116508: sqlite3_int64 iDocid; /* Current docid */
116509: u8 bEof; /* True this expression is at EOF already */
116510: u8 bStart; /* True if iDocid is valid */
116511: u8 bDeferred; /* True if this expression is entirely deferred */
116512:
116513: u32 *aMI;
116514: };
116515:
116516: /*
116517: ** Candidate values for Fts3Query.eType. Note that the order of the first
116518: ** four values is in order of precedence when parsing expressions. For
116519: ** example, the following:
116520: **
116521: ** "a OR b AND c NOT d NEAR e"
116522: **
116523: ** is equivalent to:
116524: **
116525: ** "a OR (b AND (c NOT (d NEAR e)))"
116526: */
116527: #define FTSQUERY_NEAR 1
116528: #define FTSQUERY_NOT 2
116529: #define FTSQUERY_AND 3
116530: #define FTSQUERY_OR 4
116531: #define FTSQUERY_PHRASE 5
116532:
116533:
116534: /* fts3_write.c */
116535: SQLITE_PRIVATE int sqlite3Fts3UpdateMethod(sqlite3_vtab*,int,sqlite3_value**,sqlite3_int64*);
116536: SQLITE_PRIVATE int sqlite3Fts3PendingTermsFlush(Fts3Table *);
116537: SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *);
116538: SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *);
116539: SQLITE_PRIVATE int sqlite3Fts3SegReaderNew(int, sqlite3_int64,
116540: sqlite3_int64, sqlite3_int64, const char *, int, Fts3SegReader**);
116541: SQLITE_PRIVATE int sqlite3Fts3SegReaderPending(
116542: Fts3Table*,int,const char*,int,int,Fts3SegReader**);
116543: SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *);
116544: SQLITE_PRIVATE int sqlite3Fts3AllSegdirs(Fts3Table*, int, int, sqlite3_stmt **);
116545: SQLITE_PRIVATE int sqlite3Fts3ReadLock(Fts3Table *);
116546: SQLITE_PRIVATE int sqlite3Fts3ReadBlock(Fts3Table*, sqlite3_int64, char **, int*, int*);
116547:
116548: SQLITE_PRIVATE int sqlite3Fts3SelectDoctotal(Fts3Table *, sqlite3_stmt **);
116549: SQLITE_PRIVATE int sqlite3Fts3SelectDocsize(Fts3Table *, sqlite3_int64, sqlite3_stmt **);
116550:
116551: SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *);
116552: SQLITE_PRIVATE int sqlite3Fts3DeferToken(Fts3Cursor *, Fts3PhraseToken *, int);
116553: SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *);
116554: SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *);
116555: SQLITE_PRIVATE void sqlite3Fts3SegmentsClose(Fts3Table *);
116556:
116557: /* Special values interpreted by sqlite3SegReaderCursor() */
116558: #define FTS3_SEGCURSOR_PENDING -1
116559: #define FTS3_SEGCURSOR_ALL -2
116560:
116561: SQLITE_PRIVATE int sqlite3Fts3SegReaderStart(Fts3Table*, Fts3MultiSegReader*, Fts3SegFilter*);
116562: SQLITE_PRIVATE int sqlite3Fts3SegReaderStep(Fts3Table *, Fts3MultiSegReader *);
116563: SQLITE_PRIVATE void sqlite3Fts3SegReaderFinish(Fts3MultiSegReader *);
116564:
116565: SQLITE_PRIVATE int sqlite3Fts3SegReaderCursor(
116566: Fts3Table *, int, int, const char *, int, int, int, Fts3MultiSegReader *);
116567:
116568: /* Flags allowed as part of the 4th argument to SegmentReaderIterate() */
116569: #define FTS3_SEGMENT_REQUIRE_POS 0x00000001
116570: #define FTS3_SEGMENT_IGNORE_EMPTY 0x00000002
116571: #define FTS3_SEGMENT_COLUMN_FILTER 0x00000004
116572: #define FTS3_SEGMENT_PREFIX 0x00000008
116573: #define FTS3_SEGMENT_SCAN 0x00000010
116574: #define FTS3_SEGMENT_FIRST 0x00000020
116575:
116576: /* Type passed as 4th argument to SegmentReaderIterate() */
116577: struct Fts3SegFilter {
116578: const char *zTerm;
116579: int nTerm;
116580: int iCol;
116581: int flags;
116582: };
116583:
116584: struct Fts3MultiSegReader {
116585: /* Used internally by sqlite3Fts3SegReaderXXX() calls */
116586: Fts3SegReader **apSegment; /* Array of Fts3SegReader objects */
116587: int nSegment; /* Size of apSegment array */
116588: int nAdvance; /* How many seg-readers to advance */
116589: Fts3SegFilter *pFilter; /* Pointer to filter object */
116590: char *aBuffer; /* Buffer to merge doclists in */
116591: int nBuffer; /* Allocated size of aBuffer[] in bytes */
116592:
116593: int iColFilter; /* If >=0, filter for this column */
116594: int bRestart;
116595:
116596: /* Used by fts3.c only. */
116597: int nCost; /* Cost of running iterator */
116598: int bLookup; /* True if a lookup of a single entry. */
116599:
116600: /* Output values. Valid only after Fts3SegReaderStep() returns SQLITE_ROW. */
116601: char *zTerm; /* Pointer to term buffer */
116602: int nTerm; /* Size of zTerm in bytes */
116603: char *aDoclist; /* Pointer to doclist buffer */
116604: int nDoclist; /* Size of aDoclist[] in bytes */
116605: };
116606:
116607: /* fts3.c */
116608: SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *, sqlite3_int64);
116609: SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *, sqlite_int64 *);
116610: SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *, int *);
116611: SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64);
116612: SQLITE_PRIVATE void sqlite3Fts3Dequote(char *);
116613: SQLITE_PRIVATE void sqlite3Fts3DoclistPrev(int,char*,int,char**,sqlite3_int64*,int*,u8*);
116614: SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats(Fts3Cursor *, Fts3Expr *, u32 *);
116615: SQLITE_PRIVATE int sqlite3Fts3FirstFilter(sqlite3_int64, char *, int, char *);
116616:
116617: /* fts3_tokenizer.c */
116618: SQLITE_PRIVATE const char *sqlite3Fts3NextToken(const char *, int *);
116619: SQLITE_PRIVATE int sqlite3Fts3InitHashTable(sqlite3 *, Fts3Hash *, const char *);
116620: SQLITE_PRIVATE int sqlite3Fts3InitTokenizer(Fts3Hash *pHash, const char *,
116621: sqlite3_tokenizer **, char **
116622: );
116623: SQLITE_PRIVATE int sqlite3Fts3IsIdChar(char);
116624:
116625: /* fts3_snippet.c */
116626: SQLITE_PRIVATE void sqlite3Fts3Offsets(sqlite3_context*, Fts3Cursor*);
116627: SQLITE_PRIVATE void sqlite3Fts3Snippet(sqlite3_context *, Fts3Cursor *, const char *,
116628: const char *, const char *, int, int
116629: );
116630: SQLITE_PRIVATE void sqlite3Fts3Matchinfo(sqlite3_context *, Fts3Cursor *, const char *);
116631:
116632: /* fts3_expr.c */
116633: SQLITE_PRIVATE int sqlite3Fts3ExprParse(sqlite3_tokenizer *,
116634: char **, int, int, int, const char *, int, Fts3Expr **
116635: );
116636: SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *);
116637: #ifdef SQLITE_TEST
116638: SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db);
116639: SQLITE_PRIVATE int sqlite3Fts3InitTerm(sqlite3 *db);
116640: #endif
116641:
116642: /* fts3_aux.c */
116643: SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db);
116644:
116645: SQLITE_PRIVATE void sqlite3Fts3EvalPhraseCleanup(Fts3Phrase *);
116646:
116647: SQLITE_PRIVATE int sqlite3Fts3MsrIncrStart(
116648: Fts3Table*, Fts3MultiSegReader*, int, const char*, int);
116649: SQLITE_PRIVATE int sqlite3Fts3MsrIncrNext(
116650: Fts3Table *, Fts3MultiSegReader *, sqlite3_int64 *, char **, int *);
116651: SQLITE_PRIVATE char *sqlite3Fts3EvalPhrasePoslist(Fts3Cursor *, Fts3Expr *, int iCol);
116652: SQLITE_PRIVATE int sqlite3Fts3MsrOvfl(Fts3Cursor *, Fts3MultiSegReader *, int *);
116653: SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr);
116654:
116655: SQLITE_PRIVATE int sqlite3Fts3DeferredTokenList(Fts3DeferredToken *, char **, int *);
116656:
116657: #endif /* !SQLITE_CORE || SQLITE_ENABLE_FTS3 */
116658: #endif /* _FTSINT_H */
116659:
116660: /************** End of fts3Int.h *********************************************/
116661: /************** Continuing where we left off in fts3.c ***********************/
116662: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
116663:
116664: #if defined(SQLITE_ENABLE_FTS3) && !defined(SQLITE_CORE)
116665: # define SQLITE_CORE 1
116666: #endif
116667:
116668: /* #include <assert.h> */
116669: /* #include <stdlib.h> */
116670: /* #include <stddef.h> */
116671: /* #include <stdio.h> */
116672: /* #include <string.h> */
116673: /* #include <stdarg.h> */
116674:
116675: #ifndef SQLITE_CORE
116676: SQLITE_EXTENSION_INIT1
116677: #endif
116678:
116679: static int fts3EvalNext(Fts3Cursor *pCsr);
116680: static int fts3EvalStart(Fts3Cursor *pCsr);
116681: static int fts3TermSegReaderCursor(
116682: Fts3Cursor *, const char *, int, int, Fts3MultiSegReader **);
116683:
116684: /*
116685: ** Write a 64-bit variable-length integer to memory starting at p[0].
116686: ** The length of data written will be between 1 and FTS3_VARINT_MAX bytes.
116687: ** The number of bytes written is returned.
116688: */
116689: SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){
116690: unsigned char *q = (unsigned char *) p;
116691: sqlite_uint64 vu = v;
116692: do{
116693: *q++ = (unsigned char) ((vu & 0x7f) | 0x80);
116694: vu >>= 7;
116695: }while( vu!=0 );
116696: q[-1] &= 0x7f; /* turn off high bit in final byte */
116697: assert( q - (unsigned char *)p <= FTS3_VARINT_MAX );
116698: return (int) (q - (unsigned char *)p);
116699: }
116700:
116701: /*
116702: ** Read a 64-bit variable-length integer from memory starting at p[0].
116703: ** Return the number of bytes read, or 0 on error.
116704: ** The value is stored in *v.
116705: */
116706: SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *p, sqlite_int64 *v){
116707: const unsigned char *q = (const unsigned char *) p;
116708: sqlite_uint64 x = 0, y = 1;
116709: while( (*q&0x80)==0x80 && q-(unsigned char *)p<FTS3_VARINT_MAX ){
116710: x += y * (*q++ & 0x7f);
116711: y <<= 7;
116712: }
116713: x += y * (*q++);
116714: *v = (sqlite_int64) x;
116715: return (int) (q - (unsigned char *)p);
116716: }
116717:
116718: /*
116719: ** Similar to sqlite3Fts3GetVarint(), except that the output is truncated to a
116720: ** 32-bit integer before it is returned.
116721: */
116722: SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *p, int *pi){
116723: sqlite_int64 i;
116724: int ret = sqlite3Fts3GetVarint(p, &i);
116725: *pi = (int) i;
116726: return ret;
116727: }
116728:
116729: /*
116730: ** Return the number of bytes required to encode v as a varint
116731: */
116732: SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64 v){
116733: int i = 0;
116734: do{
116735: i++;
116736: v >>= 7;
116737: }while( v!=0 );
116738: return i;
116739: }
116740:
116741: /*
116742: ** Convert an SQL-style quoted string into a normal string by removing
116743: ** the quote characters. The conversion is done in-place. If the
116744: ** input does not begin with a quote character, then this routine
116745: ** is a no-op.
116746: **
116747: ** Examples:
116748: **
116749: ** "abc" becomes abc
116750: ** 'xyz' becomes xyz
116751: ** [pqr] becomes pqr
116752: ** `mno` becomes mno
116753: **
116754: */
116755: SQLITE_PRIVATE void sqlite3Fts3Dequote(char *z){
116756: char quote; /* Quote character (if any ) */
116757:
116758: quote = z[0];
116759: if( quote=='[' || quote=='\'' || quote=='"' || quote=='`' ){
116760: int iIn = 1; /* Index of next byte to read from input */
116761: int iOut = 0; /* Index of next byte to write to output */
116762:
116763: /* If the first byte was a '[', then the close-quote character is a ']' */
116764: if( quote=='[' ) quote = ']';
116765:
116766: while( ALWAYS(z[iIn]) ){
116767: if( z[iIn]==quote ){
116768: if( z[iIn+1]!=quote ) break;
116769: z[iOut++] = quote;
116770: iIn += 2;
116771: }else{
116772: z[iOut++] = z[iIn++];
116773: }
116774: }
116775: z[iOut] = '\0';
116776: }
116777: }
116778:
116779: /*
116780: ** Read a single varint from the doclist at *pp and advance *pp to point
116781: ** to the first byte past the end of the varint. Add the value of the varint
116782: ** to *pVal.
116783: */
116784: static void fts3GetDeltaVarint(char **pp, sqlite3_int64 *pVal){
116785: sqlite3_int64 iVal;
116786: *pp += sqlite3Fts3GetVarint(*pp, &iVal);
116787: *pVal += iVal;
116788: }
116789:
116790: /*
116791: ** When this function is called, *pp points to the first byte following a
116792: ** varint that is part of a doclist (or position-list, or any other list
116793: ** of varints). This function moves *pp to point to the start of that varint,
116794: ** and sets *pVal by the varint value.
116795: **
116796: ** Argument pStart points to the first byte of the doclist that the
116797: ** varint is part of.
116798: */
116799: static void fts3GetReverseVarint(
116800: char **pp,
116801: char *pStart,
116802: sqlite3_int64 *pVal
116803: ){
116804: sqlite3_int64 iVal;
116805: char *p;
116806:
116807: /* Pointer p now points at the first byte past the varint we are
116808: ** interested in. So, unless the doclist is corrupt, the 0x80 bit is
116809: ** clear on character p[-1]. */
116810: for(p = (*pp)-2; p>=pStart && *p&0x80; p--);
116811: p++;
116812: *pp = p;
116813:
116814: sqlite3Fts3GetVarint(p, &iVal);
116815: *pVal = iVal;
116816: }
116817:
116818: /*
116819: ** The xDisconnect() virtual table method.
116820: */
116821: static int fts3DisconnectMethod(sqlite3_vtab *pVtab){
116822: Fts3Table *p = (Fts3Table *)pVtab;
116823: int i;
116824:
116825: assert( p->nPendingData==0 );
116826: assert( p->pSegments==0 );
116827:
116828: /* Free any prepared statements held */
116829: for(i=0; i<SizeofArray(p->aStmt); i++){
116830: sqlite3_finalize(p->aStmt[i]);
116831: }
116832: sqlite3_free(p->zSegmentsTbl);
116833: sqlite3_free(p->zReadExprlist);
116834: sqlite3_free(p->zWriteExprlist);
116835: sqlite3_free(p->zContentTbl);
116836:
116837: /* Invoke the tokenizer destructor to free the tokenizer. */
116838: p->pTokenizer->pModule->xDestroy(p->pTokenizer);
116839:
116840: sqlite3_free(p);
116841: return SQLITE_OK;
116842: }
116843:
116844: /*
116845: ** Construct one or more SQL statements from the format string given
116846: ** and then evaluate those statements. The success code is written
116847: ** into *pRc.
116848: **
116849: ** If *pRc is initially non-zero then this routine is a no-op.
116850: */
116851: static void fts3DbExec(
116852: int *pRc, /* Success code */
116853: sqlite3 *db, /* Database in which to run SQL */
116854: const char *zFormat, /* Format string for SQL */
116855: ... /* Arguments to the format string */
116856: ){
116857: va_list ap;
116858: char *zSql;
116859: if( *pRc ) return;
116860: va_start(ap, zFormat);
116861: zSql = sqlite3_vmprintf(zFormat, ap);
116862: va_end(ap);
116863: if( zSql==0 ){
116864: *pRc = SQLITE_NOMEM;
116865: }else{
116866: *pRc = sqlite3_exec(db, zSql, 0, 0, 0);
116867: sqlite3_free(zSql);
116868: }
116869: }
116870:
116871: /*
116872: ** The xDestroy() virtual table method.
116873: */
116874: static int fts3DestroyMethod(sqlite3_vtab *pVtab){
116875: Fts3Table *p = (Fts3Table *)pVtab;
116876: int rc = SQLITE_OK; /* Return code */
116877: const char *zDb = p->zDb; /* Name of database (e.g. "main", "temp") */
116878: sqlite3 *db = p->db; /* Database handle */
116879:
116880: /* Drop the shadow tables */
116881: if( p->zContentTbl==0 ){
116882: fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_content'", zDb, p->zName);
116883: }
116884: fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segments'", zDb,p->zName);
116885: fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_segdir'", zDb, p->zName);
116886: fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_docsize'", zDb, p->zName);
116887: fts3DbExec(&rc, db, "DROP TABLE IF EXISTS %Q.'%q_stat'", zDb, p->zName);
116888:
116889: /* If everything has worked, invoke fts3DisconnectMethod() to free the
116890: ** memory associated with the Fts3Table structure and return SQLITE_OK.
116891: ** Otherwise, return an SQLite error code.
116892: */
116893: return (rc==SQLITE_OK ? fts3DisconnectMethod(pVtab) : rc);
116894: }
116895:
116896:
116897: /*
116898: ** Invoke sqlite3_declare_vtab() to declare the schema for the FTS3 table
116899: ** passed as the first argument. This is done as part of the xConnect()
116900: ** and xCreate() methods.
116901: **
116902: ** If *pRc is non-zero when this function is called, it is a no-op.
116903: ** Otherwise, if an error occurs, an SQLite error code is stored in *pRc
116904: ** before returning.
116905: */
116906: static void fts3DeclareVtab(int *pRc, Fts3Table *p){
116907: if( *pRc==SQLITE_OK ){
116908: int i; /* Iterator variable */
116909: int rc; /* Return code */
116910: char *zSql; /* SQL statement passed to declare_vtab() */
116911: char *zCols; /* List of user defined columns */
116912:
116913: sqlite3_vtab_config(p->db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1);
116914:
116915: /* Create a list of user columns for the virtual table */
116916: zCols = sqlite3_mprintf("%Q, ", p->azColumn[0]);
116917: for(i=1; zCols && i<p->nColumn; i++){
116918: zCols = sqlite3_mprintf("%z%Q, ", zCols, p->azColumn[i]);
116919: }
116920:
116921: /* Create the whole "CREATE TABLE" statement to pass to SQLite */
116922: zSql = sqlite3_mprintf(
116923: "CREATE TABLE x(%s %Q HIDDEN, docid HIDDEN)", zCols, p->zName
116924: );
116925: if( !zCols || !zSql ){
116926: rc = SQLITE_NOMEM;
116927: }else{
116928: rc = sqlite3_declare_vtab(p->db, zSql);
116929: }
116930:
116931: sqlite3_free(zSql);
116932: sqlite3_free(zCols);
116933: *pRc = rc;
116934: }
116935: }
116936:
116937: /*
116938: ** Create the backing store tables (%_content, %_segments and %_segdir)
116939: ** required by the FTS3 table passed as the only argument. This is done
116940: ** as part of the vtab xCreate() method.
116941: **
116942: ** If the p->bHasDocsize boolean is true (indicating that this is an
116943: ** FTS4 table, not an FTS3 table) then also create the %_docsize and
116944: ** %_stat tables required by FTS4.
116945: */
116946: static int fts3CreateTables(Fts3Table *p){
116947: int rc = SQLITE_OK; /* Return code */
116948: int i; /* Iterator variable */
116949: sqlite3 *db = p->db; /* The database connection */
116950:
116951: if( p->zContentTbl==0 ){
116952: char *zContentCols; /* Columns of %_content table */
116953:
116954: /* Create a list of user columns for the content table */
116955: zContentCols = sqlite3_mprintf("docid INTEGER PRIMARY KEY");
116956: for(i=0; zContentCols && i<p->nColumn; i++){
116957: char *z = p->azColumn[i];
116958: zContentCols = sqlite3_mprintf("%z, 'c%d%q'", zContentCols, i, z);
116959: }
116960: if( zContentCols==0 ) rc = SQLITE_NOMEM;
116961:
116962: /* Create the content table */
116963: fts3DbExec(&rc, db,
116964: "CREATE TABLE %Q.'%q_content'(%s)",
116965: p->zDb, p->zName, zContentCols
116966: );
116967: sqlite3_free(zContentCols);
116968: }
116969:
116970: /* Create other tables */
116971: fts3DbExec(&rc, db,
116972: "CREATE TABLE %Q.'%q_segments'(blockid INTEGER PRIMARY KEY, block BLOB);",
116973: p->zDb, p->zName
116974: );
116975: fts3DbExec(&rc, db,
116976: "CREATE TABLE %Q.'%q_segdir'("
116977: "level INTEGER,"
116978: "idx INTEGER,"
116979: "start_block INTEGER,"
116980: "leaves_end_block INTEGER,"
116981: "end_block INTEGER,"
116982: "root BLOB,"
116983: "PRIMARY KEY(level, idx)"
116984: ");",
116985: p->zDb, p->zName
116986: );
116987: if( p->bHasDocsize ){
116988: fts3DbExec(&rc, db,
116989: "CREATE TABLE %Q.'%q_docsize'(docid INTEGER PRIMARY KEY, size BLOB);",
116990: p->zDb, p->zName
116991: );
116992: }
116993: if( p->bHasStat ){
116994: fts3DbExec(&rc, db,
116995: "CREATE TABLE %Q.'%q_stat'(id INTEGER PRIMARY KEY, value BLOB);",
116996: p->zDb, p->zName
116997: );
116998: }
116999: return rc;
117000: }
117001:
117002: /*
117003: ** Store the current database page-size in bytes in p->nPgsz.
117004: **
117005: ** If *pRc is non-zero when this function is called, it is a no-op.
117006: ** Otherwise, if an error occurs, an SQLite error code is stored in *pRc
117007: ** before returning.
117008: */
117009: static void fts3DatabasePageSize(int *pRc, Fts3Table *p){
117010: if( *pRc==SQLITE_OK ){
117011: int rc; /* Return code */
117012: char *zSql; /* SQL text "PRAGMA %Q.page_size" */
117013: sqlite3_stmt *pStmt; /* Compiled "PRAGMA %Q.page_size" statement */
117014:
117015: zSql = sqlite3_mprintf("PRAGMA %Q.page_size", p->zDb);
117016: if( !zSql ){
117017: rc = SQLITE_NOMEM;
117018: }else{
117019: rc = sqlite3_prepare(p->db, zSql, -1, &pStmt, 0);
117020: if( rc==SQLITE_OK ){
117021: sqlite3_step(pStmt);
117022: p->nPgsz = sqlite3_column_int(pStmt, 0);
117023: rc = sqlite3_finalize(pStmt);
117024: }else if( rc==SQLITE_AUTH ){
117025: p->nPgsz = 1024;
117026: rc = SQLITE_OK;
117027: }
117028: }
117029: assert( p->nPgsz>0 || rc!=SQLITE_OK );
117030: sqlite3_free(zSql);
117031: *pRc = rc;
117032: }
117033: }
117034:
117035: /*
117036: ** "Special" FTS4 arguments are column specifications of the following form:
117037: **
117038: ** <key> = <value>
117039: **
117040: ** There may not be whitespace surrounding the "=" character. The <value>
117041: ** term may be quoted, but the <key> may not.
117042: */
117043: static int fts3IsSpecialColumn(
117044: const char *z,
117045: int *pnKey,
117046: char **pzValue
117047: ){
117048: char *zValue;
117049: const char *zCsr = z;
117050:
117051: while( *zCsr!='=' ){
117052: if( *zCsr=='\0' ) return 0;
117053: zCsr++;
117054: }
117055:
117056: *pnKey = (int)(zCsr-z);
117057: zValue = sqlite3_mprintf("%s", &zCsr[1]);
117058: if( zValue ){
117059: sqlite3Fts3Dequote(zValue);
117060: }
117061: *pzValue = zValue;
117062: return 1;
117063: }
117064:
117065: /*
117066: ** Append the output of a printf() style formatting to an existing string.
117067: */
117068: static void fts3Appendf(
117069: int *pRc, /* IN/OUT: Error code */
117070: char **pz, /* IN/OUT: Pointer to string buffer */
117071: const char *zFormat, /* Printf format string to append */
117072: ... /* Arguments for printf format string */
117073: ){
117074: if( *pRc==SQLITE_OK ){
117075: va_list ap;
117076: char *z;
117077: va_start(ap, zFormat);
117078: z = sqlite3_vmprintf(zFormat, ap);
117079: va_end(ap);
117080: if( z && *pz ){
117081: char *z2 = sqlite3_mprintf("%s%s", *pz, z);
117082: sqlite3_free(z);
117083: z = z2;
117084: }
117085: if( z==0 ) *pRc = SQLITE_NOMEM;
117086: sqlite3_free(*pz);
117087: *pz = z;
117088: }
117089: }
117090:
117091: /*
117092: ** Return a copy of input string zInput enclosed in double-quotes (") and
117093: ** with all double quote characters escaped. For example:
117094: **
117095: ** fts3QuoteId("un \"zip\"") -> "un \"\"zip\"\""
117096: **
117097: ** The pointer returned points to memory obtained from sqlite3_malloc(). It
117098: ** is the callers responsibility to call sqlite3_free() to release this
117099: ** memory.
117100: */
117101: static char *fts3QuoteId(char const *zInput){
117102: int nRet;
117103: char *zRet;
117104: nRet = 2 + strlen(zInput)*2 + 1;
117105: zRet = sqlite3_malloc(nRet);
117106: if( zRet ){
117107: int i;
117108: char *z = zRet;
117109: *(z++) = '"';
117110: for(i=0; zInput[i]; i++){
117111: if( zInput[i]=='"' ) *(z++) = '"';
117112: *(z++) = zInput[i];
117113: }
117114: *(z++) = '"';
117115: *(z++) = '\0';
117116: }
117117: return zRet;
117118: }
117119:
117120: /*
117121: ** Return a list of comma separated SQL expressions and a FROM clause that
117122: ** could be used in a SELECT statement such as the following:
117123: **
117124: ** SELECT <list of expressions> FROM %_content AS x ...
117125: **
117126: ** to return the docid, followed by each column of text data in order
117127: ** from left to write. If parameter zFunc is not NULL, then instead of
117128: ** being returned directly each column of text data is passed to an SQL
117129: ** function named zFunc first. For example, if zFunc is "unzip" and the
117130: ** table has the three user-defined columns "a", "b", and "c", the following
117131: ** string is returned:
117132: **
117133: ** "docid, unzip(x.'a'), unzip(x.'b'), unzip(x.'c') FROM %_content AS x"
117134: **
117135: ** The pointer returned points to a buffer allocated by sqlite3_malloc(). It
117136: ** is the responsibility of the caller to eventually free it.
117137: **
117138: ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
117139: ** a NULL pointer is returned). Otherwise, if an OOM error is encountered
117140: ** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If
117141: ** no error occurs, *pRc is left unmodified.
117142: */
117143: static char *fts3ReadExprList(Fts3Table *p, const char *zFunc, int *pRc){
117144: char *zRet = 0;
117145: char *zFree = 0;
117146: char *zFunction;
117147: int i;
117148:
117149: if( p->zContentTbl==0 ){
117150: if( !zFunc ){
117151: zFunction = "";
117152: }else{
117153: zFree = zFunction = fts3QuoteId(zFunc);
117154: }
117155: fts3Appendf(pRc, &zRet, "docid");
117156: for(i=0; i<p->nColumn; i++){
117157: fts3Appendf(pRc, &zRet, ",%s(x.'c%d%q')", zFunction, i, p->azColumn[i]);
117158: }
117159: sqlite3_free(zFree);
117160: }else{
117161: fts3Appendf(pRc, &zRet, "rowid");
117162: for(i=0; i<p->nColumn; i++){
117163: fts3Appendf(pRc, &zRet, ", x.'%q'", p->azColumn[i]);
117164: }
117165: }
117166: fts3Appendf(pRc, &zRet, "FROM '%q'.'%q%s' AS x",
117167: p->zDb,
117168: (p->zContentTbl ? p->zContentTbl : p->zName),
117169: (p->zContentTbl ? "" : "_content")
117170: );
117171: return zRet;
117172: }
117173:
117174: /*
117175: ** Return a list of N comma separated question marks, where N is the number
117176: ** of columns in the %_content table (one for the docid plus one for each
117177: ** user-defined text column).
117178: **
117179: ** If argument zFunc is not NULL, then all but the first question mark
117180: ** is preceded by zFunc and an open bracket, and followed by a closed
117181: ** bracket. For example, if zFunc is "zip" and the FTS3 table has three
117182: ** user-defined text columns, the following string is returned:
117183: **
117184: ** "?, zip(?), zip(?), zip(?)"
117185: **
117186: ** The pointer returned points to a buffer allocated by sqlite3_malloc(). It
117187: ** is the responsibility of the caller to eventually free it.
117188: **
117189: ** If *pRc is not SQLITE_OK when this function is called, it is a no-op (and
117190: ** a NULL pointer is returned). Otherwise, if an OOM error is encountered
117191: ** by this function, NULL is returned and *pRc is set to SQLITE_NOMEM. If
117192: ** no error occurs, *pRc is left unmodified.
117193: */
117194: static char *fts3WriteExprList(Fts3Table *p, const char *zFunc, int *pRc){
117195: char *zRet = 0;
117196: char *zFree = 0;
117197: char *zFunction;
117198: int i;
117199:
117200: if( !zFunc ){
117201: zFunction = "";
117202: }else{
117203: zFree = zFunction = fts3QuoteId(zFunc);
117204: }
117205: fts3Appendf(pRc, &zRet, "?");
117206: for(i=0; i<p->nColumn; i++){
117207: fts3Appendf(pRc, &zRet, ",%s(?)", zFunction);
117208: }
117209: sqlite3_free(zFree);
117210: return zRet;
117211: }
117212:
117213: /*
117214: ** This function interprets the string at (*pp) as a non-negative integer
117215: ** value. It reads the integer and sets *pnOut to the value read, then
117216: ** sets *pp to point to the byte immediately following the last byte of
117217: ** the integer value.
117218: **
117219: ** Only decimal digits ('0'..'9') may be part of an integer value.
117220: **
117221: ** If *pp does not being with a decimal digit SQLITE_ERROR is returned and
117222: ** the output value undefined. Otherwise SQLITE_OK is returned.
117223: **
117224: ** This function is used when parsing the "prefix=" FTS4 parameter.
117225: */
117226: static int fts3GobbleInt(const char **pp, int *pnOut){
117227: const char *p; /* Iterator pointer */
117228: int nInt = 0; /* Output value */
117229:
117230: for(p=*pp; p[0]>='0' && p[0]<='9'; p++){
117231: nInt = nInt * 10 + (p[0] - '0');
117232: }
117233: if( p==*pp ) return SQLITE_ERROR;
117234: *pnOut = nInt;
117235: *pp = p;
117236: return SQLITE_OK;
117237: }
117238:
117239: /*
117240: ** This function is called to allocate an array of Fts3Index structures
117241: ** representing the indexes maintained by the current FTS table. FTS tables
117242: ** always maintain the main "terms" index, but may also maintain one or
117243: ** more "prefix" indexes, depending on the value of the "prefix=" parameter
117244: ** (if any) specified as part of the CREATE VIRTUAL TABLE statement.
117245: **
117246: ** Argument zParam is passed the value of the "prefix=" option if one was
117247: ** specified, or NULL otherwise.
117248: **
117249: ** If no error occurs, SQLITE_OK is returned and *apIndex set to point to
117250: ** the allocated array. *pnIndex is set to the number of elements in the
117251: ** array. If an error does occur, an SQLite error code is returned.
117252: **
117253: ** Regardless of whether or not an error is returned, it is the responsibility
117254: ** of the caller to call sqlite3_free() on the output array to free it.
117255: */
117256: static int fts3PrefixParameter(
117257: const char *zParam, /* ABC in prefix=ABC parameter to parse */
117258: int *pnIndex, /* OUT: size of *apIndex[] array */
117259: struct Fts3Index **apIndex /* OUT: Array of indexes for this table */
117260: ){
117261: struct Fts3Index *aIndex; /* Allocated array */
117262: int nIndex = 1; /* Number of entries in array */
117263:
117264: if( zParam && zParam[0] ){
117265: const char *p;
117266: nIndex++;
117267: for(p=zParam; *p; p++){
117268: if( *p==',' ) nIndex++;
117269: }
117270: }
117271:
117272: aIndex = sqlite3_malloc(sizeof(struct Fts3Index) * nIndex);
117273: *apIndex = aIndex;
117274: *pnIndex = nIndex;
117275: if( !aIndex ){
117276: return SQLITE_NOMEM;
117277: }
117278:
117279: memset(aIndex, 0, sizeof(struct Fts3Index) * nIndex);
117280: if( zParam ){
117281: const char *p = zParam;
117282: int i;
117283: for(i=1; i<nIndex; i++){
117284: int nPrefix;
117285: if( fts3GobbleInt(&p, &nPrefix) ) return SQLITE_ERROR;
117286: aIndex[i].nPrefix = nPrefix;
117287: p++;
117288: }
117289: }
117290:
117291: return SQLITE_OK;
117292: }
117293:
117294: /*
117295: ** This function is called when initializing an FTS4 table that uses the
117296: ** content=xxx option. It determines the number of and names of the columns
117297: ** of the new FTS4 table.
117298: **
117299: ** The third argument passed to this function is the value passed to the
117300: ** config=xxx option (i.e. "xxx"). This function queries the database for
117301: ** a table of that name. If found, the output variables are populated
117302: ** as follows:
117303: **
117304: ** *pnCol: Set to the number of columns table xxx has,
117305: **
117306: ** *pnStr: Set to the total amount of space required to store a copy
117307: ** of each columns name, including the nul-terminator.
117308: **
117309: ** *pazCol: Set to point to an array of *pnCol strings. Each string is
117310: ** the name of the corresponding column in table xxx. The array
117311: ** and its contents are allocated using a single allocation. It
117312: ** is the responsibility of the caller to free this allocation
117313: ** by eventually passing the *pazCol value to sqlite3_free().
117314: **
117315: ** If the table cannot be found, an error code is returned and the output
117316: ** variables are undefined. Or, if an OOM is encountered, SQLITE_NOMEM is
117317: ** returned (and the output variables are undefined).
117318: */
117319: static int fts3ContentColumns(
117320: sqlite3 *db, /* Database handle */
117321: const char *zDb, /* Name of db (i.e. "main", "temp" etc.) */
117322: const char *zTbl, /* Name of content table */
117323: const char ***pazCol, /* OUT: Malloc'd array of column names */
117324: int *pnCol, /* OUT: Size of array *pazCol */
117325: int *pnStr /* OUT: Bytes of string content */
117326: ){
117327: int rc = SQLITE_OK; /* Return code */
117328: char *zSql; /* "SELECT *" statement on zTbl */
117329: sqlite3_stmt *pStmt = 0; /* Compiled version of zSql */
117330:
117331: zSql = sqlite3_mprintf("SELECT * FROM %Q.%Q", zDb, zTbl);
117332: if( !zSql ){
117333: rc = SQLITE_NOMEM;
117334: }else{
117335: rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
117336: }
117337: sqlite3_free(zSql);
117338:
117339: if( rc==SQLITE_OK ){
117340: const char **azCol; /* Output array */
117341: int nStr = 0; /* Size of all column names (incl. 0x00) */
117342: int nCol; /* Number of table columns */
117343: int i; /* Used to iterate through columns */
117344:
117345: /* Loop through the returned columns. Set nStr to the number of bytes of
117346: ** space required to store a copy of each column name, including the
117347: ** nul-terminator byte. */
117348: nCol = sqlite3_column_count(pStmt);
117349: for(i=0; i<nCol; i++){
117350: const char *zCol = sqlite3_column_name(pStmt, i);
117351: nStr += strlen(zCol) + 1;
117352: }
117353:
117354: /* Allocate and populate the array to return. */
117355: azCol = (const char **)sqlite3_malloc(sizeof(char *) * nCol + nStr);
117356: if( azCol==0 ){
117357: rc = SQLITE_NOMEM;
117358: }else{
117359: char *p = (char *)&azCol[nCol];
117360: for(i=0; i<nCol; i++){
117361: const char *zCol = sqlite3_column_name(pStmt, i);
117362: int n = strlen(zCol)+1;
117363: memcpy(p, zCol, n);
117364: azCol[i] = p;
117365: p += n;
117366: }
117367: }
117368: sqlite3_finalize(pStmt);
117369:
117370: /* Set the output variables. */
117371: *pnCol = nCol;
117372: *pnStr = nStr;
117373: *pazCol = azCol;
117374: }
117375:
117376: return rc;
117377: }
117378:
117379: /*
117380: ** This function is the implementation of both the xConnect and xCreate
117381: ** methods of the FTS3 virtual table.
117382: **
117383: ** The argv[] array contains the following:
117384: **
117385: ** argv[0] -> module name ("fts3" or "fts4")
117386: ** argv[1] -> database name
117387: ** argv[2] -> table name
117388: ** argv[...] -> "column name" and other module argument fields.
117389: */
117390: static int fts3InitVtab(
117391: int isCreate, /* True for xCreate, false for xConnect */
117392: sqlite3 *db, /* The SQLite database connection */
117393: void *pAux, /* Hash table containing tokenizers */
117394: int argc, /* Number of elements in argv array */
117395: const char * const *argv, /* xCreate/xConnect argument array */
117396: sqlite3_vtab **ppVTab, /* Write the resulting vtab structure here */
117397: char **pzErr /* Write any error message here */
117398: ){
117399: Fts3Hash *pHash = (Fts3Hash *)pAux;
117400: Fts3Table *p = 0; /* Pointer to allocated vtab */
117401: int rc = SQLITE_OK; /* Return code */
117402: int i; /* Iterator variable */
117403: int nByte; /* Size of allocation used for *p */
117404: int iCol; /* Column index */
117405: int nString = 0; /* Bytes required to hold all column names */
117406: int nCol = 0; /* Number of columns in the FTS table */
117407: char *zCsr; /* Space for holding column names */
117408: int nDb; /* Bytes required to hold database name */
117409: int nName; /* Bytes required to hold table name */
117410: int isFts4 = (argv[0][3]=='4'); /* True for FTS4, false for FTS3 */
117411: const char **aCol; /* Array of column names */
117412: sqlite3_tokenizer *pTokenizer = 0; /* Tokenizer for this table */
117413:
117414: int nIndex; /* Size of aIndex[] array */
117415: struct Fts3Index *aIndex = 0; /* Array of indexes for this table */
117416:
117417: /* The results of parsing supported FTS4 key=value options: */
117418: int bNoDocsize = 0; /* True to omit %_docsize table */
117419: int bDescIdx = 0; /* True to store descending indexes */
117420: char *zPrefix = 0; /* Prefix parameter value (or NULL) */
117421: char *zCompress = 0; /* compress=? parameter (or NULL) */
117422: char *zUncompress = 0; /* uncompress=? parameter (or NULL) */
117423: char *zContent = 0; /* content=? parameter (or NULL) */
117424:
117425: assert( strlen(argv[0])==4 );
117426: assert( (sqlite3_strnicmp(argv[0], "fts4", 4)==0 && isFts4)
117427: || (sqlite3_strnicmp(argv[0], "fts3", 4)==0 && !isFts4)
117428: );
117429:
117430: nDb = (int)strlen(argv[1]) + 1;
117431: nName = (int)strlen(argv[2]) + 1;
117432:
117433: aCol = (const char **)sqlite3_malloc(sizeof(const char *) * (argc-2) );
117434: if( !aCol ) return SQLITE_NOMEM;
117435: memset((void *)aCol, 0, sizeof(const char *) * (argc-2));
117436:
117437: /* Loop through all of the arguments passed by the user to the FTS3/4
117438: ** module (i.e. all the column names and special arguments). This loop
117439: ** does the following:
117440: **
117441: ** + Figures out the number of columns the FTSX table will have, and
117442: ** the number of bytes of space that must be allocated to store copies
117443: ** of the column names.
117444: **
117445: ** + If there is a tokenizer specification included in the arguments,
117446: ** initializes the tokenizer pTokenizer.
117447: */
117448: for(i=3; rc==SQLITE_OK && i<argc; i++){
117449: char const *z = argv[i];
117450: int nKey;
117451: char *zVal;
117452:
117453: /* Check if this is a tokenizer specification */
117454: if( !pTokenizer
117455: && strlen(z)>8
117456: && 0==sqlite3_strnicmp(z, "tokenize", 8)
117457: && 0==sqlite3Fts3IsIdChar(z[8])
117458: ){
117459: rc = sqlite3Fts3InitTokenizer(pHash, &z[9], &pTokenizer, pzErr);
117460: }
117461:
117462: /* Check if it is an FTS4 special argument. */
117463: else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){
117464: struct Fts4Option {
117465: const char *zOpt;
117466: int nOpt;
117467: } aFts4Opt[] = {
117468: { "matchinfo", 9 }, /* 0 -> MATCHINFO */
117469: { "prefix", 6 }, /* 1 -> PREFIX */
117470: { "compress", 8 }, /* 2 -> COMPRESS */
117471: { "uncompress", 10 }, /* 3 -> UNCOMPRESS */
117472: { "order", 5 }, /* 4 -> ORDER */
117473: { "content", 7 } /* 5 -> CONTENT */
117474: };
117475:
117476: int iOpt;
117477: if( !zVal ){
117478: rc = SQLITE_NOMEM;
117479: }else{
117480: for(iOpt=0; iOpt<SizeofArray(aFts4Opt); iOpt++){
117481: struct Fts4Option *pOp = &aFts4Opt[iOpt];
117482: if( nKey==pOp->nOpt && !sqlite3_strnicmp(z, pOp->zOpt, pOp->nOpt) ){
117483: break;
117484: }
117485: }
117486: if( iOpt==SizeofArray(aFts4Opt) ){
117487: *pzErr = sqlite3_mprintf("unrecognized parameter: %s", z);
117488: rc = SQLITE_ERROR;
117489: }else{
117490: switch( iOpt ){
117491: case 0: /* MATCHINFO */
117492: if( strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "fts3", 4) ){
117493: *pzErr = sqlite3_mprintf("unrecognized matchinfo: %s", zVal);
117494: rc = SQLITE_ERROR;
117495: }
117496: bNoDocsize = 1;
117497: break;
117498:
117499: case 1: /* PREFIX */
117500: sqlite3_free(zPrefix);
117501: zPrefix = zVal;
117502: zVal = 0;
117503: break;
117504:
117505: case 2: /* COMPRESS */
117506: sqlite3_free(zCompress);
117507: zCompress = zVal;
117508: zVal = 0;
117509: break;
117510:
117511: case 3: /* UNCOMPRESS */
117512: sqlite3_free(zUncompress);
117513: zUncompress = zVal;
117514: zVal = 0;
117515: break;
117516:
117517: case 4: /* ORDER */
117518: if( (strlen(zVal)!=3 || sqlite3_strnicmp(zVal, "asc", 3))
117519: && (strlen(zVal)!=4 || sqlite3_strnicmp(zVal, "desc", 4))
117520: ){
117521: *pzErr = sqlite3_mprintf("unrecognized order: %s", zVal);
117522: rc = SQLITE_ERROR;
117523: }
117524: bDescIdx = (zVal[0]=='d' || zVal[0]=='D');
117525: break;
117526:
117527: default: /* CONTENT */
117528: assert( iOpt==5 );
117529: sqlite3_free(zUncompress);
117530: zContent = zVal;
117531: zVal = 0;
117532: break;
117533: }
117534: }
117535: sqlite3_free(zVal);
117536: }
117537: }
117538:
117539: /* Otherwise, the argument is a column name. */
117540: else {
117541: nString += (int)(strlen(z) + 1);
117542: aCol[nCol++] = z;
117543: }
117544: }
117545:
117546: /* If a content=xxx option was specified, the following:
117547: **
117548: ** 1. Ignore any compress= and uncompress= options.
117549: **
117550: ** 2. If no column names were specified as part of the CREATE VIRTUAL
117551: ** TABLE statement, use all columns from the content table.
117552: */
117553: if( rc==SQLITE_OK && zContent ){
117554: sqlite3_free(zCompress);
117555: sqlite3_free(zUncompress);
117556: zCompress = 0;
117557: zUncompress = 0;
117558: if( nCol==0 ){
117559: sqlite3_free((void*)aCol);
117560: aCol = 0;
117561: rc = fts3ContentColumns(db, argv[1], zContent, &aCol, &nCol, &nString);
117562: }
117563: assert( rc!=SQLITE_OK || nCol>0 );
117564: }
117565: if( rc!=SQLITE_OK ) goto fts3_init_out;
117566:
117567: if( nCol==0 ){
117568: assert( nString==0 );
117569: aCol[0] = "content";
117570: nString = 8;
117571: nCol = 1;
117572: }
117573:
117574: if( pTokenizer==0 ){
117575: rc = sqlite3Fts3InitTokenizer(pHash, "simple", &pTokenizer, pzErr);
117576: if( rc!=SQLITE_OK ) goto fts3_init_out;
117577: }
117578: assert( pTokenizer );
117579:
117580: rc = fts3PrefixParameter(zPrefix, &nIndex, &aIndex);
117581: if( rc==SQLITE_ERROR ){
117582: assert( zPrefix );
117583: *pzErr = sqlite3_mprintf("error parsing prefix parameter: %s", zPrefix);
117584: }
117585: if( rc!=SQLITE_OK ) goto fts3_init_out;
117586:
117587: /* Allocate and populate the Fts3Table structure. */
117588: nByte = sizeof(Fts3Table) + /* Fts3Table */
117589: nCol * sizeof(char *) + /* azColumn */
117590: nIndex * sizeof(struct Fts3Index) + /* aIndex */
117591: nName + /* zName */
117592: nDb + /* zDb */
117593: nString; /* Space for azColumn strings */
117594: p = (Fts3Table*)sqlite3_malloc(nByte);
117595: if( p==0 ){
117596: rc = SQLITE_NOMEM;
117597: goto fts3_init_out;
117598: }
117599: memset(p, 0, nByte);
117600: p->db = db;
117601: p->nColumn = nCol;
117602: p->nPendingData = 0;
117603: p->azColumn = (char **)&p[1];
117604: p->pTokenizer = pTokenizer;
117605: p->nMaxPendingData = FTS3_MAX_PENDING_DATA;
117606: p->bHasDocsize = (isFts4 && bNoDocsize==0);
117607: p->bHasStat = isFts4;
117608: p->bDescIdx = bDescIdx;
117609: p->zContentTbl = zContent;
117610: zContent = 0;
117611: TESTONLY( p->inTransaction = -1 );
117612: TESTONLY( p->mxSavepoint = -1 );
117613:
117614: p->aIndex = (struct Fts3Index *)&p->azColumn[nCol];
117615: memcpy(p->aIndex, aIndex, sizeof(struct Fts3Index) * nIndex);
117616: p->nIndex = nIndex;
117617: for(i=0; i<nIndex; i++){
117618: fts3HashInit(&p->aIndex[i].hPending, FTS3_HASH_STRING, 1);
117619: }
117620:
117621: /* Fill in the zName and zDb fields of the vtab structure. */
117622: zCsr = (char *)&p->aIndex[nIndex];
117623: p->zName = zCsr;
117624: memcpy(zCsr, argv[2], nName);
117625: zCsr += nName;
117626: p->zDb = zCsr;
117627: memcpy(zCsr, argv[1], nDb);
117628: zCsr += nDb;
117629:
117630: /* Fill in the azColumn array */
117631: for(iCol=0; iCol<nCol; iCol++){
117632: char *z;
117633: int n = 0;
117634: z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
117635: memcpy(zCsr, z, n);
117636: zCsr[n] = '\0';
117637: sqlite3Fts3Dequote(zCsr);
117638: p->azColumn[iCol] = zCsr;
117639: zCsr += n+1;
117640: assert( zCsr <= &((char *)p)[nByte] );
117641: }
117642:
117643: if( (zCompress==0)!=(zUncompress==0) ){
117644: char const *zMiss = (zCompress==0 ? "compress" : "uncompress");
117645: rc = SQLITE_ERROR;
117646: *pzErr = sqlite3_mprintf("missing %s parameter in fts4 constructor", zMiss);
117647: }
117648: p->zReadExprlist = fts3ReadExprList(p, zUncompress, &rc);
117649: p->zWriteExprlist = fts3WriteExprList(p, zCompress, &rc);
117650: if( rc!=SQLITE_OK ) goto fts3_init_out;
117651:
117652: /* If this is an xCreate call, create the underlying tables in the
117653: ** database. TODO: For xConnect(), it could verify that said tables exist.
117654: */
117655: if( isCreate ){
117656: rc = fts3CreateTables(p);
117657: }
117658:
117659: /* Figure out the page-size for the database. This is required in order to
117660: ** estimate the cost of loading large doclists from the database. */
117661: fts3DatabasePageSize(&rc, p);
117662: p->nNodeSize = p->nPgsz-35;
117663:
117664: /* Declare the table schema to SQLite. */
117665: fts3DeclareVtab(&rc, p);
117666:
117667: fts3_init_out:
117668: sqlite3_free(zPrefix);
117669: sqlite3_free(aIndex);
117670: sqlite3_free(zCompress);
117671: sqlite3_free(zUncompress);
117672: sqlite3_free(zContent);
117673: sqlite3_free((void *)aCol);
117674: if( rc!=SQLITE_OK ){
117675: if( p ){
117676: fts3DisconnectMethod((sqlite3_vtab *)p);
117677: }else if( pTokenizer ){
117678: pTokenizer->pModule->xDestroy(pTokenizer);
117679: }
117680: }else{
117681: assert( p->pSegments==0 );
117682: *ppVTab = &p->base;
117683: }
117684: return rc;
117685: }
117686:
117687: /*
117688: ** The xConnect() and xCreate() methods for the virtual table. All the
117689: ** work is done in function fts3InitVtab().
117690: */
117691: static int fts3ConnectMethod(
117692: sqlite3 *db, /* Database connection */
117693: void *pAux, /* Pointer to tokenizer hash table */
117694: int argc, /* Number of elements in argv array */
117695: const char * const *argv, /* xCreate/xConnect argument array */
117696: sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
117697: char **pzErr /* OUT: sqlite3_malloc'd error message */
117698: ){
117699: return fts3InitVtab(0, db, pAux, argc, argv, ppVtab, pzErr);
117700: }
117701: static int fts3CreateMethod(
117702: sqlite3 *db, /* Database connection */
117703: void *pAux, /* Pointer to tokenizer hash table */
117704: int argc, /* Number of elements in argv array */
117705: const char * const *argv, /* xCreate/xConnect argument array */
117706: sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
117707: char **pzErr /* OUT: sqlite3_malloc'd error message */
117708: ){
117709: return fts3InitVtab(1, db, pAux, argc, argv, ppVtab, pzErr);
117710: }
117711:
117712: /*
117713: ** Implementation of the xBestIndex method for FTS3 tables. There
117714: ** are three possible strategies, in order of preference:
117715: **
117716: ** 1. Direct lookup by rowid or docid.
117717: ** 2. Full-text search using a MATCH operator on a non-docid column.
117718: ** 3. Linear scan of %_content table.
117719: */
117720: static int fts3BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
117721: Fts3Table *p = (Fts3Table *)pVTab;
117722: int i; /* Iterator variable */
117723: int iCons = -1; /* Index of constraint to use */
117724:
117725: /* By default use a full table scan. This is an expensive option,
117726: ** so search through the constraints to see if a more efficient
117727: ** strategy is possible.
117728: */
117729: pInfo->idxNum = FTS3_FULLSCAN_SEARCH;
117730: pInfo->estimatedCost = 500000;
117731: for(i=0; i<pInfo->nConstraint; i++){
117732: struct sqlite3_index_constraint *pCons = &pInfo->aConstraint[i];
117733: if( pCons->usable==0 ) continue;
117734:
117735: /* A direct lookup on the rowid or docid column. Assign a cost of 1.0. */
117736: if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ
117737: && (pCons->iColumn<0 || pCons->iColumn==p->nColumn+1 )
117738: ){
117739: pInfo->idxNum = FTS3_DOCID_SEARCH;
117740: pInfo->estimatedCost = 1.0;
117741: iCons = i;
117742: }
117743:
117744: /* A MATCH constraint. Use a full-text search.
117745: **
117746: ** If there is more than one MATCH constraint available, use the first
117747: ** one encountered. If there is both a MATCH constraint and a direct
117748: ** rowid/docid lookup, prefer the MATCH strategy. This is done even
117749: ** though the rowid/docid lookup is faster than a MATCH query, selecting
117750: ** it would lead to an "unable to use function MATCH in the requested
117751: ** context" error.
117752: */
117753: if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH
117754: && pCons->iColumn>=0 && pCons->iColumn<=p->nColumn
117755: ){
117756: pInfo->idxNum = FTS3_FULLTEXT_SEARCH + pCons->iColumn;
117757: pInfo->estimatedCost = 2.0;
117758: iCons = i;
117759: break;
117760: }
117761: }
117762:
117763: if( iCons>=0 ){
117764: pInfo->aConstraintUsage[iCons].argvIndex = 1;
117765: pInfo->aConstraintUsage[iCons].omit = 1;
117766: }
117767:
117768: /* Regardless of the strategy selected, FTS can deliver rows in rowid (or
117769: ** docid) order. Both ascending and descending are possible.
117770: */
117771: if( pInfo->nOrderBy==1 ){
117772: struct sqlite3_index_orderby *pOrder = &pInfo->aOrderBy[0];
117773: if( pOrder->iColumn<0 || pOrder->iColumn==p->nColumn+1 ){
117774: if( pOrder->desc ){
117775: pInfo->idxStr = "DESC";
117776: }else{
117777: pInfo->idxStr = "ASC";
117778: }
117779: pInfo->orderByConsumed = 1;
117780: }
117781: }
117782:
117783: assert( p->pSegments==0 );
117784: return SQLITE_OK;
117785: }
117786:
117787: /*
117788: ** Implementation of xOpen method.
117789: */
117790: static int fts3OpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){
117791: sqlite3_vtab_cursor *pCsr; /* Allocated cursor */
117792:
117793: UNUSED_PARAMETER(pVTab);
117794:
117795: /* Allocate a buffer large enough for an Fts3Cursor structure. If the
117796: ** allocation succeeds, zero it and return SQLITE_OK. Otherwise,
117797: ** if the allocation fails, return SQLITE_NOMEM.
117798: */
117799: *ppCsr = pCsr = (sqlite3_vtab_cursor *)sqlite3_malloc(sizeof(Fts3Cursor));
117800: if( !pCsr ){
117801: return SQLITE_NOMEM;
117802: }
117803: memset(pCsr, 0, sizeof(Fts3Cursor));
117804: return SQLITE_OK;
117805: }
117806:
117807: /*
117808: ** Close the cursor. For additional information see the documentation
117809: ** on the xClose method of the virtual table interface.
117810: */
117811: static int fts3CloseMethod(sqlite3_vtab_cursor *pCursor){
117812: Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
117813: assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
117814: sqlite3_finalize(pCsr->pStmt);
117815: sqlite3Fts3ExprFree(pCsr->pExpr);
117816: sqlite3Fts3FreeDeferredTokens(pCsr);
117817: sqlite3_free(pCsr->aDoclist);
117818: sqlite3_free(pCsr->aMatchinfo);
117819: assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
117820: sqlite3_free(pCsr);
117821: return SQLITE_OK;
117822: }
117823:
117824: /*
117825: ** If pCsr->pStmt has not been prepared (i.e. if pCsr->pStmt==0), then
117826: ** compose and prepare an SQL statement of the form:
117827: **
117828: ** "SELECT <columns> FROM %_content WHERE rowid = ?"
117829: **
117830: ** (or the equivalent for a content=xxx table) and set pCsr->pStmt to
117831: ** it. If an error occurs, return an SQLite error code.
117832: **
117833: ** Otherwise, set *ppStmt to point to pCsr->pStmt and return SQLITE_OK.
117834: */
117835: static int fts3CursorSeekStmt(Fts3Cursor *pCsr, sqlite3_stmt **ppStmt){
117836: int rc = SQLITE_OK;
117837: if( pCsr->pStmt==0 ){
117838: Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
117839: char *zSql;
117840: zSql = sqlite3_mprintf("SELECT %s WHERE rowid = ?", p->zReadExprlist);
117841: if( !zSql ) return SQLITE_NOMEM;
117842: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
117843: sqlite3_free(zSql);
117844: }
117845: *ppStmt = pCsr->pStmt;
117846: return rc;
117847: }
117848:
117849: /*
117850: ** Position the pCsr->pStmt statement so that it is on the row
117851: ** of the %_content table that contains the last match. Return
117852: ** SQLITE_OK on success.
117853: */
117854: static int fts3CursorSeek(sqlite3_context *pContext, Fts3Cursor *pCsr){
117855: int rc = SQLITE_OK;
117856: if( pCsr->isRequireSeek ){
117857: sqlite3_stmt *pStmt = 0;
117858:
117859: rc = fts3CursorSeekStmt(pCsr, &pStmt);
117860: if( rc==SQLITE_OK ){
117861: sqlite3_bind_int64(pCsr->pStmt, 1, pCsr->iPrevId);
117862: pCsr->isRequireSeek = 0;
117863: if( SQLITE_ROW==sqlite3_step(pCsr->pStmt) ){
117864: return SQLITE_OK;
117865: }else{
117866: rc = sqlite3_reset(pCsr->pStmt);
117867: if( rc==SQLITE_OK && ((Fts3Table *)pCsr->base.pVtab)->zContentTbl==0 ){
117868: /* If no row was found and no error has occured, then the %_content
117869: ** table is missing a row that is present in the full-text index.
117870: ** The data structures are corrupt. */
117871: rc = FTS_CORRUPT_VTAB;
117872: pCsr->isEof = 1;
117873: }
117874: }
117875: }
117876: }
117877:
117878: if( rc!=SQLITE_OK && pContext ){
117879: sqlite3_result_error_code(pContext, rc);
117880: }
117881: return rc;
117882: }
117883:
117884: /*
117885: ** This function is used to process a single interior node when searching
117886: ** a b-tree for a term or term prefix. The node data is passed to this
117887: ** function via the zNode/nNode parameters. The term to search for is
117888: ** passed in zTerm/nTerm.
117889: **
117890: ** If piFirst is not NULL, then this function sets *piFirst to the blockid
117891: ** of the child node that heads the sub-tree that may contain the term.
117892: **
117893: ** If piLast is not NULL, then *piLast is set to the right-most child node
117894: ** that heads a sub-tree that may contain a term for which zTerm/nTerm is
117895: ** a prefix.
117896: **
117897: ** If an OOM error occurs, SQLITE_NOMEM is returned. Otherwise, SQLITE_OK.
117898: */
117899: static int fts3ScanInteriorNode(
117900: const char *zTerm, /* Term to select leaves for */
117901: int nTerm, /* Size of term zTerm in bytes */
117902: const char *zNode, /* Buffer containing segment interior node */
117903: int nNode, /* Size of buffer at zNode */
117904: sqlite3_int64 *piFirst, /* OUT: Selected child node */
117905: sqlite3_int64 *piLast /* OUT: Selected child node */
117906: ){
117907: int rc = SQLITE_OK; /* Return code */
117908: const char *zCsr = zNode; /* Cursor to iterate through node */
117909: const char *zEnd = &zCsr[nNode];/* End of interior node buffer */
117910: char *zBuffer = 0; /* Buffer to load terms into */
117911: int nAlloc = 0; /* Size of allocated buffer */
117912: int isFirstTerm = 1; /* True when processing first term on page */
117913: sqlite3_int64 iChild; /* Block id of child node to descend to */
117914:
117915: /* Skip over the 'height' varint that occurs at the start of every
117916: ** interior node. Then load the blockid of the left-child of the b-tree
117917: ** node into variable iChild.
117918: **
117919: ** Even if the data structure on disk is corrupted, this (reading two
117920: ** varints from the buffer) does not risk an overread. If zNode is a
117921: ** root node, then the buffer comes from a SELECT statement. SQLite does
117922: ** not make this guarantee explicitly, but in practice there are always
117923: ** either more than 20 bytes of allocated space following the nNode bytes of
117924: ** contents, or two zero bytes. Or, if the node is read from the %_segments
117925: ** table, then there are always 20 bytes of zeroed padding following the
117926: ** nNode bytes of content (see sqlite3Fts3ReadBlock() for details).
117927: */
117928: zCsr += sqlite3Fts3GetVarint(zCsr, &iChild);
117929: zCsr += sqlite3Fts3GetVarint(zCsr, &iChild);
117930: if( zCsr>zEnd ){
117931: return FTS_CORRUPT_VTAB;
117932: }
117933:
117934: while( zCsr<zEnd && (piFirst || piLast) ){
117935: int cmp; /* memcmp() result */
117936: int nSuffix; /* Size of term suffix */
117937: int nPrefix = 0; /* Size of term prefix */
117938: int nBuffer; /* Total term size */
117939:
117940: /* Load the next term on the node into zBuffer. Use realloc() to expand
117941: ** the size of zBuffer if required. */
117942: if( !isFirstTerm ){
117943: zCsr += sqlite3Fts3GetVarint32(zCsr, &nPrefix);
117944: }
117945: isFirstTerm = 0;
117946: zCsr += sqlite3Fts3GetVarint32(zCsr, &nSuffix);
117947:
117948: if( nPrefix<0 || nSuffix<0 || &zCsr[nSuffix]>zEnd ){
117949: rc = FTS_CORRUPT_VTAB;
117950: goto finish_scan;
117951: }
117952: if( nPrefix+nSuffix>nAlloc ){
117953: char *zNew;
117954: nAlloc = (nPrefix+nSuffix) * 2;
117955: zNew = (char *)sqlite3_realloc(zBuffer, nAlloc);
117956: if( !zNew ){
117957: rc = SQLITE_NOMEM;
117958: goto finish_scan;
117959: }
117960: zBuffer = zNew;
117961: }
117962: assert( zBuffer );
117963: memcpy(&zBuffer[nPrefix], zCsr, nSuffix);
117964: nBuffer = nPrefix + nSuffix;
117965: zCsr += nSuffix;
117966:
117967: /* Compare the term we are searching for with the term just loaded from
117968: ** the interior node. If the specified term is greater than or equal
117969: ** to the term from the interior node, then all terms on the sub-tree
117970: ** headed by node iChild are smaller than zTerm. No need to search
117971: ** iChild.
117972: **
117973: ** If the interior node term is larger than the specified term, then
117974: ** the tree headed by iChild may contain the specified term.
117975: */
117976: cmp = memcmp(zTerm, zBuffer, (nBuffer>nTerm ? nTerm : nBuffer));
117977: if( piFirst && (cmp<0 || (cmp==0 && nBuffer>nTerm)) ){
117978: *piFirst = iChild;
117979: piFirst = 0;
117980: }
117981:
117982: if( piLast && cmp<0 ){
117983: *piLast = iChild;
117984: piLast = 0;
117985: }
117986:
117987: iChild++;
117988: };
117989:
117990: if( piFirst ) *piFirst = iChild;
117991: if( piLast ) *piLast = iChild;
117992:
117993: finish_scan:
117994: sqlite3_free(zBuffer);
117995: return rc;
117996: }
117997:
117998:
117999: /*
118000: ** The buffer pointed to by argument zNode (size nNode bytes) contains an
118001: ** interior node of a b-tree segment. The zTerm buffer (size nTerm bytes)
118002: ** contains a term. This function searches the sub-tree headed by the zNode
118003: ** node for the range of leaf nodes that may contain the specified term
118004: ** or terms for which the specified term is a prefix.
118005: **
118006: ** If piLeaf is not NULL, then *piLeaf is set to the blockid of the
118007: ** left-most leaf node in the tree that may contain the specified term.
118008: ** If piLeaf2 is not NULL, then *piLeaf2 is set to the blockid of the
118009: ** right-most leaf node that may contain a term for which the specified
118010: ** term is a prefix.
118011: **
118012: ** It is possible that the range of returned leaf nodes does not contain
118013: ** the specified term or any terms for which it is a prefix. However, if the
118014: ** segment does contain any such terms, they are stored within the identified
118015: ** range. Because this function only inspects interior segment nodes (and
118016: ** never loads leaf nodes into memory), it is not possible to be sure.
118017: **
118018: ** If an error occurs, an error code other than SQLITE_OK is returned.
118019: */
118020: static int fts3SelectLeaf(
118021: Fts3Table *p, /* Virtual table handle */
118022: const char *zTerm, /* Term to select leaves for */
118023: int nTerm, /* Size of term zTerm in bytes */
118024: const char *zNode, /* Buffer containing segment interior node */
118025: int nNode, /* Size of buffer at zNode */
118026: sqlite3_int64 *piLeaf, /* Selected leaf node */
118027: sqlite3_int64 *piLeaf2 /* Selected leaf node */
118028: ){
118029: int rc; /* Return code */
118030: int iHeight; /* Height of this node in tree */
118031:
118032: assert( piLeaf || piLeaf2 );
118033:
118034: sqlite3Fts3GetVarint32(zNode, &iHeight);
118035: rc = fts3ScanInteriorNode(zTerm, nTerm, zNode, nNode, piLeaf, piLeaf2);
118036: assert( !piLeaf2 || !piLeaf || rc!=SQLITE_OK || (*piLeaf<=*piLeaf2) );
118037:
118038: if( rc==SQLITE_OK && iHeight>1 ){
118039: char *zBlob = 0; /* Blob read from %_segments table */
118040: int nBlob; /* Size of zBlob in bytes */
118041:
118042: if( piLeaf && piLeaf2 && (*piLeaf!=*piLeaf2) ){
118043: rc = sqlite3Fts3ReadBlock(p, *piLeaf, &zBlob, &nBlob, 0);
118044: if( rc==SQLITE_OK ){
118045: rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, 0);
118046: }
118047: sqlite3_free(zBlob);
118048: piLeaf = 0;
118049: zBlob = 0;
118050: }
118051:
118052: if( rc==SQLITE_OK ){
118053: rc = sqlite3Fts3ReadBlock(p, piLeaf?*piLeaf:*piLeaf2, &zBlob, &nBlob, 0);
118054: }
118055: if( rc==SQLITE_OK ){
118056: rc = fts3SelectLeaf(p, zTerm, nTerm, zBlob, nBlob, piLeaf, piLeaf2);
118057: }
118058: sqlite3_free(zBlob);
118059: }
118060:
118061: return rc;
118062: }
118063:
118064: /*
118065: ** This function is used to create delta-encoded serialized lists of FTS3
118066: ** varints. Each call to this function appends a single varint to a list.
118067: */
118068: static void fts3PutDeltaVarint(
118069: char **pp, /* IN/OUT: Output pointer */
118070: sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
118071: sqlite3_int64 iVal /* Write this value to the list */
118072: ){
118073: assert( iVal-*piPrev > 0 || (*piPrev==0 && iVal==0) );
118074: *pp += sqlite3Fts3PutVarint(*pp, iVal-*piPrev);
118075: *piPrev = iVal;
118076: }
118077:
118078: /*
118079: ** When this function is called, *ppPoslist is assumed to point to the
118080: ** start of a position-list. After it returns, *ppPoslist points to the
118081: ** first byte after the position-list.
118082: **
118083: ** A position list is list of positions (delta encoded) and columns for
118084: ** a single document record of a doclist. So, in other words, this
118085: ** routine advances *ppPoslist so that it points to the next docid in
118086: ** the doclist, or to the first byte past the end of the doclist.
118087: **
118088: ** If pp is not NULL, then the contents of the position list are copied
118089: ** to *pp. *pp is set to point to the first byte past the last byte copied
118090: ** before this function returns.
118091: */
118092: static void fts3PoslistCopy(char **pp, char **ppPoslist){
118093: char *pEnd = *ppPoslist;
118094: char c = 0;
118095:
118096: /* The end of a position list is marked by a zero encoded as an FTS3
118097: ** varint. A single POS_END (0) byte. Except, if the 0 byte is preceded by
118098: ** a byte with the 0x80 bit set, then it is not a varint 0, but the tail
118099: ** of some other, multi-byte, value.
118100: **
118101: ** The following while-loop moves pEnd to point to the first byte that is not
118102: ** immediately preceded by a byte with the 0x80 bit set. Then increments
118103: ** pEnd once more so that it points to the byte immediately following the
118104: ** last byte in the position-list.
118105: */
118106: while( *pEnd | c ){
118107: c = *pEnd++ & 0x80;
118108: testcase( c!=0 && (*pEnd)==0 );
118109: }
118110: pEnd++; /* Advance past the POS_END terminator byte */
118111:
118112: if( pp ){
118113: int n = (int)(pEnd - *ppPoslist);
118114: char *p = *pp;
118115: memcpy(p, *ppPoslist, n);
118116: p += n;
118117: *pp = p;
118118: }
118119: *ppPoslist = pEnd;
118120: }
118121:
118122: /*
118123: ** When this function is called, *ppPoslist is assumed to point to the
118124: ** start of a column-list. After it returns, *ppPoslist points to the
118125: ** to the terminator (POS_COLUMN or POS_END) byte of the column-list.
118126: **
118127: ** A column-list is list of delta-encoded positions for a single column
118128: ** within a single document within a doclist.
118129: **
118130: ** The column-list is terminated either by a POS_COLUMN varint (1) or
118131: ** a POS_END varint (0). This routine leaves *ppPoslist pointing to
118132: ** the POS_COLUMN or POS_END that terminates the column-list.
118133: **
118134: ** If pp is not NULL, then the contents of the column-list are copied
118135: ** to *pp. *pp is set to point to the first byte past the last byte copied
118136: ** before this function returns. The POS_COLUMN or POS_END terminator
118137: ** is not copied into *pp.
118138: */
118139: static void fts3ColumnlistCopy(char **pp, char **ppPoslist){
118140: char *pEnd = *ppPoslist;
118141: char c = 0;
118142:
118143: /* A column-list is terminated by either a 0x01 or 0x00 byte that is
118144: ** not part of a multi-byte varint.
118145: */
118146: while( 0xFE & (*pEnd | c) ){
118147: c = *pEnd++ & 0x80;
118148: testcase( c!=0 && ((*pEnd)&0xfe)==0 );
118149: }
118150: if( pp ){
118151: int n = (int)(pEnd - *ppPoslist);
118152: char *p = *pp;
118153: memcpy(p, *ppPoslist, n);
118154: p += n;
118155: *pp = p;
118156: }
118157: *ppPoslist = pEnd;
118158: }
118159:
118160: /*
118161: ** Value used to signify the end of an position-list. This is safe because
118162: ** it is not possible to have a document with 2^31 terms.
118163: */
118164: #define POSITION_LIST_END 0x7fffffff
118165:
118166: /*
118167: ** This function is used to help parse position-lists. When this function is
118168: ** called, *pp may point to the start of the next varint in the position-list
118169: ** being parsed, or it may point to 1 byte past the end of the position-list
118170: ** (in which case **pp will be a terminator bytes POS_END (0) or
118171: ** (1)).
118172: **
118173: ** If *pp points past the end of the current position-list, set *pi to
118174: ** POSITION_LIST_END and return. Otherwise, read the next varint from *pp,
118175: ** increment the current value of *pi by the value read, and set *pp to
118176: ** point to the next value before returning.
118177: **
118178: ** Before calling this routine *pi must be initialized to the value of
118179: ** the previous position, or zero if we are reading the first position
118180: ** in the position-list. Because positions are delta-encoded, the value
118181: ** of the previous position is needed in order to compute the value of
118182: ** the next position.
118183: */
118184: static void fts3ReadNextPos(
118185: char **pp, /* IN/OUT: Pointer into position-list buffer */
118186: sqlite3_int64 *pi /* IN/OUT: Value read from position-list */
118187: ){
118188: if( (**pp)&0xFE ){
118189: fts3GetDeltaVarint(pp, pi);
118190: *pi -= 2;
118191: }else{
118192: *pi = POSITION_LIST_END;
118193: }
118194: }
118195:
118196: /*
118197: ** If parameter iCol is not 0, write an POS_COLUMN (1) byte followed by
118198: ** the value of iCol encoded as a varint to *pp. This will start a new
118199: ** column list.
118200: **
118201: ** Set *pp to point to the byte just after the last byte written before
118202: ** returning (do not modify it if iCol==0). Return the total number of bytes
118203: ** written (0 if iCol==0).
118204: */
118205: static int fts3PutColNumber(char **pp, int iCol){
118206: int n = 0; /* Number of bytes written */
118207: if( iCol ){
118208: char *p = *pp; /* Output pointer */
118209: n = 1 + sqlite3Fts3PutVarint(&p[1], iCol);
118210: *p = 0x01;
118211: *pp = &p[n];
118212: }
118213: return n;
118214: }
118215:
118216: /*
118217: ** Compute the union of two position lists. The output written
118218: ** into *pp contains all positions of both *pp1 and *pp2 in sorted
118219: ** order and with any duplicates removed. All pointers are
118220: ** updated appropriately. The caller is responsible for insuring
118221: ** that there is enough space in *pp to hold the complete output.
118222: */
118223: static void fts3PoslistMerge(
118224: char **pp, /* Output buffer */
118225: char **pp1, /* Left input list */
118226: char **pp2 /* Right input list */
118227: ){
118228: char *p = *pp;
118229: char *p1 = *pp1;
118230: char *p2 = *pp2;
118231:
118232: while( *p1 || *p2 ){
118233: int iCol1; /* The current column index in pp1 */
118234: int iCol2; /* The current column index in pp2 */
118235:
118236: if( *p1==POS_COLUMN ) sqlite3Fts3GetVarint32(&p1[1], &iCol1);
118237: else if( *p1==POS_END ) iCol1 = POSITION_LIST_END;
118238: else iCol1 = 0;
118239:
118240: if( *p2==POS_COLUMN ) sqlite3Fts3GetVarint32(&p2[1], &iCol2);
118241: else if( *p2==POS_END ) iCol2 = POSITION_LIST_END;
118242: else iCol2 = 0;
118243:
118244: if( iCol1==iCol2 ){
118245: sqlite3_int64 i1 = 0; /* Last position from pp1 */
118246: sqlite3_int64 i2 = 0; /* Last position from pp2 */
118247: sqlite3_int64 iPrev = 0;
118248: int n = fts3PutColNumber(&p, iCol1);
118249: p1 += n;
118250: p2 += n;
118251:
118252: /* At this point, both p1 and p2 point to the start of column-lists
118253: ** for the same column (the column with index iCol1 and iCol2).
118254: ** A column-list is a list of non-negative delta-encoded varints, each
118255: ** incremented by 2 before being stored. Each list is terminated by a
118256: ** POS_END (0) or POS_COLUMN (1). The following block merges the two lists
118257: ** and writes the results to buffer p. p is left pointing to the byte
118258: ** after the list written. No terminator (POS_END or POS_COLUMN) is
118259: ** written to the output.
118260: */
118261: fts3GetDeltaVarint(&p1, &i1);
118262: fts3GetDeltaVarint(&p2, &i2);
118263: do {
118264: fts3PutDeltaVarint(&p, &iPrev, (i1<i2) ? i1 : i2);
118265: iPrev -= 2;
118266: if( i1==i2 ){
118267: fts3ReadNextPos(&p1, &i1);
118268: fts3ReadNextPos(&p2, &i2);
118269: }else if( i1<i2 ){
118270: fts3ReadNextPos(&p1, &i1);
118271: }else{
118272: fts3ReadNextPos(&p2, &i2);
118273: }
118274: }while( i1!=POSITION_LIST_END || i2!=POSITION_LIST_END );
118275: }else if( iCol1<iCol2 ){
118276: p1 += fts3PutColNumber(&p, iCol1);
118277: fts3ColumnlistCopy(&p, &p1);
118278: }else{
118279: p2 += fts3PutColNumber(&p, iCol2);
118280: fts3ColumnlistCopy(&p, &p2);
118281: }
118282: }
118283:
118284: *p++ = POS_END;
118285: *pp = p;
118286: *pp1 = p1 + 1;
118287: *pp2 = p2 + 1;
118288: }
118289:
118290: /*
118291: ** This function is used to merge two position lists into one. When it is
118292: ** called, *pp1 and *pp2 must both point to position lists. A position-list is
118293: ** the part of a doclist that follows each document id. For example, if a row
118294: ** contains:
118295: **
118296: ** 'a b c'|'x y z'|'a b b a'
118297: **
118298: ** Then the position list for this row for token 'b' would consist of:
118299: **
118300: ** 0x02 0x01 0x02 0x03 0x03 0x00
118301: **
118302: ** When this function returns, both *pp1 and *pp2 are left pointing to the
118303: ** byte following the 0x00 terminator of their respective position lists.
118304: **
118305: ** If isSaveLeft is 0, an entry is added to the output position list for
118306: ** each position in *pp2 for which there exists one or more positions in
118307: ** *pp1 so that (pos(*pp2)>pos(*pp1) && pos(*pp2)-pos(*pp1)<=nToken). i.e.
118308: ** when the *pp1 token appears before the *pp2 token, but not more than nToken
118309: ** slots before it.
118310: **
118311: ** e.g. nToken==1 searches for adjacent positions.
118312: */
118313: static int fts3PoslistPhraseMerge(
118314: char **pp, /* IN/OUT: Preallocated output buffer */
118315: int nToken, /* Maximum difference in token positions */
118316: int isSaveLeft, /* Save the left position */
118317: int isExact, /* If *pp1 is exactly nTokens before *pp2 */
118318: char **pp1, /* IN/OUT: Left input list */
118319: char **pp2 /* IN/OUT: Right input list */
118320: ){
118321: char *p = *pp;
118322: char *p1 = *pp1;
118323: char *p2 = *pp2;
118324: int iCol1 = 0;
118325: int iCol2 = 0;
118326:
118327: /* Never set both isSaveLeft and isExact for the same invocation. */
118328: assert( isSaveLeft==0 || isExact==0 );
118329:
118330: assert( p!=0 && *p1!=0 && *p2!=0 );
118331: if( *p1==POS_COLUMN ){
118332: p1++;
118333: p1 += sqlite3Fts3GetVarint32(p1, &iCol1);
118334: }
118335: if( *p2==POS_COLUMN ){
118336: p2++;
118337: p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
118338: }
118339:
118340: while( 1 ){
118341: if( iCol1==iCol2 ){
118342: char *pSave = p;
118343: sqlite3_int64 iPrev = 0;
118344: sqlite3_int64 iPos1 = 0;
118345: sqlite3_int64 iPos2 = 0;
118346:
118347: if( iCol1 ){
118348: *p++ = POS_COLUMN;
118349: p += sqlite3Fts3PutVarint(p, iCol1);
118350: }
118351:
118352: assert( *p1!=POS_END && *p1!=POS_COLUMN );
118353: assert( *p2!=POS_END && *p2!=POS_COLUMN );
118354: fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2;
118355: fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
118356:
118357: while( 1 ){
118358: if( iPos2==iPos1+nToken
118359: || (isExact==0 && iPos2>iPos1 && iPos2<=iPos1+nToken)
118360: ){
118361: sqlite3_int64 iSave;
118362: iSave = isSaveLeft ? iPos1 : iPos2;
118363: fts3PutDeltaVarint(&p, &iPrev, iSave+2); iPrev -= 2;
118364: pSave = 0;
118365: assert( p );
118366: }
118367: if( (!isSaveLeft && iPos2<=(iPos1+nToken)) || iPos2<=iPos1 ){
118368: if( (*p2&0xFE)==0 ) break;
118369: fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
118370: }else{
118371: if( (*p1&0xFE)==0 ) break;
118372: fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2;
118373: }
118374: }
118375:
118376: if( pSave ){
118377: assert( pp && p );
118378: p = pSave;
118379: }
118380:
118381: fts3ColumnlistCopy(0, &p1);
118382: fts3ColumnlistCopy(0, &p2);
118383: assert( (*p1&0xFE)==0 && (*p2&0xFE)==0 );
118384: if( 0==*p1 || 0==*p2 ) break;
118385:
118386: p1++;
118387: p1 += sqlite3Fts3GetVarint32(p1, &iCol1);
118388: p2++;
118389: p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
118390: }
118391:
118392: /* Advance pointer p1 or p2 (whichever corresponds to the smaller of
118393: ** iCol1 and iCol2) so that it points to either the 0x00 that marks the
118394: ** end of the position list, or the 0x01 that precedes the next
118395: ** column-number in the position list.
118396: */
118397: else if( iCol1<iCol2 ){
118398: fts3ColumnlistCopy(0, &p1);
118399: if( 0==*p1 ) break;
118400: p1++;
118401: p1 += sqlite3Fts3GetVarint32(p1, &iCol1);
118402: }else{
118403: fts3ColumnlistCopy(0, &p2);
118404: if( 0==*p2 ) break;
118405: p2++;
118406: p2 += sqlite3Fts3GetVarint32(p2, &iCol2);
118407: }
118408: }
118409:
118410: fts3PoslistCopy(0, &p2);
118411: fts3PoslistCopy(0, &p1);
118412: *pp1 = p1;
118413: *pp2 = p2;
118414: if( *pp==p ){
118415: return 0;
118416: }
118417: *p++ = 0x00;
118418: *pp = p;
118419: return 1;
118420: }
118421:
118422: /*
118423: ** Merge two position-lists as required by the NEAR operator. The argument
118424: ** position lists correspond to the left and right phrases of an expression
118425: ** like:
118426: **
118427: ** "phrase 1" NEAR "phrase number 2"
118428: **
118429: ** Position list *pp1 corresponds to the left-hand side of the NEAR
118430: ** expression and *pp2 to the right. As usual, the indexes in the position
118431: ** lists are the offsets of the last token in each phrase (tokens "1" and "2"
118432: ** in the example above).
118433: **
118434: ** The output position list - written to *pp - is a copy of *pp2 with those
118435: ** entries that are not sufficiently NEAR entries in *pp1 removed.
118436: */
118437: static int fts3PoslistNearMerge(
118438: char **pp, /* Output buffer */
118439: char *aTmp, /* Temporary buffer space */
118440: int nRight, /* Maximum difference in token positions */
118441: int nLeft, /* Maximum difference in token positions */
118442: char **pp1, /* IN/OUT: Left input list */
118443: char **pp2 /* IN/OUT: Right input list */
118444: ){
118445: char *p1 = *pp1;
118446: char *p2 = *pp2;
118447:
118448: char *pTmp1 = aTmp;
118449: char *pTmp2;
118450: char *aTmp2;
118451: int res = 1;
118452:
118453: fts3PoslistPhraseMerge(&pTmp1, nRight, 0, 0, pp1, pp2);
118454: aTmp2 = pTmp2 = pTmp1;
118455: *pp1 = p1;
118456: *pp2 = p2;
118457: fts3PoslistPhraseMerge(&pTmp2, nLeft, 1, 0, pp2, pp1);
118458: if( pTmp1!=aTmp && pTmp2!=aTmp2 ){
118459: fts3PoslistMerge(pp, &aTmp, &aTmp2);
118460: }else if( pTmp1!=aTmp ){
118461: fts3PoslistCopy(pp, &aTmp);
118462: }else if( pTmp2!=aTmp2 ){
118463: fts3PoslistCopy(pp, &aTmp2);
118464: }else{
118465: res = 0;
118466: }
118467:
118468: return res;
118469: }
118470:
118471: /*
118472: ** An instance of this function is used to merge together the (potentially
118473: ** large number of) doclists for each term that matches a prefix query.
118474: ** See function fts3TermSelectMerge() for details.
118475: */
118476: typedef struct TermSelect TermSelect;
118477: struct TermSelect {
118478: char *aaOutput[16]; /* Malloc'd output buffers */
118479: int anOutput[16]; /* Size each output buffer in bytes */
118480: };
118481:
118482: /*
118483: ** This function is used to read a single varint from a buffer. Parameter
118484: ** pEnd points 1 byte past the end of the buffer. When this function is
118485: ** called, if *pp points to pEnd or greater, then the end of the buffer
118486: ** has been reached. In this case *pp is set to 0 and the function returns.
118487: **
118488: ** If *pp does not point to or past pEnd, then a single varint is read
118489: ** from *pp. *pp is then set to point 1 byte past the end of the read varint.
118490: **
118491: ** If bDescIdx is false, the value read is added to *pVal before returning.
118492: ** If it is true, the value read is subtracted from *pVal before this
118493: ** function returns.
118494: */
118495: static void fts3GetDeltaVarint3(
118496: char **pp, /* IN/OUT: Point to read varint from */
118497: char *pEnd, /* End of buffer */
118498: int bDescIdx, /* True if docids are descending */
118499: sqlite3_int64 *pVal /* IN/OUT: Integer value */
118500: ){
118501: if( *pp>=pEnd ){
118502: *pp = 0;
118503: }else{
118504: sqlite3_int64 iVal;
118505: *pp += sqlite3Fts3GetVarint(*pp, &iVal);
118506: if( bDescIdx ){
118507: *pVal -= iVal;
118508: }else{
118509: *pVal += iVal;
118510: }
118511: }
118512: }
118513:
118514: /*
118515: ** This function is used to write a single varint to a buffer. The varint
118516: ** is written to *pp. Before returning, *pp is set to point 1 byte past the
118517: ** end of the value written.
118518: **
118519: ** If *pbFirst is zero when this function is called, the value written to
118520: ** the buffer is that of parameter iVal.
118521: **
118522: ** If *pbFirst is non-zero when this function is called, then the value
118523: ** written is either (iVal-*piPrev) (if bDescIdx is zero) or (*piPrev-iVal)
118524: ** (if bDescIdx is non-zero).
118525: **
118526: ** Before returning, this function always sets *pbFirst to 1 and *piPrev
118527: ** to the value of parameter iVal.
118528: */
118529: static void fts3PutDeltaVarint3(
118530: char **pp, /* IN/OUT: Output pointer */
118531: int bDescIdx, /* True for descending docids */
118532: sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
118533: int *pbFirst, /* IN/OUT: True after first int written */
118534: sqlite3_int64 iVal /* Write this value to the list */
118535: ){
118536: sqlite3_int64 iWrite;
118537: if( bDescIdx==0 || *pbFirst==0 ){
118538: iWrite = iVal - *piPrev;
118539: }else{
118540: iWrite = *piPrev - iVal;
118541: }
118542: assert( *pbFirst || *piPrev==0 );
118543: assert( *pbFirst==0 || iWrite>0 );
118544: *pp += sqlite3Fts3PutVarint(*pp, iWrite);
118545: *piPrev = iVal;
118546: *pbFirst = 1;
118547: }
118548:
118549:
118550: /*
118551: ** This macro is used by various functions that merge doclists. The two
118552: ** arguments are 64-bit docid values. If the value of the stack variable
118553: ** bDescDoclist is 0 when this macro is invoked, then it returns (i1-i2).
118554: ** Otherwise, (i2-i1).
118555: **
118556: ** Using this makes it easier to write code that can merge doclists that are
118557: ** sorted in either ascending or descending order.
118558: */
118559: #define DOCID_CMP(i1, i2) ((bDescDoclist?-1:1) * (i1-i2))
118560:
118561: /*
118562: ** This function does an "OR" merge of two doclists (output contains all
118563: ** positions contained in either argument doclist). If the docids in the
118564: ** input doclists are sorted in ascending order, parameter bDescDoclist
118565: ** should be false. If they are sorted in ascending order, it should be
118566: ** passed a non-zero value.
118567: **
118568: ** If no error occurs, *paOut is set to point at an sqlite3_malloc'd buffer
118569: ** containing the output doclist and SQLITE_OK is returned. In this case
118570: ** *pnOut is set to the number of bytes in the output doclist.
118571: **
118572: ** If an error occurs, an SQLite error code is returned. The output values
118573: ** are undefined in this case.
118574: */
118575: static int fts3DoclistOrMerge(
118576: int bDescDoclist, /* True if arguments are desc */
118577: char *a1, int n1, /* First doclist */
118578: char *a2, int n2, /* Second doclist */
118579: char **paOut, int *pnOut /* OUT: Malloc'd doclist */
118580: ){
118581: sqlite3_int64 i1 = 0;
118582: sqlite3_int64 i2 = 0;
118583: sqlite3_int64 iPrev = 0;
118584: char *pEnd1 = &a1[n1];
118585: char *pEnd2 = &a2[n2];
118586: char *p1 = a1;
118587: char *p2 = a2;
118588: char *p;
118589: char *aOut;
118590: int bFirstOut = 0;
118591:
118592: *paOut = 0;
118593: *pnOut = 0;
118594:
118595: /* Allocate space for the output. Both the input and output doclists
118596: ** are delta encoded. If they are in ascending order (bDescDoclist==0),
118597: ** then the first docid in each list is simply encoded as a varint. For
118598: ** each subsequent docid, the varint stored is the difference between the
118599: ** current and previous docid (a positive number - since the list is in
118600: ** ascending order).
118601: **
118602: ** The first docid written to the output is therefore encoded using the
118603: ** same number of bytes as it is in whichever of the input lists it is
118604: ** read from. And each subsequent docid read from the same input list
118605: ** consumes either the same or less bytes as it did in the input (since
118606: ** the difference between it and the previous value in the output must
118607: ** be a positive value less than or equal to the delta value read from
118608: ** the input list). The same argument applies to all but the first docid
118609: ** read from the 'other' list. And to the contents of all position lists
118610: ** that will be copied and merged from the input to the output.
118611: **
118612: ** However, if the first docid copied to the output is a negative number,
118613: ** then the encoding of the first docid from the 'other' input list may
118614: ** be larger in the output than it was in the input (since the delta value
118615: ** may be a larger positive integer than the actual docid).
118616: **
118617: ** The space required to store the output is therefore the sum of the
118618: ** sizes of the two inputs, plus enough space for exactly one of the input
118619: ** docids to grow.
118620: **
118621: ** A symetric argument may be made if the doclists are in descending
118622: ** order.
118623: */
118624: aOut = sqlite3_malloc(n1+n2+FTS3_VARINT_MAX-1);
118625: if( !aOut ) return SQLITE_NOMEM;
118626:
118627: p = aOut;
118628: fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1);
118629: fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
118630: while( p1 || p2 ){
118631: sqlite3_int64 iDiff = DOCID_CMP(i1, i2);
118632:
118633: if( p2 && p1 && iDiff==0 ){
118634: fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
118635: fts3PoslistMerge(&p, &p1, &p2);
118636: fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1);
118637: fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118638: }else if( !p2 || (p1 && iDiff<0) ){
118639: fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
118640: fts3PoslistCopy(&p, &p1);
118641: fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1);
118642: }else{
118643: fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i2);
118644: fts3PoslistCopy(&p, &p2);
118645: fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118646: }
118647: }
118648:
118649: *paOut = aOut;
118650: *pnOut = (p-aOut);
118651: assert( *pnOut<=n1+n2+FTS3_VARINT_MAX-1 );
118652: return SQLITE_OK;
118653: }
118654:
118655: /*
118656: ** This function does a "phrase" merge of two doclists. In a phrase merge,
118657: ** the output contains a copy of each position from the right-hand input
118658: ** doclist for which there is a position in the left-hand input doclist
118659: ** exactly nDist tokens before it.
118660: **
118661: ** If the docids in the input doclists are sorted in ascending order,
118662: ** parameter bDescDoclist should be false. If they are sorted in ascending
118663: ** order, it should be passed a non-zero value.
118664: **
118665: ** The right-hand input doclist is overwritten by this function.
118666: */
118667: static void fts3DoclistPhraseMerge(
118668: int bDescDoclist, /* True if arguments are desc */
118669: int nDist, /* Distance from left to right (1=adjacent) */
118670: char *aLeft, int nLeft, /* Left doclist */
118671: char *aRight, int *pnRight /* IN/OUT: Right/output doclist */
118672: ){
118673: sqlite3_int64 i1 = 0;
118674: sqlite3_int64 i2 = 0;
118675: sqlite3_int64 iPrev = 0;
118676: char *pEnd1 = &aLeft[nLeft];
118677: char *pEnd2 = &aRight[*pnRight];
118678: char *p1 = aLeft;
118679: char *p2 = aRight;
118680: char *p;
118681: int bFirstOut = 0;
118682: char *aOut = aRight;
118683:
118684: assert( nDist>0 );
118685:
118686: p = aOut;
118687: fts3GetDeltaVarint3(&p1, pEnd1, 0, &i1);
118688: fts3GetDeltaVarint3(&p2, pEnd2, 0, &i2);
118689:
118690: while( p1 && p2 ){
118691: sqlite3_int64 iDiff = DOCID_CMP(i1, i2);
118692: if( iDiff==0 ){
118693: char *pSave = p;
118694: sqlite3_int64 iPrevSave = iPrev;
118695: int bFirstOutSave = bFirstOut;
118696:
118697: fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
118698: if( 0==fts3PoslistPhraseMerge(&p, nDist, 0, 1, &p1, &p2) ){
118699: p = pSave;
118700: iPrev = iPrevSave;
118701: bFirstOut = bFirstOutSave;
118702: }
118703: fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1);
118704: fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118705: }else if( iDiff<0 ){
118706: fts3PoslistCopy(0, &p1);
118707: fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1);
118708: }else{
118709: fts3PoslistCopy(0, &p2);
118710: fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
118711: }
118712: }
118713:
118714: *pnRight = p - aOut;
118715: }
118716:
118717: /*
118718: ** Argument pList points to a position list nList bytes in size. This
118719: ** function checks to see if the position list contains any entries for
118720: ** a token in position 0 (of any column). If so, it writes argument iDelta
118721: ** to the output buffer pOut, followed by a position list consisting only
118722: ** of the entries from pList at position 0, and terminated by an 0x00 byte.
118723: ** The value returned is the number of bytes written to pOut (if any).
118724: */
118725: SQLITE_PRIVATE int sqlite3Fts3FirstFilter(
118726: sqlite3_int64 iDelta, /* Varint that may be written to pOut */
118727: char *pList, /* Position list (no 0x00 term) */
118728: int nList, /* Size of pList in bytes */
118729: char *pOut /* Write output here */
118730: ){
118731: int nOut = 0;
118732: int bWritten = 0; /* True once iDelta has been written */
118733: char *p = pList;
118734: char *pEnd = &pList[nList];
118735:
118736: if( *p!=0x01 ){
118737: if( *p==0x02 ){
118738: nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta);
118739: pOut[nOut++] = 0x02;
118740: bWritten = 1;
118741: }
118742: fts3ColumnlistCopy(0, &p);
118743: }
118744:
118745: while( p<pEnd && *p==0x01 ){
118746: sqlite3_int64 iCol;
118747: p++;
118748: p += sqlite3Fts3GetVarint(p, &iCol);
118749: if( *p==0x02 ){
118750: if( bWritten==0 ){
118751: nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta);
118752: bWritten = 1;
118753: }
118754: pOut[nOut++] = 0x01;
118755: nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
118756: pOut[nOut++] = 0x02;
118757: }
118758: fts3ColumnlistCopy(0, &p);
118759: }
118760: if( bWritten ){
118761: pOut[nOut++] = 0x00;
118762: }
118763:
118764: return nOut;
118765: }
118766:
118767:
118768: /*
118769: ** Merge all doclists in the TermSelect.aaOutput[] array into a single
118770: ** doclist stored in TermSelect.aaOutput[0]. If successful, delete all
118771: ** other doclists (except the aaOutput[0] one) and return SQLITE_OK.
118772: **
118773: ** If an OOM error occurs, return SQLITE_NOMEM. In this case it is
118774: ** the responsibility of the caller to free any doclists left in the
118775: ** TermSelect.aaOutput[] array.
118776: */
118777: static int fts3TermSelectFinishMerge(Fts3Table *p, TermSelect *pTS){
118778: char *aOut = 0;
118779: int nOut = 0;
118780: int i;
118781:
118782: /* Loop through the doclists in the aaOutput[] array. Merge them all
118783: ** into a single doclist.
118784: */
118785: for(i=0; i<SizeofArray(pTS->aaOutput); i++){
118786: if( pTS->aaOutput[i] ){
118787: if( !aOut ){
118788: aOut = pTS->aaOutput[i];
118789: nOut = pTS->anOutput[i];
118790: pTS->aaOutput[i] = 0;
118791: }else{
118792: int nNew;
118793: char *aNew;
118794:
118795: int rc = fts3DoclistOrMerge(p->bDescIdx,
118796: pTS->aaOutput[i], pTS->anOutput[i], aOut, nOut, &aNew, &nNew
118797: );
118798: if( rc!=SQLITE_OK ){
118799: sqlite3_free(aOut);
118800: return rc;
118801: }
118802:
118803: sqlite3_free(pTS->aaOutput[i]);
118804: sqlite3_free(aOut);
118805: pTS->aaOutput[i] = 0;
118806: aOut = aNew;
118807: nOut = nNew;
118808: }
118809: }
118810: }
118811:
118812: pTS->aaOutput[0] = aOut;
118813: pTS->anOutput[0] = nOut;
118814: return SQLITE_OK;
118815: }
118816:
118817: /*
118818: ** Merge the doclist aDoclist/nDoclist into the TermSelect object passed
118819: ** as the first argument. The merge is an "OR" merge (see function
118820: ** fts3DoclistOrMerge() for details).
118821: **
118822: ** This function is called with the doclist for each term that matches
118823: ** a queried prefix. It merges all these doclists into one, the doclist
118824: ** for the specified prefix. Since there can be a very large number of
118825: ** doclists to merge, the merging is done pair-wise using the TermSelect
118826: ** object.
118827: **
118828: ** This function returns SQLITE_OK if the merge is successful, or an
118829: ** SQLite error code (SQLITE_NOMEM) if an error occurs.
118830: */
118831: static int fts3TermSelectMerge(
118832: Fts3Table *p, /* FTS table handle */
118833: TermSelect *pTS, /* TermSelect object to merge into */
118834: char *aDoclist, /* Pointer to doclist */
118835: int nDoclist /* Size of aDoclist in bytes */
118836: ){
118837: if( pTS->aaOutput[0]==0 ){
118838: /* If this is the first term selected, copy the doclist to the output
118839: ** buffer using memcpy(). */
118840: pTS->aaOutput[0] = sqlite3_malloc(nDoclist);
118841: pTS->anOutput[0] = nDoclist;
118842: if( pTS->aaOutput[0] ){
118843: memcpy(pTS->aaOutput[0], aDoclist, nDoclist);
118844: }else{
118845: return SQLITE_NOMEM;
118846: }
118847: }else{
118848: char *aMerge = aDoclist;
118849: int nMerge = nDoclist;
118850: int iOut;
118851:
118852: for(iOut=0; iOut<SizeofArray(pTS->aaOutput); iOut++){
118853: if( pTS->aaOutput[iOut]==0 ){
118854: assert( iOut>0 );
118855: pTS->aaOutput[iOut] = aMerge;
118856: pTS->anOutput[iOut] = nMerge;
118857: break;
118858: }else{
118859: char *aNew;
118860: int nNew;
118861:
118862: int rc = fts3DoclistOrMerge(p->bDescIdx, aMerge, nMerge,
118863: pTS->aaOutput[iOut], pTS->anOutput[iOut], &aNew, &nNew
118864: );
118865: if( rc!=SQLITE_OK ){
118866: if( aMerge!=aDoclist ) sqlite3_free(aMerge);
118867: return rc;
118868: }
118869:
118870: if( aMerge!=aDoclist ) sqlite3_free(aMerge);
118871: sqlite3_free(pTS->aaOutput[iOut]);
118872: pTS->aaOutput[iOut] = 0;
118873:
118874: aMerge = aNew;
118875: nMerge = nNew;
118876: if( (iOut+1)==SizeofArray(pTS->aaOutput) ){
118877: pTS->aaOutput[iOut] = aMerge;
118878: pTS->anOutput[iOut] = nMerge;
118879: }
118880: }
118881: }
118882: }
118883: return SQLITE_OK;
118884: }
118885:
118886: /*
118887: ** Append SegReader object pNew to the end of the pCsr->apSegment[] array.
118888: */
118889: static int fts3SegReaderCursorAppend(
118890: Fts3MultiSegReader *pCsr,
118891: Fts3SegReader *pNew
118892: ){
118893: if( (pCsr->nSegment%16)==0 ){
118894: Fts3SegReader **apNew;
118895: int nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*);
118896: apNew = (Fts3SegReader **)sqlite3_realloc(pCsr->apSegment, nByte);
118897: if( !apNew ){
118898: sqlite3Fts3SegReaderFree(pNew);
118899: return SQLITE_NOMEM;
118900: }
118901: pCsr->apSegment = apNew;
118902: }
118903: pCsr->apSegment[pCsr->nSegment++] = pNew;
118904: return SQLITE_OK;
118905: }
118906:
118907: /*
118908: ** Add seg-reader objects to the Fts3MultiSegReader object passed as the
118909: ** 8th argument.
118910: **
118911: ** This function returns SQLITE_OK if successful, or an SQLite error code
118912: ** otherwise.
118913: */
118914: static int fts3SegReaderCursor(
118915: Fts3Table *p, /* FTS3 table handle */
118916: int iIndex, /* Index to search (from 0 to p->nIndex-1) */
118917: int iLevel, /* Level of segments to scan */
118918: const char *zTerm, /* Term to query for */
118919: int nTerm, /* Size of zTerm in bytes */
118920: int isPrefix, /* True for a prefix search */
118921: int isScan, /* True to scan from zTerm to EOF */
118922: Fts3MultiSegReader *pCsr /* Cursor object to populate */
118923: ){
118924: int rc = SQLITE_OK; /* Error code */
118925: sqlite3_stmt *pStmt = 0; /* Statement to iterate through segments */
118926: int rc2; /* Result of sqlite3_reset() */
118927:
118928: /* If iLevel is less than 0 and this is not a scan, include a seg-reader
118929: ** for the pending-terms. If this is a scan, then this call must be being
118930: ** made by an fts4aux module, not an FTS table. In this case calling
118931: ** Fts3SegReaderPending might segfault, as the data structures used by
118932: ** fts4aux are not completely populated. So it's easiest to filter these
118933: ** calls out here. */
118934: if( iLevel<0 && p->aIndex ){
118935: Fts3SegReader *pSeg = 0;
118936: rc = sqlite3Fts3SegReaderPending(p, iIndex, zTerm, nTerm, isPrefix, &pSeg);
118937: if( rc==SQLITE_OK && pSeg ){
118938: rc = fts3SegReaderCursorAppend(pCsr, pSeg);
118939: }
118940: }
118941:
118942: if( iLevel!=FTS3_SEGCURSOR_PENDING ){
118943: if( rc==SQLITE_OK ){
118944: rc = sqlite3Fts3AllSegdirs(p, iIndex, iLevel, &pStmt);
118945: }
118946:
118947: while( rc==SQLITE_OK && SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
118948: Fts3SegReader *pSeg = 0;
118949:
118950: /* Read the values returned by the SELECT into local variables. */
118951: sqlite3_int64 iStartBlock = sqlite3_column_int64(pStmt, 1);
118952: sqlite3_int64 iLeavesEndBlock = sqlite3_column_int64(pStmt, 2);
118953: sqlite3_int64 iEndBlock = sqlite3_column_int64(pStmt, 3);
118954: int nRoot = sqlite3_column_bytes(pStmt, 4);
118955: char const *zRoot = sqlite3_column_blob(pStmt, 4);
118956:
118957: /* If zTerm is not NULL, and this segment is not stored entirely on its
118958: ** root node, the range of leaves scanned can be reduced. Do this. */
118959: if( iStartBlock && zTerm ){
118960: sqlite3_int64 *pi = (isPrefix ? &iLeavesEndBlock : 0);
118961: rc = fts3SelectLeaf(p, zTerm, nTerm, zRoot, nRoot, &iStartBlock, pi);
118962: if( rc!=SQLITE_OK ) goto finished;
118963: if( isPrefix==0 && isScan==0 ) iLeavesEndBlock = iStartBlock;
118964: }
118965:
118966: rc = sqlite3Fts3SegReaderNew(pCsr->nSegment+1,
118967: iStartBlock, iLeavesEndBlock, iEndBlock, zRoot, nRoot, &pSeg
118968: );
118969: if( rc!=SQLITE_OK ) goto finished;
118970: rc = fts3SegReaderCursorAppend(pCsr, pSeg);
118971: }
118972: }
118973:
118974: finished:
118975: rc2 = sqlite3_reset(pStmt);
118976: if( rc==SQLITE_DONE ) rc = rc2;
118977:
118978: return rc;
118979: }
118980:
118981: /*
118982: ** Set up a cursor object for iterating through a full-text index or a
118983: ** single level therein.
118984: */
118985: SQLITE_PRIVATE int sqlite3Fts3SegReaderCursor(
118986: Fts3Table *p, /* FTS3 table handle */
118987: int iIndex, /* Index to search (from 0 to p->nIndex-1) */
118988: int iLevel, /* Level of segments to scan */
118989: const char *zTerm, /* Term to query for */
118990: int nTerm, /* Size of zTerm in bytes */
118991: int isPrefix, /* True for a prefix search */
118992: int isScan, /* True to scan from zTerm to EOF */
118993: Fts3MultiSegReader *pCsr /* Cursor object to populate */
118994: ){
118995: assert( iIndex>=0 && iIndex<p->nIndex );
118996: assert( iLevel==FTS3_SEGCURSOR_ALL
118997: || iLevel==FTS3_SEGCURSOR_PENDING
118998: || iLevel>=0
118999: );
119000: assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
119001: assert( FTS3_SEGCURSOR_ALL<0 && FTS3_SEGCURSOR_PENDING<0 );
119002: assert( isPrefix==0 || isScan==0 );
119003:
119004: /* "isScan" is only set to true by the ft4aux module, an ordinary
119005: ** full-text tables. */
119006: assert( isScan==0 || p->aIndex==0 );
119007:
119008: memset(pCsr, 0, sizeof(Fts3MultiSegReader));
119009:
119010: return fts3SegReaderCursor(
119011: p, iIndex, iLevel, zTerm, nTerm, isPrefix, isScan, pCsr
119012: );
119013: }
119014:
119015: /*
119016: ** In addition to its current configuration, have the Fts3MultiSegReader
119017: ** passed as the 4th argument also scan the doclist for term zTerm/nTerm.
119018: **
119019: ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
119020: */
119021: static int fts3SegReaderCursorAddZero(
119022: Fts3Table *p, /* FTS virtual table handle */
119023: const char *zTerm, /* Term to scan doclist of */
119024: int nTerm, /* Number of bytes in zTerm */
119025: Fts3MultiSegReader *pCsr /* Fts3MultiSegReader to modify */
119026: ){
119027: return fts3SegReaderCursor(p, 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0,pCsr);
119028: }
119029:
119030: /*
119031: ** Open an Fts3MultiSegReader to scan the doclist for term zTerm/nTerm. Or,
119032: ** if isPrefix is true, to scan the doclist for all terms for which
119033: ** zTerm/nTerm is a prefix. If successful, return SQLITE_OK and write
119034: ** a pointer to the new Fts3MultiSegReader to *ppSegcsr. Otherwise, return
119035: ** an SQLite error code.
119036: **
119037: ** It is the responsibility of the caller to free this object by eventually
119038: ** passing it to fts3SegReaderCursorFree()
119039: **
119040: ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
119041: ** Output parameter *ppSegcsr is set to 0 if an error occurs.
119042: */
119043: static int fts3TermSegReaderCursor(
119044: Fts3Cursor *pCsr, /* Virtual table cursor handle */
119045: const char *zTerm, /* Term to query for */
119046: int nTerm, /* Size of zTerm in bytes */
119047: int isPrefix, /* True for a prefix search */
119048: Fts3MultiSegReader **ppSegcsr /* OUT: Allocated seg-reader cursor */
119049: ){
119050: Fts3MultiSegReader *pSegcsr; /* Object to allocate and return */
119051: int rc = SQLITE_NOMEM; /* Return code */
119052:
119053: pSegcsr = sqlite3_malloc(sizeof(Fts3MultiSegReader));
119054: if( pSegcsr ){
119055: int i;
119056: int bFound = 0; /* True once an index has been found */
119057: Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
119058:
119059: if( isPrefix ){
119060: for(i=1; bFound==0 && i<p->nIndex; i++){
119061: if( p->aIndex[i].nPrefix==nTerm ){
119062: bFound = 1;
119063: rc = sqlite3Fts3SegReaderCursor(
119064: p, i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 0, 0, pSegcsr);
119065: pSegcsr->bLookup = 1;
119066: }
119067: }
119068:
119069: for(i=1; bFound==0 && i<p->nIndex; i++){
119070: if( p->aIndex[i].nPrefix==nTerm+1 ){
119071: bFound = 1;
119072: rc = sqlite3Fts3SegReaderCursor(
119073: p, i, FTS3_SEGCURSOR_ALL, zTerm, nTerm, 1, 0, pSegcsr
119074: );
119075: if( rc==SQLITE_OK ){
119076: rc = fts3SegReaderCursorAddZero(p, zTerm, nTerm, pSegcsr);
119077: }
119078: }
119079: }
119080: }
119081:
119082: if( bFound==0 ){
119083: rc = sqlite3Fts3SegReaderCursor(
119084: p, 0, FTS3_SEGCURSOR_ALL, zTerm, nTerm, isPrefix, 0, pSegcsr
119085: );
119086: pSegcsr->bLookup = !isPrefix;
119087: }
119088: }
119089:
119090: *ppSegcsr = pSegcsr;
119091: return rc;
119092: }
119093:
119094: /*
119095: ** Free an Fts3MultiSegReader allocated by fts3TermSegReaderCursor().
119096: */
119097: static void fts3SegReaderCursorFree(Fts3MultiSegReader *pSegcsr){
119098: sqlite3Fts3SegReaderFinish(pSegcsr);
119099: sqlite3_free(pSegcsr);
119100: }
119101:
119102: /*
119103: ** This function retreives the doclist for the specified term (or term
119104: ** prefix) from the database.
119105: */
119106: static int fts3TermSelect(
119107: Fts3Table *p, /* Virtual table handle */
119108: Fts3PhraseToken *pTok, /* Token to query for */
119109: int iColumn, /* Column to query (or -ve for all columns) */
119110: int *pnOut, /* OUT: Size of buffer at *ppOut */
119111: char **ppOut /* OUT: Malloced result buffer */
119112: ){
119113: int rc; /* Return code */
119114: Fts3MultiSegReader *pSegcsr; /* Seg-reader cursor for this term */
119115: TermSelect tsc; /* Object for pair-wise doclist merging */
119116: Fts3SegFilter filter; /* Segment term filter configuration */
119117:
119118: pSegcsr = pTok->pSegcsr;
119119: memset(&tsc, 0, sizeof(TermSelect));
119120:
119121: filter.flags = FTS3_SEGMENT_IGNORE_EMPTY | FTS3_SEGMENT_REQUIRE_POS
119122: | (pTok->isPrefix ? FTS3_SEGMENT_PREFIX : 0)
119123: | (pTok->bFirst ? FTS3_SEGMENT_FIRST : 0)
119124: | (iColumn<p->nColumn ? FTS3_SEGMENT_COLUMN_FILTER : 0);
119125: filter.iCol = iColumn;
119126: filter.zTerm = pTok->z;
119127: filter.nTerm = pTok->n;
119128:
119129: rc = sqlite3Fts3SegReaderStart(p, pSegcsr, &filter);
119130: while( SQLITE_OK==rc
119131: && SQLITE_ROW==(rc = sqlite3Fts3SegReaderStep(p, pSegcsr))
119132: ){
119133: rc = fts3TermSelectMerge(p, &tsc, pSegcsr->aDoclist, pSegcsr->nDoclist);
119134: }
119135:
119136: if( rc==SQLITE_OK ){
119137: rc = fts3TermSelectFinishMerge(p, &tsc);
119138: }
119139: if( rc==SQLITE_OK ){
119140: *ppOut = tsc.aaOutput[0];
119141: *pnOut = tsc.anOutput[0];
119142: }else{
119143: int i;
119144: for(i=0; i<SizeofArray(tsc.aaOutput); i++){
119145: sqlite3_free(tsc.aaOutput[i]);
119146: }
119147: }
119148:
119149: fts3SegReaderCursorFree(pSegcsr);
119150: pTok->pSegcsr = 0;
119151: return rc;
119152: }
119153:
119154: /*
119155: ** This function counts the total number of docids in the doclist stored
119156: ** in buffer aList[], size nList bytes.
119157: **
119158: ** If the isPoslist argument is true, then it is assumed that the doclist
119159: ** contains a position-list following each docid. Otherwise, it is assumed
119160: ** that the doclist is simply a list of docids stored as delta encoded
119161: ** varints.
119162: */
119163: static int fts3DoclistCountDocids(char *aList, int nList){
119164: int nDoc = 0; /* Return value */
119165: if( aList ){
119166: char *aEnd = &aList[nList]; /* Pointer to one byte after EOF */
119167: char *p = aList; /* Cursor */
119168: while( p<aEnd ){
119169: nDoc++;
119170: while( (*p++)&0x80 ); /* Skip docid varint */
119171: fts3PoslistCopy(0, &p); /* Skip over position list */
119172: }
119173: }
119174:
119175: return nDoc;
119176: }
119177:
119178: /*
119179: ** Advance the cursor to the next row in the %_content table that
119180: ** matches the search criteria. For a MATCH search, this will be
119181: ** the next row that matches. For a full-table scan, this will be
119182: ** simply the next row in the %_content table. For a docid lookup,
119183: ** this routine simply sets the EOF flag.
119184: **
119185: ** Return SQLITE_OK if nothing goes wrong. SQLITE_OK is returned
119186: ** even if we reach end-of-file. The fts3EofMethod() will be called
119187: ** subsequently to determine whether or not an EOF was hit.
119188: */
119189: static int fts3NextMethod(sqlite3_vtab_cursor *pCursor){
119190: int rc;
119191: Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
119192: if( pCsr->eSearch==FTS3_DOCID_SEARCH || pCsr->eSearch==FTS3_FULLSCAN_SEARCH ){
119193: if( SQLITE_ROW!=sqlite3_step(pCsr->pStmt) ){
119194: pCsr->isEof = 1;
119195: rc = sqlite3_reset(pCsr->pStmt);
119196: }else{
119197: pCsr->iPrevId = sqlite3_column_int64(pCsr->pStmt, 0);
119198: rc = SQLITE_OK;
119199: }
119200: }else{
119201: rc = fts3EvalNext((Fts3Cursor *)pCursor);
119202: }
119203: assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
119204: return rc;
119205: }
119206:
119207: /*
119208: ** This is the xFilter interface for the virtual table. See
119209: ** the virtual table xFilter method documentation for additional
119210: ** information.
119211: **
119212: ** If idxNum==FTS3_FULLSCAN_SEARCH then do a full table scan against
119213: ** the %_content table.
119214: **
119215: ** If idxNum==FTS3_DOCID_SEARCH then do a docid lookup for a single entry
119216: ** in the %_content table.
119217: **
119218: ** If idxNum>=FTS3_FULLTEXT_SEARCH then use the full text index. The
119219: ** column on the left-hand side of the MATCH operator is column
119220: ** number idxNum-FTS3_FULLTEXT_SEARCH, 0 indexed. argv[0] is the right-hand
119221: ** side of the MATCH operator.
119222: */
119223: static int fts3FilterMethod(
119224: sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */
119225: int idxNum, /* Strategy index */
119226: const char *idxStr, /* Unused */
119227: int nVal, /* Number of elements in apVal */
119228: sqlite3_value **apVal /* Arguments for the indexing scheme */
119229: ){
119230: int rc;
119231: char *zSql; /* SQL statement used to access %_content */
119232: Fts3Table *p = (Fts3Table *)pCursor->pVtab;
119233: Fts3Cursor *pCsr = (Fts3Cursor *)pCursor;
119234:
119235: UNUSED_PARAMETER(idxStr);
119236: UNUSED_PARAMETER(nVal);
119237:
119238: assert( idxNum>=0 && idxNum<=(FTS3_FULLTEXT_SEARCH+p->nColumn) );
119239: assert( nVal==0 || nVal==1 );
119240: assert( (nVal==0)==(idxNum==FTS3_FULLSCAN_SEARCH) );
119241: assert( p->pSegments==0 );
119242:
119243: /* In case the cursor has been used before, clear it now. */
119244: sqlite3_finalize(pCsr->pStmt);
119245: sqlite3_free(pCsr->aDoclist);
119246: sqlite3Fts3ExprFree(pCsr->pExpr);
119247: memset(&pCursor[1], 0, sizeof(Fts3Cursor)-sizeof(sqlite3_vtab_cursor));
119248:
119249: if( idxStr ){
119250: pCsr->bDesc = (idxStr[0]=='D');
119251: }else{
119252: pCsr->bDesc = p->bDescIdx;
119253: }
119254: pCsr->eSearch = (i16)idxNum;
119255:
119256: if( idxNum!=FTS3_DOCID_SEARCH && idxNum!=FTS3_FULLSCAN_SEARCH ){
119257: int iCol = idxNum-FTS3_FULLTEXT_SEARCH;
119258: const char *zQuery = (const char *)sqlite3_value_text(apVal[0]);
119259:
119260: if( zQuery==0 && sqlite3_value_type(apVal[0])!=SQLITE_NULL ){
119261: return SQLITE_NOMEM;
119262: }
119263:
119264: rc = sqlite3Fts3ExprParse(p->pTokenizer, p->azColumn, p->bHasStat,
119265: p->nColumn, iCol, zQuery, -1, &pCsr->pExpr
119266: );
119267: if( rc!=SQLITE_OK ){
119268: if( rc==SQLITE_ERROR ){
119269: static const char *zErr = "malformed MATCH expression: [%s]";
119270: p->base.zErrMsg = sqlite3_mprintf(zErr, zQuery);
119271: }
119272: return rc;
119273: }
119274:
119275: rc = sqlite3Fts3ReadLock(p);
119276: if( rc!=SQLITE_OK ) return rc;
119277:
119278: rc = fts3EvalStart(pCsr);
119279:
119280: sqlite3Fts3SegmentsClose(p);
119281: if( rc!=SQLITE_OK ) return rc;
119282: pCsr->pNextId = pCsr->aDoclist;
119283: pCsr->iPrevId = 0;
119284: }
119285:
119286: /* Compile a SELECT statement for this cursor. For a full-table-scan, the
119287: ** statement loops through all rows of the %_content table. For a
119288: ** full-text query or docid lookup, the statement retrieves a single
119289: ** row by docid.
119290: */
119291: if( idxNum==FTS3_FULLSCAN_SEARCH ){
119292: zSql = sqlite3_mprintf(
119293: "SELECT %s ORDER BY rowid %s",
119294: p->zReadExprlist, (pCsr->bDesc ? "DESC" : "ASC")
119295: );
119296: if( zSql ){
119297: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pCsr->pStmt, 0);
119298: sqlite3_free(zSql);
119299: }else{
119300: rc = SQLITE_NOMEM;
119301: }
119302: }else if( idxNum==FTS3_DOCID_SEARCH ){
119303: rc = fts3CursorSeekStmt(pCsr, &pCsr->pStmt);
119304: if( rc==SQLITE_OK ){
119305: rc = sqlite3_bind_value(pCsr->pStmt, 1, apVal[0]);
119306: }
119307: }
119308: if( rc!=SQLITE_OK ) return rc;
119309:
119310: return fts3NextMethod(pCursor);
119311: }
119312:
119313: /*
119314: ** This is the xEof method of the virtual table. SQLite calls this
119315: ** routine to find out if it has reached the end of a result set.
119316: */
119317: static int fts3EofMethod(sqlite3_vtab_cursor *pCursor){
119318: return ((Fts3Cursor *)pCursor)->isEof;
119319: }
119320:
119321: /*
119322: ** This is the xRowid method. The SQLite core calls this routine to
119323: ** retrieve the rowid for the current row of the result set. fts3
119324: ** exposes %_content.docid as the rowid for the virtual table. The
119325: ** rowid should be written to *pRowid.
119326: */
119327: static int fts3RowidMethod(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
119328: Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
119329: *pRowid = pCsr->iPrevId;
119330: return SQLITE_OK;
119331: }
119332:
119333: /*
119334: ** This is the xColumn method, called by SQLite to request a value from
119335: ** the row that the supplied cursor currently points to.
119336: */
119337: static int fts3ColumnMethod(
119338: sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
119339: sqlite3_context *pContext, /* Context for sqlite3_result_xxx() calls */
119340: int iCol /* Index of column to read value from */
119341: ){
119342: int rc = SQLITE_OK; /* Return Code */
119343: Fts3Cursor *pCsr = (Fts3Cursor *) pCursor;
119344: Fts3Table *p = (Fts3Table *)pCursor->pVtab;
119345:
119346: /* The column value supplied by SQLite must be in range. */
119347: assert( iCol>=0 && iCol<=p->nColumn+1 );
119348:
119349: if( iCol==p->nColumn+1 ){
119350: /* This call is a request for the "docid" column. Since "docid" is an
119351: ** alias for "rowid", use the xRowid() method to obtain the value.
119352: */
119353: sqlite3_result_int64(pContext, pCsr->iPrevId);
119354: }else if( iCol==p->nColumn ){
119355: /* The extra column whose name is the same as the table.
119356: ** Return a blob which is a pointer to the cursor.
119357: */
119358: sqlite3_result_blob(pContext, &pCsr, sizeof(pCsr), SQLITE_TRANSIENT);
119359: }else{
119360: rc = fts3CursorSeek(0, pCsr);
119361: if( rc==SQLITE_OK && sqlite3_data_count(pCsr->pStmt)>(iCol+1) ){
119362: sqlite3_result_value(pContext, sqlite3_column_value(pCsr->pStmt, iCol+1));
119363: }
119364: }
119365:
119366: assert( ((Fts3Table *)pCsr->base.pVtab)->pSegments==0 );
119367: return rc;
119368: }
119369:
119370: /*
119371: ** This function is the implementation of the xUpdate callback used by
119372: ** FTS3 virtual tables. It is invoked by SQLite each time a row is to be
119373: ** inserted, updated or deleted.
119374: */
119375: static int fts3UpdateMethod(
119376: sqlite3_vtab *pVtab, /* Virtual table handle */
119377: int nArg, /* Size of argument array */
119378: sqlite3_value **apVal, /* Array of arguments */
119379: sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */
119380: ){
119381: return sqlite3Fts3UpdateMethod(pVtab, nArg, apVal, pRowid);
119382: }
119383:
119384: /*
119385: ** Implementation of xSync() method. Flush the contents of the pending-terms
119386: ** hash-table to the database.
119387: */
119388: static int fts3SyncMethod(sqlite3_vtab *pVtab){
119389: int rc = sqlite3Fts3PendingTermsFlush((Fts3Table *)pVtab);
119390: sqlite3Fts3SegmentsClose((Fts3Table *)pVtab);
119391: return rc;
119392: }
119393:
119394: /*
119395: ** Implementation of xBegin() method. This is a no-op.
119396: */
119397: static int fts3BeginMethod(sqlite3_vtab *pVtab){
119398: TESTONLY( Fts3Table *p = (Fts3Table*)pVtab );
119399: UNUSED_PARAMETER(pVtab);
119400: assert( p->pSegments==0 );
119401: assert( p->nPendingData==0 );
119402: assert( p->inTransaction!=1 );
119403: TESTONLY( p->inTransaction = 1 );
119404: TESTONLY( p->mxSavepoint = -1; );
119405: return SQLITE_OK;
119406: }
119407:
119408: /*
119409: ** Implementation of xCommit() method. This is a no-op. The contents of
119410: ** the pending-terms hash-table have already been flushed into the database
119411: ** by fts3SyncMethod().
119412: */
119413: static int fts3CommitMethod(sqlite3_vtab *pVtab){
119414: TESTONLY( Fts3Table *p = (Fts3Table*)pVtab );
119415: UNUSED_PARAMETER(pVtab);
119416: assert( p->nPendingData==0 );
119417: assert( p->inTransaction!=0 );
119418: assert( p->pSegments==0 );
119419: TESTONLY( p->inTransaction = 0 );
119420: TESTONLY( p->mxSavepoint = -1; );
119421: return SQLITE_OK;
119422: }
119423:
119424: /*
119425: ** Implementation of xRollback(). Discard the contents of the pending-terms
119426: ** hash-table. Any changes made to the database are reverted by SQLite.
119427: */
119428: static int fts3RollbackMethod(sqlite3_vtab *pVtab){
119429: Fts3Table *p = (Fts3Table*)pVtab;
119430: sqlite3Fts3PendingTermsClear(p);
119431: assert( p->inTransaction!=0 );
119432: TESTONLY( p->inTransaction = 0 );
119433: TESTONLY( p->mxSavepoint = -1; );
119434: return SQLITE_OK;
119435: }
119436:
119437: /*
119438: ** When called, *ppPoslist must point to the byte immediately following the
119439: ** end of a position-list. i.e. ( (*ppPoslist)[-1]==POS_END ). This function
119440: ** moves *ppPoslist so that it instead points to the first byte of the
119441: ** same position list.
119442: */
119443: static void fts3ReversePoslist(char *pStart, char **ppPoslist){
119444: char *p = &(*ppPoslist)[-2];
119445: char c = 0;
119446:
119447: while( p>pStart && (c=*p--)==0 );
119448: while( p>pStart && (*p & 0x80) | c ){
119449: c = *p--;
119450: }
119451: if( p>pStart ){ p = &p[2]; }
119452: while( *p++&0x80 );
119453: *ppPoslist = p;
119454: }
119455:
119456: /*
119457: ** Helper function used by the implementation of the overloaded snippet(),
119458: ** offsets() and optimize() SQL functions.
119459: **
119460: ** If the value passed as the third argument is a blob of size
119461: ** sizeof(Fts3Cursor*), then the blob contents are copied to the
119462: ** output variable *ppCsr and SQLITE_OK is returned. Otherwise, an error
119463: ** message is written to context pContext and SQLITE_ERROR returned. The
119464: ** string passed via zFunc is used as part of the error message.
119465: */
119466: static int fts3FunctionArg(
119467: sqlite3_context *pContext, /* SQL function call context */
119468: const char *zFunc, /* Function name */
119469: sqlite3_value *pVal, /* argv[0] passed to function */
119470: Fts3Cursor **ppCsr /* OUT: Store cursor handle here */
119471: ){
119472: Fts3Cursor *pRet;
119473: if( sqlite3_value_type(pVal)!=SQLITE_BLOB
119474: || sqlite3_value_bytes(pVal)!=sizeof(Fts3Cursor *)
119475: ){
119476: char *zErr = sqlite3_mprintf("illegal first argument to %s", zFunc);
119477: sqlite3_result_error(pContext, zErr, -1);
119478: sqlite3_free(zErr);
119479: return SQLITE_ERROR;
119480: }
119481: memcpy(&pRet, sqlite3_value_blob(pVal), sizeof(Fts3Cursor *));
119482: *ppCsr = pRet;
119483: return SQLITE_OK;
119484: }
119485:
119486: /*
119487: ** Implementation of the snippet() function for FTS3
119488: */
119489: static void fts3SnippetFunc(
119490: sqlite3_context *pContext, /* SQLite function call context */
119491: int nVal, /* Size of apVal[] array */
119492: sqlite3_value **apVal /* Array of arguments */
119493: ){
119494: Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
119495: const char *zStart = "<b>";
119496: const char *zEnd = "</b>";
119497: const char *zEllipsis = "<b>...</b>";
119498: int iCol = -1;
119499: int nToken = 15; /* Default number of tokens in snippet */
119500:
119501: /* There must be at least one argument passed to this function (otherwise
119502: ** the non-overloaded version would have been called instead of this one).
119503: */
119504: assert( nVal>=1 );
119505:
119506: if( nVal>6 ){
119507: sqlite3_result_error(pContext,
119508: "wrong number of arguments to function snippet()", -1);
119509: return;
119510: }
119511: if( fts3FunctionArg(pContext, "snippet", apVal[0], &pCsr) ) return;
119512:
119513: switch( nVal ){
119514: case 6: nToken = sqlite3_value_int(apVal[5]);
119515: case 5: iCol = sqlite3_value_int(apVal[4]);
119516: case 4: zEllipsis = (const char*)sqlite3_value_text(apVal[3]);
119517: case 3: zEnd = (const char*)sqlite3_value_text(apVal[2]);
119518: case 2: zStart = (const char*)sqlite3_value_text(apVal[1]);
119519: }
119520: if( !zEllipsis || !zEnd || !zStart ){
119521: sqlite3_result_error_nomem(pContext);
119522: }else if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
119523: sqlite3Fts3Snippet(pContext, pCsr, zStart, zEnd, zEllipsis, iCol, nToken);
119524: }
119525: }
119526:
119527: /*
119528: ** Implementation of the offsets() function for FTS3
119529: */
119530: static void fts3OffsetsFunc(
119531: sqlite3_context *pContext, /* SQLite function call context */
119532: int nVal, /* Size of argument array */
119533: sqlite3_value **apVal /* Array of arguments */
119534: ){
119535: Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
119536:
119537: UNUSED_PARAMETER(nVal);
119538:
119539: assert( nVal==1 );
119540: if( fts3FunctionArg(pContext, "offsets", apVal[0], &pCsr) ) return;
119541: assert( pCsr );
119542: if( SQLITE_OK==fts3CursorSeek(pContext, pCsr) ){
119543: sqlite3Fts3Offsets(pContext, pCsr);
119544: }
119545: }
119546:
119547: /*
119548: ** Implementation of the special optimize() function for FTS3. This
119549: ** function merges all segments in the database to a single segment.
119550: ** Example usage is:
119551: **
119552: ** SELECT optimize(t) FROM t LIMIT 1;
119553: **
119554: ** where 't' is the name of an FTS3 table.
119555: */
119556: static void fts3OptimizeFunc(
119557: sqlite3_context *pContext, /* SQLite function call context */
119558: int nVal, /* Size of argument array */
119559: sqlite3_value **apVal /* Array of arguments */
119560: ){
119561: int rc; /* Return code */
119562: Fts3Table *p; /* Virtual table handle */
119563: Fts3Cursor *pCursor; /* Cursor handle passed through apVal[0] */
119564:
119565: UNUSED_PARAMETER(nVal);
119566:
119567: assert( nVal==1 );
119568: if( fts3FunctionArg(pContext, "optimize", apVal[0], &pCursor) ) return;
119569: p = (Fts3Table *)pCursor->base.pVtab;
119570: assert( p );
119571:
119572: rc = sqlite3Fts3Optimize(p);
119573:
119574: switch( rc ){
119575: case SQLITE_OK:
119576: sqlite3_result_text(pContext, "Index optimized", -1, SQLITE_STATIC);
119577: break;
119578: case SQLITE_DONE:
119579: sqlite3_result_text(pContext, "Index already optimal", -1, SQLITE_STATIC);
119580: break;
119581: default:
119582: sqlite3_result_error_code(pContext, rc);
119583: break;
119584: }
119585: }
119586:
119587: /*
119588: ** Implementation of the matchinfo() function for FTS3
119589: */
119590: static void fts3MatchinfoFunc(
119591: sqlite3_context *pContext, /* SQLite function call context */
119592: int nVal, /* Size of argument array */
119593: sqlite3_value **apVal /* Array of arguments */
119594: ){
119595: Fts3Cursor *pCsr; /* Cursor handle passed through apVal[0] */
119596: assert( nVal==1 || nVal==2 );
119597: if( SQLITE_OK==fts3FunctionArg(pContext, "matchinfo", apVal[0], &pCsr) ){
119598: const char *zArg = 0;
119599: if( nVal>1 ){
119600: zArg = (const char *)sqlite3_value_text(apVal[1]);
119601: }
119602: sqlite3Fts3Matchinfo(pContext, pCsr, zArg);
119603: }
119604: }
119605:
119606: /*
119607: ** This routine implements the xFindFunction method for the FTS3
119608: ** virtual table.
119609: */
119610: static int fts3FindFunctionMethod(
119611: sqlite3_vtab *pVtab, /* Virtual table handle */
119612: int nArg, /* Number of SQL function arguments */
119613: const char *zName, /* Name of SQL function */
119614: void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
119615: void **ppArg /* Unused */
119616: ){
119617: struct Overloaded {
119618: const char *zName;
119619: void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
119620: } aOverload[] = {
119621: { "snippet", fts3SnippetFunc },
119622: { "offsets", fts3OffsetsFunc },
119623: { "optimize", fts3OptimizeFunc },
119624: { "matchinfo", fts3MatchinfoFunc },
119625: };
119626: int i; /* Iterator variable */
119627:
119628: UNUSED_PARAMETER(pVtab);
119629: UNUSED_PARAMETER(nArg);
119630: UNUSED_PARAMETER(ppArg);
119631:
119632: for(i=0; i<SizeofArray(aOverload); i++){
119633: if( strcmp(zName, aOverload[i].zName)==0 ){
119634: *pxFunc = aOverload[i].xFunc;
119635: return 1;
119636: }
119637: }
119638:
119639: /* No function of the specified name was found. Return 0. */
119640: return 0;
119641: }
119642:
119643: /*
119644: ** Implementation of FTS3 xRename method. Rename an fts3 table.
119645: */
119646: static int fts3RenameMethod(
119647: sqlite3_vtab *pVtab, /* Virtual table handle */
119648: const char *zName /* New name of table */
119649: ){
119650: Fts3Table *p = (Fts3Table *)pVtab;
119651: sqlite3 *db = p->db; /* Database connection */
119652: int rc; /* Return Code */
119653:
119654: /* As it happens, the pending terms table is always empty here. This is
119655: ** because an "ALTER TABLE RENAME TABLE" statement inside a transaction
119656: ** always opens a savepoint transaction. And the xSavepoint() method
119657: ** flushes the pending terms table. But leave the (no-op) call to
119658: ** PendingTermsFlush() in in case that changes.
119659: */
119660: assert( p->nPendingData==0 );
119661: rc = sqlite3Fts3PendingTermsFlush(p);
119662:
119663: if( p->zContentTbl==0 ){
119664: fts3DbExec(&rc, db,
119665: "ALTER TABLE %Q.'%q_content' RENAME TO '%q_content';",
119666: p->zDb, p->zName, zName
119667: );
119668: }
119669:
119670: if( p->bHasDocsize ){
119671: fts3DbExec(&rc, db,
119672: "ALTER TABLE %Q.'%q_docsize' RENAME TO '%q_docsize';",
119673: p->zDb, p->zName, zName
119674: );
119675: }
119676: if( p->bHasStat ){
119677: fts3DbExec(&rc, db,
119678: "ALTER TABLE %Q.'%q_stat' RENAME TO '%q_stat';",
119679: p->zDb, p->zName, zName
119680: );
119681: }
119682: fts3DbExec(&rc, db,
119683: "ALTER TABLE %Q.'%q_segments' RENAME TO '%q_segments';",
119684: p->zDb, p->zName, zName
119685: );
119686: fts3DbExec(&rc, db,
119687: "ALTER TABLE %Q.'%q_segdir' RENAME TO '%q_segdir';",
119688: p->zDb, p->zName, zName
119689: );
119690: return rc;
119691: }
119692:
119693: /*
119694: ** The xSavepoint() method.
119695: **
119696: ** Flush the contents of the pending-terms table to disk.
119697: */
119698: static int fts3SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){
119699: UNUSED_PARAMETER(iSavepoint);
119700: assert( ((Fts3Table *)pVtab)->inTransaction );
119701: assert( ((Fts3Table *)pVtab)->mxSavepoint < iSavepoint );
119702: TESTONLY( ((Fts3Table *)pVtab)->mxSavepoint = iSavepoint );
119703: return fts3SyncMethod(pVtab);
119704: }
119705:
119706: /*
119707: ** The xRelease() method.
119708: **
119709: ** This is a no-op.
119710: */
119711: static int fts3ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){
119712: TESTONLY( Fts3Table *p = (Fts3Table*)pVtab );
119713: UNUSED_PARAMETER(iSavepoint);
119714: UNUSED_PARAMETER(pVtab);
119715: assert( p->inTransaction );
119716: assert( p->mxSavepoint >= iSavepoint );
119717: TESTONLY( p->mxSavepoint = iSavepoint-1 );
119718: return SQLITE_OK;
119719: }
119720:
119721: /*
119722: ** The xRollbackTo() method.
119723: **
119724: ** Discard the contents of the pending terms table.
119725: */
119726: static int fts3RollbackToMethod(sqlite3_vtab *pVtab, int iSavepoint){
119727: Fts3Table *p = (Fts3Table*)pVtab;
119728: UNUSED_PARAMETER(iSavepoint);
119729: assert( p->inTransaction );
119730: assert( p->mxSavepoint >= iSavepoint );
119731: TESTONLY( p->mxSavepoint = iSavepoint );
119732: sqlite3Fts3PendingTermsClear(p);
119733: return SQLITE_OK;
119734: }
119735:
119736: static const sqlite3_module fts3Module = {
119737: /* iVersion */ 2,
119738: /* xCreate */ fts3CreateMethod,
119739: /* xConnect */ fts3ConnectMethod,
119740: /* xBestIndex */ fts3BestIndexMethod,
119741: /* xDisconnect */ fts3DisconnectMethod,
119742: /* xDestroy */ fts3DestroyMethod,
119743: /* xOpen */ fts3OpenMethod,
119744: /* xClose */ fts3CloseMethod,
119745: /* xFilter */ fts3FilterMethod,
119746: /* xNext */ fts3NextMethod,
119747: /* xEof */ fts3EofMethod,
119748: /* xColumn */ fts3ColumnMethod,
119749: /* xRowid */ fts3RowidMethod,
119750: /* xUpdate */ fts3UpdateMethod,
119751: /* xBegin */ fts3BeginMethod,
119752: /* xSync */ fts3SyncMethod,
119753: /* xCommit */ fts3CommitMethod,
119754: /* xRollback */ fts3RollbackMethod,
119755: /* xFindFunction */ fts3FindFunctionMethod,
119756: /* xRename */ fts3RenameMethod,
119757: /* xSavepoint */ fts3SavepointMethod,
119758: /* xRelease */ fts3ReleaseMethod,
119759: /* xRollbackTo */ fts3RollbackToMethod,
119760: };
119761:
119762: /*
119763: ** This function is registered as the module destructor (called when an
119764: ** FTS3 enabled database connection is closed). It frees the memory
119765: ** allocated for the tokenizer hash table.
119766: */
119767: static void hashDestroy(void *p){
119768: Fts3Hash *pHash = (Fts3Hash *)p;
119769: sqlite3Fts3HashClear(pHash);
119770: sqlite3_free(pHash);
119771: }
119772:
119773: /*
119774: ** The fts3 built-in tokenizers - "simple", "porter" and "icu"- are
119775: ** implemented in files fts3_tokenizer1.c, fts3_porter.c and fts3_icu.c
119776: ** respectively. The following three forward declarations are for functions
119777: ** declared in these files used to retrieve the respective implementations.
119778: **
119779: ** Calling sqlite3Fts3SimpleTokenizerModule() sets the value pointed
119780: ** to by the argument to point to the "simple" tokenizer implementation.
119781: ** And so on.
119782: */
119783: SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
119784: SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule(sqlite3_tokenizer_module const**ppModule);
119785: #ifdef SQLITE_ENABLE_ICU
119786: SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(sqlite3_tokenizer_module const**ppModule);
119787: #endif
119788:
119789: /*
119790: ** Initialise the fts3 extension. If this extension is built as part
119791: ** of the sqlite library, then this function is called directly by
119792: ** SQLite. If fts3 is built as a dynamically loadable extension, this
119793: ** function is called by the sqlite3_extension_init() entry point.
119794: */
119795: SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db){
119796: int rc = SQLITE_OK;
119797: Fts3Hash *pHash = 0;
119798: const sqlite3_tokenizer_module *pSimple = 0;
119799: const sqlite3_tokenizer_module *pPorter = 0;
119800:
119801: #ifdef SQLITE_ENABLE_ICU
119802: const sqlite3_tokenizer_module *pIcu = 0;
119803: sqlite3Fts3IcuTokenizerModule(&pIcu);
119804: #endif
119805:
119806: #ifdef SQLITE_TEST
119807: rc = sqlite3Fts3InitTerm(db);
119808: if( rc!=SQLITE_OK ) return rc;
119809: #endif
119810:
119811: rc = sqlite3Fts3InitAux(db);
119812: if( rc!=SQLITE_OK ) return rc;
119813:
119814: sqlite3Fts3SimpleTokenizerModule(&pSimple);
119815: sqlite3Fts3PorterTokenizerModule(&pPorter);
119816:
119817: /* Allocate and initialise the hash-table used to store tokenizers. */
119818: pHash = sqlite3_malloc(sizeof(Fts3Hash));
119819: if( !pHash ){
119820: rc = SQLITE_NOMEM;
119821: }else{
119822: sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
119823: }
119824:
119825: /* Load the built-in tokenizers into the hash table */
119826: if( rc==SQLITE_OK ){
119827: if( sqlite3Fts3HashInsert(pHash, "simple", 7, (void *)pSimple)
119828: || sqlite3Fts3HashInsert(pHash, "porter", 7, (void *)pPorter)
119829: #ifdef SQLITE_ENABLE_ICU
119830: || (pIcu && sqlite3Fts3HashInsert(pHash, "icu", 4, (void *)pIcu))
119831: #endif
119832: ){
119833: rc = SQLITE_NOMEM;
119834: }
119835: }
119836:
119837: #ifdef SQLITE_TEST
119838: if( rc==SQLITE_OK ){
119839: rc = sqlite3Fts3ExprInitTestInterface(db);
119840: }
119841: #endif
119842:
119843: /* Create the virtual table wrapper around the hash-table and overload
119844: ** the two scalar functions. If this is successful, register the
119845: ** module with sqlite.
119846: */
119847: if( SQLITE_OK==rc
119848: && SQLITE_OK==(rc = sqlite3Fts3InitHashTable(db, pHash, "fts3_tokenizer"))
119849: && SQLITE_OK==(rc = sqlite3_overload_function(db, "snippet", -1))
119850: && SQLITE_OK==(rc = sqlite3_overload_function(db, "offsets", 1))
119851: && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 1))
119852: && SQLITE_OK==(rc = sqlite3_overload_function(db, "matchinfo", 2))
119853: && SQLITE_OK==(rc = sqlite3_overload_function(db, "optimize", 1))
119854: ){
119855: rc = sqlite3_create_module_v2(
119856: db, "fts3", &fts3Module, (void *)pHash, hashDestroy
119857: );
119858: if( rc==SQLITE_OK ){
119859: rc = sqlite3_create_module_v2(
119860: db, "fts4", &fts3Module, (void *)pHash, 0
119861: );
119862: }
119863: return rc;
119864: }
119865:
119866: /* An error has occurred. Delete the hash table and return the error code. */
119867: assert( rc!=SQLITE_OK );
119868: if( pHash ){
119869: sqlite3Fts3HashClear(pHash);
119870: sqlite3_free(pHash);
119871: }
119872: return rc;
119873: }
119874:
119875: /*
119876: ** Allocate an Fts3MultiSegReader for each token in the expression headed
119877: ** by pExpr.
119878: **
119879: ** An Fts3SegReader object is a cursor that can seek or scan a range of
119880: ** entries within a single segment b-tree. An Fts3MultiSegReader uses multiple
119881: ** Fts3SegReader objects internally to provide an interface to seek or scan
119882: ** within the union of all segments of a b-tree. Hence the name.
119883: **
119884: ** If the allocated Fts3MultiSegReader just seeks to a single entry in a
119885: ** segment b-tree (if the term is not a prefix or it is a prefix for which
119886: ** there exists prefix b-tree of the right length) then it may be traversed
119887: ** and merged incrementally. Otherwise, it has to be merged into an in-memory
119888: ** doclist and then traversed.
119889: */
119890: static void fts3EvalAllocateReaders(
119891: Fts3Cursor *pCsr, /* FTS cursor handle */
119892: Fts3Expr *pExpr, /* Allocate readers for this expression */
119893: int *pnToken, /* OUT: Total number of tokens in phrase. */
119894: int *pnOr, /* OUT: Total number of OR nodes in expr. */
119895: int *pRc /* IN/OUT: Error code */
119896: ){
119897: if( pExpr && SQLITE_OK==*pRc ){
119898: if( pExpr->eType==FTSQUERY_PHRASE ){
119899: int i;
119900: int nToken = pExpr->pPhrase->nToken;
119901: *pnToken += nToken;
119902: for(i=0; i<nToken; i++){
119903: Fts3PhraseToken *pToken = &pExpr->pPhrase->aToken[i];
119904: int rc = fts3TermSegReaderCursor(pCsr,
119905: pToken->z, pToken->n, pToken->isPrefix, &pToken->pSegcsr
119906: );
119907: if( rc!=SQLITE_OK ){
119908: *pRc = rc;
119909: return;
119910: }
119911: }
119912: assert( pExpr->pPhrase->iDoclistToken==0 );
119913: pExpr->pPhrase->iDoclistToken = -1;
119914: }else{
119915: *pnOr += (pExpr->eType==FTSQUERY_OR);
119916: fts3EvalAllocateReaders(pCsr, pExpr->pLeft, pnToken, pnOr, pRc);
119917: fts3EvalAllocateReaders(pCsr, pExpr->pRight, pnToken, pnOr, pRc);
119918: }
119919: }
119920: }
119921:
119922: /*
119923: ** Arguments pList/nList contain the doclist for token iToken of phrase p.
119924: ** It is merged into the main doclist stored in p->doclist.aAll/nAll.
119925: **
119926: ** This function assumes that pList points to a buffer allocated using
119927: ** sqlite3_malloc(). This function takes responsibility for eventually
119928: ** freeing the buffer.
119929: */
119930: static void fts3EvalPhraseMergeToken(
119931: Fts3Table *pTab, /* FTS Table pointer */
119932: Fts3Phrase *p, /* Phrase to merge pList/nList into */
119933: int iToken, /* Token pList/nList corresponds to */
119934: char *pList, /* Pointer to doclist */
119935: int nList /* Number of bytes in pList */
119936: ){
119937: assert( iToken!=p->iDoclistToken );
119938:
119939: if( pList==0 ){
119940: sqlite3_free(p->doclist.aAll);
119941: p->doclist.aAll = 0;
119942: p->doclist.nAll = 0;
119943: }
119944:
119945: else if( p->iDoclistToken<0 ){
119946: p->doclist.aAll = pList;
119947: p->doclist.nAll = nList;
119948: }
119949:
119950: else if( p->doclist.aAll==0 ){
119951: sqlite3_free(pList);
119952: }
119953:
119954: else {
119955: char *pLeft;
119956: char *pRight;
119957: int nLeft;
119958: int nRight;
119959: int nDiff;
119960:
119961: if( p->iDoclistToken<iToken ){
119962: pLeft = p->doclist.aAll;
119963: nLeft = p->doclist.nAll;
119964: pRight = pList;
119965: nRight = nList;
119966: nDiff = iToken - p->iDoclistToken;
119967: }else{
119968: pRight = p->doclist.aAll;
119969: nRight = p->doclist.nAll;
119970: pLeft = pList;
119971: nLeft = nList;
119972: nDiff = p->iDoclistToken - iToken;
119973: }
119974:
119975: fts3DoclistPhraseMerge(pTab->bDescIdx, nDiff, pLeft, nLeft, pRight,&nRight);
119976: sqlite3_free(pLeft);
119977: p->doclist.aAll = pRight;
119978: p->doclist.nAll = nRight;
119979: }
119980:
119981: if( iToken>p->iDoclistToken ) p->iDoclistToken = iToken;
119982: }
119983:
119984: /*
119985: ** Load the doclist for phrase p into p->doclist.aAll/nAll. The loaded doclist
119986: ** does not take deferred tokens into account.
119987: **
119988: ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
119989: */
119990: static int fts3EvalPhraseLoad(
119991: Fts3Cursor *pCsr, /* FTS Cursor handle */
119992: Fts3Phrase *p /* Phrase object */
119993: ){
119994: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
119995: int iToken;
119996: int rc = SQLITE_OK;
119997:
119998: for(iToken=0; rc==SQLITE_OK && iToken<p->nToken; iToken++){
119999: Fts3PhraseToken *pToken = &p->aToken[iToken];
120000: assert( pToken->pDeferred==0 || pToken->pSegcsr==0 );
120001:
120002: if( pToken->pSegcsr ){
120003: int nThis = 0;
120004: char *pThis = 0;
120005: rc = fts3TermSelect(pTab, pToken, p->iColumn, &nThis, &pThis);
120006: if( rc==SQLITE_OK ){
120007: fts3EvalPhraseMergeToken(pTab, p, iToken, pThis, nThis);
120008: }
120009: }
120010: assert( pToken->pSegcsr==0 );
120011: }
120012:
120013: return rc;
120014: }
120015:
120016: /*
120017: ** This function is called on each phrase after the position lists for
120018: ** any deferred tokens have been loaded into memory. It updates the phrases
120019: ** current position list to include only those positions that are really
120020: ** instances of the phrase (after considering deferred tokens). If this
120021: ** means that the phrase does not appear in the current row, doclist.pList
120022: ** and doclist.nList are both zeroed.
120023: **
120024: ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
120025: */
120026: static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){
120027: int iToken; /* Used to iterate through phrase tokens */
120028: char *aPoslist = 0; /* Position list for deferred tokens */
120029: int nPoslist = 0; /* Number of bytes in aPoslist */
120030: int iPrev = -1; /* Token number of previous deferred token */
120031:
120032: assert( pPhrase->doclist.bFreeList==0 );
120033:
120034: for(iToken=0; iToken<pPhrase->nToken; iToken++){
120035: Fts3PhraseToken *pToken = &pPhrase->aToken[iToken];
120036: Fts3DeferredToken *pDeferred = pToken->pDeferred;
120037:
120038: if( pDeferred ){
120039: char *pList;
120040: int nList;
120041: int rc = sqlite3Fts3DeferredTokenList(pDeferred, &pList, &nList);
120042: if( rc!=SQLITE_OK ) return rc;
120043:
120044: if( pList==0 ){
120045: sqlite3_free(aPoslist);
120046: pPhrase->doclist.pList = 0;
120047: pPhrase->doclist.nList = 0;
120048: return SQLITE_OK;
120049:
120050: }else if( aPoslist==0 ){
120051: aPoslist = pList;
120052: nPoslist = nList;
120053:
120054: }else{
120055: char *aOut = pList;
120056: char *p1 = aPoslist;
120057: char *p2 = aOut;
120058:
120059: assert( iPrev>=0 );
120060: fts3PoslistPhraseMerge(&aOut, iToken-iPrev, 0, 1, &p1, &p2);
120061: sqlite3_free(aPoslist);
120062: aPoslist = pList;
120063: nPoslist = aOut - aPoslist;
120064: if( nPoslist==0 ){
120065: sqlite3_free(aPoslist);
120066: pPhrase->doclist.pList = 0;
120067: pPhrase->doclist.nList = 0;
120068: return SQLITE_OK;
120069: }
120070: }
120071: iPrev = iToken;
120072: }
120073: }
120074:
120075: if( iPrev>=0 ){
120076: int nMaxUndeferred = pPhrase->iDoclistToken;
120077: if( nMaxUndeferred<0 ){
120078: pPhrase->doclist.pList = aPoslist;
120079: pPhrase->doclist.nList = nPoslist;
120080: pPhrase->doclist.iDocid = pCsr->iPrevId;
120081: pPhrase->doclist.bFreeList = 1;
120082: }else{
120083: int nDistance;
120084: char *p1;
120085: char *p2;
120086: char *aOut;
120087:
120088: if( nMaxUndeferred>iPrev ){
120089: p1 = aPoslist;
120090: p2 = pPhrase->doclist.pList;
120091: nDistance = nMaxUndeferred - iPrev;
120092: }else{
120093: p1 = pPhrase->doclist.pList;
120094: p2 = aPoslist;
120095: nDistance = iPrev - nMaxUndeferred;
120096: }
120097:
120098: aOut = (char *)sqlite3_malloc(nPoslist+8);
120099: if( !aOut ){
120100: sqlite3_free(aPoslist);
120101: return SQLITE_NOMEM;
120102: }
120103:
120104: pPhrase->doclist.pList = aOut;
120105: if( fts3PoslistPhraseMerge(&aOut, nDistance, 0, 1, &p1, &p2) ){
120106: pPhrase->doclist.bFreeList = 1;
120107: pPhrase->doclist.nList = (aOut - pPhrase->doclist.pList);
120108: }else{
120109: sqlite3_free(aOut);
120110: pPhrase->doclist.pList = 0;
120111: pPhrase->doclist.nList = 0;
120112: }
120113: sqlite3_free(aPoslist);
120114: }
120115: }
120116:
120117: return SQLITE_OK;
120118: }
120119:
120120: /*
120121: ** This function is called for each Fts3Phrase in a full-text query
120122: ** expression to initialize the mechanism for returning rows. Once this
120123: ** function has been called successfully on an Fts3Phrase, it may be
120124: ** used with fts3EvalPhraseNext() to iterate through the matching docids.
120125: **
120126: ** If parameter bOptOk is true, then the phrase may (or may not) use the
120127: ** incremental loading strategy. Otherwise, the entire doclist is loaded into
120128: ** memory within this call.
120129: **
120130: ** SQLITE_OK is returned if no error occurs, otherwise an SQLite error code.
120131: */
120132: static int fts3EvalPhraseStart(Fts3Cursor *pCsr, int bOptOk, Fts3Phrase *p){
120133: int rc; /* Error code */
120134: Fts3PhraseToken *pFirst = &p->aToken[0];
120135: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
120136:
120137: if( pCsr->bDesc==pTab->bDescIdx
120138: && bOptOk==1
120139: && p->nToken==1
120140: && pFirst->pSegcsr
120141: && pFirst->pSegcsr->bLookup
120142: && pFirst->bFirst==0
120143: ){
120144: /* Use the incremental approach. */
120145: int iCol = (p->iColumn >= pTab->nColumn ? -1 : p->iColumn);
120146: rc = sqlite3Fts3MsrIncrStart(
120147: pTab, pFirst->pSegcsr, iCol, pFirst->z, pFirst->n);
120148: p->bIncr = 1;
120149:
120150: }else{
120151: /* Load the full doclist for the phrase into memory. */
120152: rc = fts3EvalPhraseLoad(pCsr, p);
120153: p->bIncr = 0;
120154: }
120155:
120156: assert( rc!=SQLITE_OK || p->nToken<1 || p->aToken[0].pSegcsr==0 || p->bIncr );
120157: return rc;
120158: }
120159:
120160: /*
120161: ** This function is used to iterate backwards (from the end to start)
120162: ** through doclists. It is used by this module to iterate through phrase
120163: ** doclists in reverse and by the fts3_write.c module to iterate through
120164: ** pending-terms lists when writing to databases with "order=desc".
120165: **
120166: ** The doclist may be sorted in ascending (parameter bDescIdx==0) or
120167: ** descending (parameter bDescIdx==1) order of docid. Regardless, this
120168: ** function iterates from the end of the doclist to the beginning.
120169: */
120170: SQLITE_PRIVATE void sqlite3Fts3DoclistPrev(
120171: int bDescIdx, /* True if the doclist is desc */
120172: char *aDoclist, /* Pointer to entire doclist */
120173: int nDoclist, /* Length of aDoclist in bytes */
120174: char **ppIter, /* IN/OUT: Iterator pointer */
120175: sqlite3_int64 *piDocid, /* IN/OUT: Docid pointer */
120176: int *pnList, /* IN/OUT: List length pointer */
120177: u8 *pbEof /* OUT: End-of-file flag */
120178: ){
120179: char *p = *ppIter;
120180:
120181: assert( nDoclist>0 );
120182: assert( *pbEof==0 );
120183: assert( p || *piDocid==0 );
120184: assert( !p || (p>aDoclist && p<&aDoclist[nDoclist]) );
120185:
120186: if( p==0 ){
120187: sqlite3_int64 iDocid = 0;
120188: char *pNext = 0;
120189: char *pDocid = aDoclist;
120190: char *pEnd = &aDoclist[nDoclist];
120191: int iMul = 1;
120192:
120193: while( pDocid<pEnd ){
120194: sqlite3_int64 iDelta;
120195: pDocid += sqlite3Fts3GetVarint(pDocid, &iDelta);
120196: iDocid += (iMul * iDelta);
120197: pNext = pDocid;
120198: fts3PoslistCopy(0, &pDocid);
120199: while( pDocid<pEnd && *pDocid==0 ) pDocid++;
120200: iMul = (bDescIdx ? -1 : 1);
120201: }
120202:
120203: *pnList = pEnd - pNext;
120204: *ppIter = pNext;
120205: *piDocid = iDocid;
120206: }else{
120207: int iMul = (bDescIdx ? -1 : 1);
120208: sqlite3_int64 iDelta;
120209: fts3GetReverseVarint(&p, aDoclist, &iDelta);
120210: *piDocid -= (iMul * iDelta);
120211:
120212: if( p==aDoclist ){
120213: *pbEof = 1;
120214: }else{
120215: char *pSave = p;
120216: fts3ReversePoslist(aDoclist, &p);
120217: *pnList = (pSave - p);
120218: }
120219: *ppIter = p;
120220: }
120221: }
120222:
120223: /*
120224: ** Attempt to move the phrase iterator to point to the next matching docid.
120225: ** If an error occurs, return an SQLite error code. Otherwise, return
120226: ** SQLITE_OK.
120227: **
120228: ** If there is no "next" entry and no error occurs, then *pbEof is set to
120229: ** 1 before returning. Otherwise, if no error occurs and the iterator is
120230: ** successfully advanced, *pbEof is set to 0.
120231: */
120232: static int fts3EvalPhraseNext(
120233: Fts3Cursor *pCsr, /* FTS Cursor handle */
120234: Fts3Phrase *p, /* Phrase object to advance to next docid */
120235: u8 *pbEof /* OUT: Set to 1 if EOF */
120236: ){
120237: int rc = SQLITE_OK;
120238: Fts3Doclist *pDL = &p->doclist;
120239: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
120240:
120241: if( p->bIncr ){
120242: assert( p->nToken==1 );
120243: assert( pDL->pNextDocid==0 );
120244: rc = sqlite3Fts3MsrIncrNext(pTab, p->aToken[0].pSegcsr,
120245: &pDL->iDocid, &pDL->pList, &pDL->nList
120246: );
120247: if( rc==SQLITE_OK && !pDL->pList ){
120248: *pbEof = 1;
120249: }
120250: }else if( pCsr->bDesc!=pTab->bDescIdx && pDL->nAll ){
120251: sqlite3Fts3DoclistPrev(pTab->bDescIdx, pDL->aAll, pDL->nAll,
120252: &pDL->pNextDocid, &pDL->iDocid, &pDL->nList, pbEof
120253: );
120254: pDL->pList = pDL->pNextDocid;
120255: }else{
120256: char *pIter; /* Used to iterate through aAll */
120257: char *pEnd = &pDL->aAll[pDL->nAll]; /* 1 byte past end of aAll */
120258: if( pDL->pNextDocid ){
120259: pIter = pDL->pNextDocid;
120260: }else{
120261: pIter = pDL->aAll;
120262: }
120263:
120264: if( pIter>=pEnd ){
120265: /* We have already reached the end of this doclist. EOF. */
120266: *pbEof = 1;
120267: }else{
120268: sqlite3_int64 iDelta;
120269: pIter += sqlite3Fts3GetVarint(pIter, &iDelta);
120270: if( pTab->bDescIdx==0 || pDL->pNextDocid==0 ){
120271: pDL->iDocid += iDelta;
120272: }else{
120273: pDL->iDocid -= iDelta;
120274: }
120275: pDL->pList = pIter;
120276: fts3PoslistCopy(0, &pIter);
120277: pDL->nList = (pIter - pDL->pList);
120278:
120279: /* pIter now points just past the 0x00 that terminates the position-
120280: ** list for document pDL->iDocid. However, if this position-list was
120281: ** edited in place by fts3EvalNearTrim(), then pIter may not actually
120282: ** point to the start of the next docid value. The following line deals
120283: ** with this case by advancing pIter past the zero-padding added by
120284: ** fts3EvalNearTrim(). */
120285: while( pIter<pEnd && *pIter==0 ) pIter++;
120286:
120287: pDL->pNextDocid = pIter;
120288: assert( pIter>=&pDL->aAll[pDL->nAll] || *pIter );
120289: *pbEof = 0;
120290: }
120291: }
120292:
120293: return rc;
120294: }
120295:
120296: /*
120297: **
120298: ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
120299: ** Otherwise, fts3EvalPhraseStart() is called on all phrases within the
120300: ** expression. Also the Fts3Expr.bDeferred variable is set to true for any
120301: ** expressions for which all descendent tokens are deferred.
120302: **
120303: ** If parameter bOptOk is zero, then it is guaranteed that the
120304: ** Fts3Phrase.doclist.aAll/nAll variables contain the entire doclist for
120305: ** each phrase in the expression (subject to deferred token processing).
120306: ** Or, if bOptOk is non-zero, then one or more tokens within the expression
120307: ** may be loaded incrementally, meaning doclist.aAll/nAll is not available.
120308: **
120309: ** If an error occurs within this function, *pRc is set to an SQLite error
120310: ** code before returning.
120311: */
120312: static void fts3EvalStartReaders(
120313: Fts3Cursor *pCsr, /* FTS Cursor handle */
120314: Fts3Expr *pExpr, /* Expression to initialize phrases in */
120315: int bOptOk, /* True to enable incremental loading */
120316: int *pRc /* IN/OUT: Error code */
120317: ){
120318: if( pExpr && SQLITE_OK==*pRc ){
120319: if( pExpr->eType==FTSQUERY_PHRASE ){
120320: int i;
120321: int nToken = pExpr->pPhrase->nToken;
120322: for(i=0; i<nToken; i++){
120323: if( pExpr->pPhrase->aToken[i].pDeferred==0 ) break;
120324: }
120325: pExpr->bDeferred = (i==nToken);
120326: *pRc = fts3EvalPhraseStart(pCsr, bOptOk, pExpr->pPhrase);
120327: }else{
120328: fts3EvalStartReaders(pCsr, pExpr->pLeft, bOptOk, pRc);
120329: fts3EvalStartReaders(pCsr, pExpr->pRight, bOptOk, pRc);
120330: pExpr->bDeferred = (pExpr->pLeft->bDeferred && pExpr->pRight->bDeferred);
120331: }
120332: }
120333: }
120334:
120335: /*
120336: ** An array of the following structures is assembled as part of the process
120337: ** of selecting tokens to defer before the query starts executing (as part
120338: ** of the xFilter() method). There is one element in the array for each
120339: ** token in the FTS expression.
120340: **
120341: ** Tokens are divided into AND/NEAR clusters. All tokens in a cluster belong
120342: ** to phrases that are connected only by AND and NEAR operators (not OR or
120343: ** NOT). When determining tokens to defer, each AND/NEAR cluster is considered
120344: ** separately. The root of a tokens AND/NEAR cluster is stored in
120345: ** Fts3TokenAndCost.pRoot.
120346: */
120347: typedef struct Fts3TokenAndCost Fts3TokenAndCost;
120348: struct Fts3TokenAndCost {
120349: Fts3Phrase *pPhrase; /* The phrase the token belongs to */
120350: int iToken; /* Position of token in phrase */
120351: Fts3PhraseToken *pToken; /* The token itself */
120352: Fts3Expr *pRoot; /* Root of NEAR/AND cluster */
120353: int nOvfl; /* Number of overflow pages to load doclist */
120354: int iCol; /* The column the token must match */
120355: };
120356:
120357: /*
120358: ** This function is used to populate an allocated Fts3TokenAndCost array.
120359: **
120360: ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
120361: ** Otherwise, if an error occurs during execution, *pRc is set to an
120362: ** SQLite error code.
120363: */
120364: static void fts3EvalTokenCosts(
120365: Fts3Cursor *pCsr, /* FTS Cursor handle */
120366: Fts3Expr *pRoot, /* Root of current AND/NEAR cluster */
120367: Fts3Expr *pExpr, /* Expression to consider */
120368: Fts3TokenAndCost **ppTC, /* Write new entries to *(*ppTC)++ */
120369: Fts3Expr ***ppOr, /* Write new OR root to *(*ppOr)++ */
120370: int *pRc /* IN/OUT: Error code */
120371: ){
120372: if( *pRc==SQLITE_OK ){
120373: if( pExpr->eType==FTSQUERY_PHRASE ){
120374: Fts3Phrase *pPhrase = pExpr->pPhrase;
120375: int i;
120376: for(i=0; *pRc==SQLITE_OK && i<pPhrase->nToken; i++){
120377: Fts3TokenAndCost *pTC = (*ppTC)++;
120378: pTC->pPhrase = pPhrase;
120379: pTC->iToken = i;
120380: pTC->pRoot = pRoot;
120381: pTC->pToken = &pPhrase->aToken[i];
120382: pTC->iCol = pPhrase->iColumn;
120383: *pRc = sqlite3Fts3MsrOvfl(pCsr, pTC->pToken->pSegcsr, &pTC->nOvfl);
120384: }
120385: }else if( pExpr->eType!=FTSQUERY_NOT ){
120386: assert( pExpr->eType==FTSQUERY_OR
120387: || pExpr->eType==FTSQUERY_AND
120388: || pExpr->eType==FTSQUERY_NEAR
120389: );
120390: assert( pExpr->pLeft && pExpr->pRight );
120391: if( pExpr->eType==FTSQUERY_OR ){
120392: pRoot = pExpr->pLeft;
120393: **ppOr = pRoot;
120394: (*ppOr)++;
120395: }
120396: fts3EvalTokenCosts(pCsr, pRoot, pExpr->pLeft, ppTC, ppOr, pRc);
120397: if( pExpr->eType==FTSQUERY_OR ){
120398: pRoot = pExpr->pRight;
120399: **ppOr = pRoot;
120400: (*ppOr)++;
120401: }
120402: fts3EvalTokenCosts(pCsr, pRoot, pExpr->pRight, ppTC, ppOr, pRc);
120403: }
120404: }
120405: }
120406:
120407: /*
120408: ** Determine the average document (row) size in pages. If successful,
120409: ** write this value to *pnPage and return SQLITE_OK. Otherwise, return
120410: ** an SQLite error code.
120411: **
120412: ** The average document size in pages is calculated by first calculating
120413: ** determining the average size in bytes, B. If B is less than the amount
120414: ** of data that will fit on a single leaf page of an intkey table in
120415: ** this database, then the average docsize is 1. Otherwise, it is 1 plus
120416: ** the number of overflow pages consumed by a record B bytes in size.
120417: */
120418: static int fts3EvalAverageDocsize(Fts3Cursor *pCsr, int *pnPage){
120419: if( pCsr->nRowAvg==0 ){
120420: /* The average document size, which is required to calculate the cost
120421: ** of each doclist, has not yet been determined. Read the required
120422: ** data from the %_stat table to calculate it.
120423: **
120424: ** Entry 0 of the %_stat table is a blob containing (nCol+1) FTS3
120425: ** varints, where nCol is the number of columns in the FTS3 table.
120426: ** The first varint is the number of documents currently stored in
120427: ** the table. The following nCol varints contain the total amount of
120428: ** data stored in all rows of each column of the table, from left
120429: ** to right.
120430: */
120431: int rc;
120432: Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
120433: sqlite3_stmt *pStmt;
120434: sqlite3_int64 nDoc = 0;
120435: sqlite3_int64 nByte = 0;
120436: const char *pEnd;
120437: const char *a;
120438:
120439: rc = sqlite3Fts3SelectDoctotal(p, &pStmt);
120440: if( rc!=SQLITE_OK ) return rc;
120441: a = sqlite3_column_blob(pStmt, 0);
120442: assert( a );
120443:
120444: pEnd = &a[sqlite3_column_bytes(pStmt, 0)];
120445: a += sqlite3Fts3GetVarint(a, &nDoc);
120446: while( a<pEnd ){
120447: a += sqlite3Fts3GetVarint(a, &nByte);
120448: }
120449: if( nDoc==0 || nByte==0 ){
120450: sqlite3_reset(pStmt);
120451: return FTS_CORRUPT_VTAB;
120452: }
120453:
120454: pCsr->nDoc = nDoc;
120455: pCsr->nRowAvg = (int)(((nByte / nDoc) + p->nPgsz) / p->nPgsz);
120456: assert( pCsr->nRowAvg>0 );
120457: rc = sqlite3_reset(pStmt);
120458: if( rc!=SQLITE_OK ) return rc;
120459: }
120460:
120461: *pnPage = pCsr->nRowAvg;
120462: return SQLITE_OK;
120463: }
120464:
120465: /*
120466: ** This function is called to select the tokens (if any) that will be
120467: ** deferred. The array aTC[] has already been populated when this is
120468: ** called.
120469: **
120470: ** This function is called once for each AND/NEAR cluster in the
120471: ** expression. Each invocation determines which tokens to defer within
120472: ** the cluster with root node pRoot. See comments above the definition
120473: ** of struct Fts3TokenAndCost for more details.
120474: **
120475: ** If no error occurs, SQLITE_OK is returned and sqlite3Fts3DeferToken()
120476: ** called on each token to defer. Otherwise, an SQLite error code is
120477: ** returned.
120478: */
120479: static int fts3EvalSelectDeferred(
120480: Fts3Cursor *pCsr, /* FTS Cursor handle */
120481: Fts3Expr *pRoot, /* Consider tokens with this root node */
120482: Fts3TokenAndCost *aTC, /* Array of expression tokens and costs */
120483: int nTC /* Number of entries in aTC[] */
120484: ){
120485: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
120486: int nDocSize = 0; /* Number of pages per doc loaded */
120487: int rc = SQLITE_OK; /* Return code */
120488: int ii; /* Iterator variable for various purposes */
120489: int nOvfl = 0; /* Total overflow pages used by doclists */
120490: int nToken = 0; /* Total number of tokens in cluster */
120491:
120492: int nMinEst = 0; /* The minimum count for any phrase so far. */
120493: int nLoad4 = 1; /* (Phrases that will be loaded)^4. */
120494:
120495: /* Tokens are never deferred for FTS tables created using the content=xxx
120496: ** option. The reason being that it is not guaranteed that the content
120497: ** table actually contains the same data as the index. To prevent this from
120498: ** causing any problems, the deferred token optimization is completely
120499: ** disabled for content=xxx tables. */
120500: if( pTab->zContentTbl ){
120501: return SQLITE_OK;
120502: }
120503:
120504: /* Count the tokens in this AND/NEAR cluster. If none of the doclists
120505: ** associated with the tokens spill onto overflow pages, or if there is
120506: ** only 1 token, exit early. No tokens to defer in this case. */
120507: for(ii=0; ii<nTC; ii++){
120508: if( aTC[ii].pRoot==pRoot ){
120509: nOvfl += aTC[ii].nOvfl;
120510: nToken++;
120511: }
120512: }
120513: if( nOvfl==0 || nToken<2 ) return SQLITE_OK;
120514:
120515: /* Obtain the average docsize (in pages). */
120516: rc = fts3EvalAverageDocsize(pCsr, &nDocSize);
120517: assert( rc!=SQLITE_OK || nDocSize>0 );
120518:
120519:
120520: /* Iterate through all tokens in this AND/NEAR cluster, in ascending order
120521: ** of the number of overflow pages that will be loaded by the pager layer
120522: ** to retrieve the entire doclist for the token from the full-text index.
120523: ** Load the doclists for tokens that are either:
120524: **
120525: ** a. The cheapest token in the entire query (i.e. the one visited by the
120526: ** first iteration of this loop), or
120527: **
120528: ** b. Part of a multi-token phrase.
120529: **
120530: ** After each token doclist is loaded, merge it with the others from the
120531: ** same phrase and count the number of documents that the merged doclist
120532: ** contains. Set variable "nMinEst" to the smallest number of documents in
120533: ** any phrase doclist for which 1 or more token doclists have been loaded.
120534: ** Let nOther be the number of other phrases for which it is certain that
120535: ** one or more tokens will not be deferred.
120536: **
120537: ** Then, for each token, defer it if loading the doclist would result in
120538: ** loading N or more overflow pages into memory, where N is computed as:
120539: **
120540: ** (nMinEst + 4^nOther - 1) / (4^nOther)
120541: */
120542: for(ii=0; ii<nToken && rc==SQLITE_OK; ii++){
120543: int iTC; /* Used to iterate through aTC[] array. */
120544: Fts3TokenAndCost *pTC = 0; /* Set to cheapest remaining token. */
120545:
120546: /* Set pTC to point to the cheapest remaining token. */
120547: for(iTC=0; iTC<nTC; iTC++){
120548: if( aTC[iTC].pToken && aTC[iTC].pRoot==pRoot
120549: && (!pTC || aTC[iTC].nOvfl<pTC->nOvfl)
120550: ){
120551: pTC = &aTC[iTC];
120552: }
120553: }
120554: assert( pTC );
120555:
120556: if( ii && pTC->nOvfl>=((nMinEst+(nLoad4/4)-1)/(nLoad4/4))*nDocSize ){
120557: /* The number of overflow pages to load for this (and therefore all
120558: ** subsequent) tokens is greater than the estimated number of pages
120559: ** that will be loaded if all subsequent tokens are deferred.
120560: */
120561: Fts3PhraseToken *pToken = pTC->pToken;
120562: rc = sqlite3Fts3DeferToken(pCsr, pToken, pTC->iCol);
120563: fts3SegReaderCursorFree(pToken->pSegcsr);
120564: pToken->pSegcsr = 0;
120565: }else{
120566: /* Set nLoad4 to the value of (4^nOther) for the next iteration of the
120567: ** for-loop. Except, limit the value to 2^24 to prevent it from
120568: ** overflowing the 32-bit integer it is stored in. */
120569: if( ii<12 ) nLoad4 = nLoad4*4;
120570:
120571: if( ii==0 || pTC->pPhrase->nToken>1 ){
120572: /* Either this is the cheapest token in the entire query, or it is
120573: ** part of a multi-token phrase. Either way, the entire doclist will
120574: ** (eventually) be loaded into memory. It may as well be now. */
120575: Fts3PhraseToken *pToken = pTC->pToken;
120576: int nList = 0;
120577: char *pList = 0;
120578: rc = fts3TermSelect(pTab, pToken, pTC->iCol, &nList, &pList);
120579: assert( rc==SQLITE_OK || pList==0 );
120580: if( rc==SQLITE_OK ){
120581: int nCount;
120582: fts3EvalPhraseMergeToken(pTab, pTC->pPhrase, pTC->iToken,pList,nList);
120583: nCount = fts3DoclistCountDocids(
120584: pTC->pPhrase->doclist.aAll, pTC->pPhrase->doclist.nAll
120585: );
120586: if( ii==0 || nCount<nMinEst ) nMinEst = nCount;
120587: }
120588: }
120589: }
120590: pTC->pToken = 0;
120591: }
120592:
120593: return rc;
120594: }
120595:
120596: /*
120597: ** This function is called from within the xFilter method. It initializes
120598: ** the full-text query currently stored in pCsr->pExpr. To iterate through
120599: ** the results of a query, the caller does:
120600: **
120601: ** fts3EvalStart(pCsr);
120602: ** while( 1 ){
120603: ** fts3EvalNext(pCsr);
120604: ** if( pCsr->bEof ) break;
120605: ** ... return row pCsr->iPrevId to the caller ...
120606: ** }
120607: */
120608: static int fts3EvalStart(Fts3Cursor *pCsr){
120609: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
120610: int rc = SQLITE_OK;
120611: int nToken = 0;
120612: int nOr = 0;
120613:
120614: /* Allocate a MultiSegReader for each token in the expression. */
120615: fts3EvalAllocateReaders(pCsr, pCsr->pExpr, &nToken, &nOr, &rc);
120616:
120617: /* Determine which, if any, tokens in the expression should be deferred. */
120618: if( rc==SQLITE_OK && nToken>1 && pTab->bHasStat ){
120619: Fts3TokenAndCost *aTC;
120620: Fts3Expr **apOr;
120621: aTC = (Fts3TokenAndCost *)sqlite3_malloc(
120622: sizeof(Fts3TokenAndCost) * nToken
120623: + sizeof(Fts3Expr *) * nOr * 2
120624: );
120625: apOr = (Fts3Expr **)&aTC[nToken];
120626:
120627: if( !aTC ){
120628: rc = SQLITE_NOMEM;
120629: }else{
120630: int ii;
120631: Fts3TokenAndCost *pTC = aTC;
120632: Fts3Expr **ppOr = apOr;
120633:
120634: fts3EvalTokenCosts(pCsr, 0, pCsr->pExpr, &pTC, &ppOr, &rc);
120635: nToken = pTC-aTC;
120636: nOr = ppOr-apOr;
120637:
120638: if( rc==SQLITE_OK ){
120639: rc = fts3EvalSelectDeferred(pCsr, 0, aTC, nToken);
120640: for(ii=0; rc==SQLITE_OK && ii<nOr; ii++){
120641: rc = fts3EvalSelectDeferred(pCsr, apOr[ii], aTC, nToken);
120642: }
120643: }
120644:
120645: sqlite3_free(aTC);
120646: }
120647: }
120648:
120649: fts3EvalStartReaders(pCsr, pCsr->pExpr, 1, &rc);
120650: return rc;
120651: }
120652:
120653: /*
120654: ** Invalidate the current position list for phrase pPhrase.
120655: */
120656: static void fts3EvalInvalidatePoslist(Fts3Phrase *pPhrase){
120657: if( pPhrase->doclist.bFreeList ){
120658: sqlite3_free(pPhrase->doclist.pList);
120659: }
120660: pPhrase->doclist.pList = 0;
120661: pPhrase->doclist.nList = 0;
120662: pPhrase->doclist.bFreeList = 0;
120663: }
120664:
120665: /*
120666: ** This function is called to edit the position list associated with
120667: ** the phrase object passed as the fifth argument according to a NEAR
120668: ** condition. For example:
120669: **
120670: ** abc NEAR/5 "def ghi"
120671: **
120672: ** Parameter nNear is passed the NEAR distance of the expression (5 in
120673: ** the example above). When this function is called, *paPoslist points to
120674: ** the position list, and *pnToken is the number of phrase tokens in, the
120675: ** phrase on the other side of the NEAR operator to pPhrase. For example,
120676: ** if pPhrase refers to the "def ghi" phrase, then *paPoslist points to
120677: ** the position list associated with phrase "abc".
120678: **
120679: ** All positions in the pPhrase position list that are not sufficiently
120680: ** close to a position in the *paPoslist position list are removed. If this
120681: ** leaves 0 positions, zero is returned. Otherwise, non-zero.
120682: **
120683: ** Before returning, *paPoslist is set to point to the position lsit
120684: ** associated with pPhrase. And *pnToken is set to the number of tokens in
120685: ** pPhrase.
120686: */
120687: static int fts3EvalNearTrim(
120688: int nNear, /* NEAR distance. As in "NEAR/nNear". */
120689: char *aTmp, /* Temporary space to use */
120690: char **paPoslist, /* IN/OUT: Position list */
120691: int *pnToken, /* IN/OUT: Tokens in phrase of *paPoslist */
120692: Fts3Phrase *pPhrase /* The phrase object to trim the doclist of */
120693: ){
120694: int nParam1 = nNear + pPhrase->nToken;
120695: int nParam2 = nNear + *pnToken;
120696: int nNew;
120697: char *p2;
120698: char *pOut;
120699: int res;
120700:
120701: assert( pPhrase->doclist.pList );
120702:
120703: p2 = pOut = pPhrase->doclist.pList;
120704: res = fts3PoslistNearMerge(
120705: &pOut, aTmp, nParam1, nParam2, paPoslist, &p2
120706: );
120707: if( res ){
120708: nNew = (pOut - pPhrase->doclist.pList) - 1;
120709: assert( pPhrase->doclist.pList[nNew]=='\0' );
120710: assert( nNew<=pPhrase->doclist.nList && nNew>0 );
120711: memset(&pPhrase->doclist.pList[nNew], 0, pPhrase->doclist.nList - nNew);
120712: pPhrase->doclist.nList = nNew;
120713: *paPoslist = pPhrase->doclist.pList;
120714: *pnToken = pPhrase->nToken;
120715: }
120716:
120717: return res;
120718: }
120719:
120720: /*
120721: ** This function is a no-op if *pRc is other than SQLITE_OK when it is called.
120722: ** Otherwise, it advances the expression passed as the second argument to
120723: ** point to the next matching row in the database. Expressions iterate through
120724: ** matching rows in docid order. Ascending order if Fts3Cursor.bDesc is zero,
120725: ** or descending if it is non-zero.
120726: **
120727: ** If an error occurs, *pRc is set to an SQLite error code. Otherwise, if
120728: ** successful, the following variables in pExpr are set:
120729: **
120730: ** Fts3Expr.bEof (non-zero if EOF - there is no next row)
120731: ** Fts3Expr.iDocid (valid if bEof==0. The docid of the next row)
120732: **
120733: ** If the expression is of type FTSQUERY_PHRASE, and the expression is not
120734: ** at EOF, then the following variables are populated with the position list
120735: ** for the phrase for the visited row:
120736: **
120737: ** FTs3Expr.pPhrase->doclist.nList (length of pList in bytes)
120738: ** FTs3Expr.pPhrase->doclist.pList (pointer to position list)
120739: **
120740: ** It says above that this function advances the expression to the next
120741: ** matching row. This is usually true, but there are the following exceptions:
120742: **
120743: ** 1. Deferred tokens are not taken into account. If a phrase consists
120744: ** entirely of deferred tokens, it is assumed to match every row in
120745: ** the db. In this case the position-list is not populated at all.
120746: **
120747: ** Or, if a phrase contains one or more deferred tokens and one or
120748: ** more non-deferred tokens, then the expression is advanced to the
120749: ** next possible match, considering only non-deferred tokens. In other
120750: ** words, if the phrase is "A B C", and "B" is deferred, the expression
120751: ** is advanced to the next row that contains an instance of "A * C",
120752: ** where "*" may match any single token. The position list in this case
120753: ** is populated as for "A * C" before returning.
120754: **
120755: ** 2. NEAR is treated as AND. If the expression is "x NEAR y", it is
120756: ** advanced to point to the next row that matches "x AND y".
120757: **
120758: ** See fts3EvalTestDeferredAndNear() for details on testing if a row is
120759: ** really a match, taking into account deferred tokens and NEAR operators.
120760: */
120761: static void fts3EvalNextRow(
120762: Fts3Cursor *pCsr, /* FTS Cursor handle */
120763: Fts3Expr *pExpr, /* Expr. to advance to next matching row */
120764: int *pRc /* IN/OUT: Error code */
120765: ){
120766: if( *pRc==SQLITE_OK ){
120767: int bDescDoclist = pCsr->bDesc; /* Used by DOCID_CMP() macro */
120768: assert( pExpr->bEof==0 );
120769: pExpr->bStart = 1;
120770:
120771: switch( pExpr->eType ){
120772: case FTSQUERY_NEAR:
120773: case FTSQUERY_AND: {
120774: Fts3Expr *pLeft = pExpr->pLeft;
120775: Fts3Expr *pRight = pExpr->pRight;
120776: assert( !pLeft->bDeferred || !pRight->bDeferred );
120777:
120778: if( pLeft->bDeferred ){
120779: /* LHS is entirely deferred. So we assume it matches every row.
120780: ** Advance the RHS iterator to find the next row visited. */
120781: fts3EvalNextRow(pCsr, pRight, pRc);
120782: pExpr->iDocid = pRight->iDocid;
120783: pExpr->bEof = pRight->bEof;
120784: }else if( pRight->bDeferred ){
120785: /* RHS is entirely deferred. So we assume it matches every row.
120786: ** Advance the LHS iterator to find the next row visited. */
120787: fts3EvalNextRow(pCsr, pLeft, pRc);
120788: pExpr->iDocid = pLeft->iDocid;
120789: pExpr->bEof = pLeft->bEof;
120790: }else{
120791: /* Neither the RHS or LHS are deferred. */
120792: fts3EvalNextRow(pCsr, pLeft, pRc);
120793: fts3EvalNextRow(pCsr, pRight, pRc);
120794: while( !pLeft->bEof && !pRight->bEof && *pRc==SQLITE_OK ){
120795: sqlite3_int64 iDiff = DOCID_CMP(pLeft->iDocid, pRight->iDocid);
120796: if( iDiff==0 ) break;
120797: if( iDiff<0 ){
120798: fts3EvalNextRow(pCsr, pLeft, pRc);
120799: }else{
120800: fts3EvalNextRow(pCsr, pRight, pRc);
120801: }
120802: }
120803: pExpr->iDocid = pLeft->iDocid;
120804: pExpr->bEof = (pLeft->bEof || pRight->bEof);
120805: }
120806: break;
120807: }
120808:
120809: case FTSQUERY_OR: {
120810: Fts3Expr *pLeft = pExpr->pLeft;
120811: Fts3Expr *pRight = pExpr->pRight;
120812: sqlite3_int64 iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid);
120813:
120814: assert( pLeft->bStart || pLeft->iDocid==pRight->iDocid );
120815: assert( pRight->bStart || pLeft->iDocid==pRight->iDocid );
120816:
120817: if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){
120818: fts3EvalNextRow(pCsr, pLeft, pRc);
120819: }else if( pLeft->bEof || (pRight->bEof==0 && iCmp>0) ){
120820: fts3EvalNextRow(pCsr, pRight, pRc);
120821: }else{
120822: fts3EvalNextRow(pCsr, pLeft, pRc);
120823: fts3EvalNextRow(pCsr, pRight, pRc);
120824: }
120825:
120826: pExpr->bEof = (pLeft->bEof && pRight->bEof);
120827: iCmp = DOCID_CMP(pLeft->iDocid, pRight->iDocid);
120828: if( pRight->bEof || (pLeft->bEof==0 && iCmp<0) ){
120829: pExpr->iDocid = pLeft->iDocid;
120830: }else{
120831: pExpr->iDocid = pRight->iDocid;
120832: }
120833:
120834: break;
120835: }
120836:
120837: case FTSQUERY_NOT: {
120838: Fts3Expr *pLeft = pExpr->pLeft;
120839: Fts3Expr *pRight = pExpr->pRight;
120840:
120841: if( pRight->bStart==0 ){
120842: fts3EvalNextRow(pCsr, pRight, pRc);
120843: assert( *pRc!=SQLITE_OK || pRight->bStart );
120844: }
120845:
120846: fts3EvalNextRow(pCsr, pLeft, pRc);
120847: if( pLeft->bEof==0 ){
120848: while( !*pRc
120849: && !pRight->bEof
120850: && DOCID_CMP(pLeft->iDocid, pRight->iDocid)>0
120851: ){
120852: fts3EvalNextRow(pCsr, pRight, pRc);
120853: }
120854: }
120855: pExpr->iDocid = pLeft->iDocid;
120856: pExpr->bEof = pLeft->bEof;
120857: break;
120858: }
120859:
120860: default: {
120861: Fts3Phrase *pPhrase = pExpr->pPhrase;
120862: fts3EvalInvalidatePoslist(pPhrase);
120863: *pRc = fts3EvalPhraseNext(pCsr, pPhrase, &pExpr->bEof);
120864: pExpr->iDocid = pPhrase->doclist.iDocid;
120865: break;
120866: }
120867: }
120868: }
120869: }
120870:
120871: /*
120872: ** If *pRc is not SQLITE_OK, or if pExpr is not the root node of a NEAR
120873: ** cluster, then this function returns 1 immediately.
120874: **
120875: ** Otherwise, it checks if the current row really does match the NEAR
120876: ** expression, using the data currently stored in the position lists
120877: ** (Fts3Expr->pPhrase.doclist.pList/nList) for each phrase in the expression.
120878: **
120879: ** If the current row is a match, the position list associated with each
120880: ** phrase in the NEAR expression is edited in place to contain only those
120881: ** phrase instances sufficiently close to their peers to satisfy all NEAR
120882: ** constraints. In this case it returns 1. If the NEAR expression does not
120883: ** match the current row, 0 is returned. The position lists may or may not
120884: ** be edited if 0 is returned.
120885: */
120886: static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
120887: int res = 1;
120888:
120889: /* The following block runs if pExpr is the root of a NEAR query.
120890: ** For example, the query:
120891: **
120892: ** "w" NEAR "x" NEAR "y" NEAR "z"
120893: **
120894: ** which is represented in tree form as:
120895: **
120896: ** |
120897: ** +--NEAR--+ <-- root of NEAR query
120898: ** | |
120899: ** +--NEAR--+ "z"
120900: ** | |
120901: ** +--NEAR--+ "y"
120902: ** | |
120903: ** "w" "x"
120904: **
120905: ** The right-hand child of a NEAR node is always a phrase. The
120906: ** left-hand child may be either a phrase or a NEAR node. There are
120907: ** no exceptions to this - it's the way the parser in fts3_expr.c works.
120908: */
120909: if( *pRc==SQLITE_OK
120910: && pExpr->eType==FTSQUERY_NEAR
120911: && pExpr->bEof==0
120912: && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
120913: ){
120914: Fts3Expr *p;
120915: int nTmp = 0; /* Bytes of temp space */
120916: char *aTmp; /* Temp space for PoslistNearMerge() */
120917:
120918: /* Allocate temporary working space. */
120919: for(p=pExpr; p->pLeft; p=p->pLeft){
120920: nTmp += p->pRight->pPhrase->doclist.nList;
120921: }
120922: nTmp += p->pPhrase->doclist.nList;
120923: aTmp = sqlite3_malloc(nTmp*2);
120924: if( !aTmp ){
120925: *pRc = SQLITE_NOMEM;
120926: res = 0;
120927: }else{
120928: char *aPoslist = p->pPhrase->doclist.pList;
120929: int nToken = p->pPhrase->nToken;
120930:
120931: for(p=p->pParent;res && p && p->eType==FTSQUERY_NEAR; p=p->pParent){
120932: Fts3Phrase *pPhrase = p->pRight->pPhrase;
120933: int nNear = p->nNear;
120934: res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase);
120935: }
120936:
120937: aPoslist = pExpr->pRight->pPhrase->doclist.pList;
120938: nToken = pExpr->pRight->pPhrase->nToken;
120939: for(p=pExpr->pLeft; p && res; p=p->pLeft){
120940: int nNear;
120941: Fts3Phrase *pPhrase;
120942: assert( p->pParent && p->pParent->pLeft==p );
120943: nNear = p->pParent->nNear;
120944: pPhrase = (
120945: p->eType==FTSQUERY_NEAR ? p->pRight->pPhrase : p->pPhrase
120946: );
120947: res = fts3EvalNearTrim(nNear, aTmp, &aPoslist, &nToken, pPhrase);
120948: }
120949: }
120950:
120951: sqlite3_free(aTmp);
120952: }
120953:
120954: return res;
120955: }
120956:
120957: /*
120958: ** This function is a helper function for fts3EvalTestDeferredAndNear().
120959: ** Assuming no error occurs or has occurred, It returns non-zero if the
120960: ** expression passed as the second argument matches the row that pCsr
120961: ** currently points to, or zero if it does not.
120962: **
120963: ** If *pRc is not SQLITE_OK when this function is called, it is a no-op.
120964: ** If an error occurs during execution of this function, *pRc is set to
120965: ** the appropriate SQLite error code. In this case the returned value is
120966: ** undefined.
120967: */
120968: static int fts3EvalTestExpr(
120969: Fts3Cursor *pCsr, /* FTS cursor handle */
120970: Fts3Expr *pExpr, /* Expr to test. May or may not be root. */
120971: int *pRc /* IN/OUT: Error code */
120972: ){
120973: int bHit = 1; /* Return value */
120974: if( *pRc==SQLITE_OK ){
120975: switch( pExpr->eType ){
120976: case FTSQUERY_NEAR:
120977: case FTSQUERY_AND:
120978: bHit = (
120979: fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
120980: && fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
120981: && fts3EvalNearTest(pExpr, pRc)
120982: );
120983:
120984: /* If the NEAR expression does not match any rows, zero the doclist for
120985: ** all phrases involved in the NEAR. This is because the snippet(),
120986: ** offsets() and matchinfo() functions are not supposed to recognize
120987: ** any instances of phrases that are part of unmatched NEAR queries.
120988: ** For example if this expression:
120989: **
120990: ** ... MATCH 'a OR (b NEAR c)'
120991: **
120992: ** is matched against a row containing:
120993: **
120994: ** 'a b d e'
120995: **
120996: ** then any snippet() should ony highlight the "a" term, not the "b"
120997: ** (as "b" is part of a non-matching NEAR clause).
120998: */
120999: if( bHit==0
121000: && pExpr->eType==FTSQUERY_NEAR
121001: && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
121002: ){
121003: Fts3Expr *p;
121004: for(p=pExpr; p->pPhrase==0; p=p->pLeft){
121005: if( p->pRight->iDocid==pCsr->iPrevId ){
121006: fts3EvalInvalidatePoslist(p->pRight->pPhrase);
121007: }
121008: }
121009: if( p->iDocid==pCsr->iPrevId ){
121010: fts3EvalInvalidatePoslist(p->pPhrase);
121011: }
121012: }
121013:
121014: break;
121015:
121016: case FTSQUERY_OR: {
121017: int bHit1 = fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc);
121018: int bHit2 = fts3EvalTestExpr(pCsr, pExpr->pRight, pRc);
121019: bHit = bHit1 || bHit2;
121020: break;
121021: }
121022:
121023: case FTSQUERY_NOT:
121024: bHit = (
121025: fts3EvalTestExpr(pCsr, pExpr->pLeft, pRc)
121026: && !fts3EvalTestExpr(pCsr, pExpr->pRight, pRc)
121027: );
121028: break;
121029:
121030: default: {
121031: if( pCsr->pDeferred
121032: && (pExpr->iDocid==pCsr->iPrevId || pExpr->bDeferred)
121033: ){
121034: Fts3Phrase *pPhrase = pExpr->pPhrase;
121035: assert( pExpr->bDeferred || pPhrase->doclist.bFreeList==0 );
121036: if( pExpr->bDeferred ){
121037: fts3EvalInvalidatePoslist(pPhrase);
121038: }
121039: *pRc = fts3EvalDeferredPhrase(pCsr, pPhrase);
121040: bHit = (pPhrase->doclist.pList!=0);
121041: pExpr->iDocid = pCsr->iPrevId;
121042: }else{
121043: bHit = (pExpr->bEof==0 && pExpr->iDocid==pCsr->iPrevId);
121044: }
121045: break;
121046: }
121047: }
121048: }
121049: return bHit;
121050: }
121051:
121052: /*
121053: ** This function is called as the second part of each xNext operation when
121054: ** iterating through the results of a full-text query. At this point the
121055: ** cursor points to a row that matches the query expression, with the
121056: ** following caveats:
121057: **
121058: ** * Up until this point, "NEAR" operators in the expression have been
121059: ** treated as "AND".
121060: **
121061: ** * Deferred tokens have not yet been considered.
121062: **
121063: ** If *pRc is not SQLITE_OK when this function is called, it immediately
121064: ** returns 0. Otherwise, it tests whether or not after considering NEAR
121065: ** operators and deferred tokens the current row is still a match for the
121066: ** expression. It returns 1 if both of the following are true:
121067: **
121068: ** 1. *pRc is SQLITE_OK when this function returns, and
121069: **
121070: ** 2. After scanning the current FTS table row for the deferred tokens,
121071: ** it is determined that the row does *not* match the query.
121072: **
121073: ** Or, if no error occurs and it seems the current row does match the FTS
121074: ** query, return 0.
121075: */
121076: static int fts3EvalTestDeferredAndNear(Fts3Cursor *pCsr, int *pRc){
121077: int rc = *pRc;
121078: int bMiss = 0;
121079: if( rc==SQLITE_OK ){
121080:
121081: /* If there are one or more deferred tokens, load the current row into
121082: ** memory and scan it to determine the position list for each deferred
121083: ** token. Then, see if this row is really a match, considering deferred
121084: ** tokens and NEAR operators (neither of which were taken into account
121085: ** earlier, by fts3EvalNextRow()).
121086: */
121087: if( pCsr->pDeferred ){
121088: rc = fts3CursorSeek(0, pCsr);
121089: if( rc==SQLITE_OK ){
121090: rc = sqlite3Fts3CacheDeferredDoclists(pCsr);
121091: }
121092: }
121093: bMiss = (0==fts3EvalTestExpr(pCsr, pCsr->pExpr, &rc));
121094:
121095: /* Free the position-lists accumulated for each deferred token above. */
121096: sqlite3Fts3FreeDeferredDoclists(pCsr);
121097: *pRc = rc;
121098: }
121099: return (rc==SQLITE_OK && bMiss);
121100: }
121101:
121102: /*
121103: ** Advance to the next document that matches the FTS expression in
121104: ** Fts3Cursor.pExpr.
121105: */
121106: static int fts3EvalNext(Fts3Cursor *pCsr){
121107: int rc = SQLITE_OK; /* Return Code */
121108: Fts3Expr *pExpr = pCsr->pExpr;
121109: assert( pCsr->isEof==0 );
121110: if( pExpr==0 ){
121111: pCsr->isEof = 1;
121112: }else{
121113: do {
121114: if( pCsr->isRequireSeek==0 ){
121115: sqlite3_reset(pCsr->pStmt);
121116: }
121117: assert( sqlite3_data_count(pCsr->pStmt)==0 );
121118: fts3EvalNextRow(pCsr, pExpr, &rc);
121119: pCsr->isEof = pExpr->bEof;
121120: pCsr->isRequireSeek = 1;
121121: pCsr->isMatchinfoNeeded = 1;
121122: pCsr->iPrevId = pExpr->iDocid;
121123: }while( pCsr->isEof==0 && fts3EvalTestDeferredAndNear(pCsr, &rc) );
121124: }
121125: return rc;
121126: }
121127:
121128: /*
121129: ** Restart interation for expression pExpr so that the next call to
121130: ** fts3EvalNext() visits the first row. Do not allow incremental
121131: ** loading or merging of phrase doclists for this iteration.
121132: **
121133: ** If *pRc is other than SQLITE_OK when this function is called, it is
121134: ** a no-op. If an error occurs within this function, *pRc is set to an
121135: ** SQLite error code before returning.
121136: */
121137: static void fts3EvalRestart(
121138: Fts3Cursor *pCsr,
121139: Fts3Expr *pExpr,
121140: int *pRc
121141: ){
121142: if( pExpr && *pRc==SQLITE_OK ){
121143: Fts3Phrase *pPhrase = pExpr->pPhrase;
121144:
121145: if( pPhrase ){
121146: fts3EvalInvalidatePoslist(pPhrase);
121147: if( pPhrase->bIncr ){
121148: assert( pPhrase->nToken==1 );
121149: assert( pPhrase->aToken[0].pSegcsr );
121150: sqlite3Fts3MsrIncrRestart(pPhrase->aToken[0].pSegcsr);
121151: *pRc = fts3EvalPhraseStart(pCsr, 0, pPhrase);
121152: }
121153:
121154: pPhrase->doclist.pNextDocid = 0;
121155: pPhrase->doclist.iDocid = 0;
121156: }
121157:
121158: pExpr->iDocid = 0;
121159: pExpr->bEof = 0;
121160: pExpr->bStart = 0;
121161:
121162: fts3EvalRestart(pCsr, pExpr->pLeft, pRc);
121163: fts3EvalRestart(pCsr, pExpr->pRight, pRc);
121164: }
121165: }
121166:
121167: /*
121168: ** After allocating the Fts3Expr.aMI[] array for each phrase in the
121169: ** expression rooted at pExpr, the cursor iterates through all rows matched
121170: ** by pExpr, calling this function for each row. This function increments
121171: ** the values in Fts3Expr.aMI[] according to the position-list currently
121172: ** found in Fts3Expr.pPhrase->doclist.pList for each of the phrase
121173: ** expression nodes.
121174: */
121175: static void fts3EvalUpdateCounts(Fts3Expr *pExpr){
121176: if( pExpr ){
121177: Fts3Phrase *pPhrase = pExpr->pPhrase;
121178: if( pPhrase && pPhrase->doclist.pList ){
121179: int iCol = 0;
121180: char *p = pPhrase->doclist.pList;
121181:
121182: assert( *p );
121183: while( 1 ){
121184: u8 c = 0;
121185: int iCnt = 0;
121186: while( 0xFE & (*p | c) ){
121187: if( (c&0x80)==0 ) iCnt++;
121188: c = *p++ & 0x80;
121189: }
121190:
121191: /* aMI[iCol*3 + 1] = Number of occurrences
121192: ** aMI[iCol*3 + 2] = Number of rows containing at least one instance
121193: */
121194: pExpr->aMI[iCol*3 + 1] += iCnt;
121195: pExpr->aMI[iCol*3 + 2] += (iCnt>0);
121196: if( *p==0x00 ) break;
121197: p++;
121198: p += sqlite3Fts3GetVarint32(p, &iCol);
121199: }
121200: }
121201:
121202: fts3EvalUpdateCounts(pExpr->pLeft);
121203: fts3EvalUpdateCounts(pExpr->pRight);
121204: }
121205: }
121206:
121207: /*
121208: ** Expression pExpr must be of type FTSQUERY_PHRASE.
121209: **
121210: ** If it is not already allocated and populated, this function allocates and
121211: ** populates the Fts3Expr.aMI[] array for expression pExpr. If pExpr is part
121212: ** of a NEAR expression, then it also allocates and populates the same array
121213: ** for all other phrases that are part of the NEAR expression.
121214: **
121215: ** SQLITE_OK is returned if the aMI[] array is successfully allocated and
121216: ** populated. Otherwise, if an error occurs, an SQLite error code is returned.
121217: */
121218: static int fts3EvalGatherStats(
121219: Fts3Cursor *pCsr, /* Cursor object */
121220: Fts3Expr *pExpr /* FTSQUERY_PHRASE expression */
121221: ){
121222: int rc = SQLITE_OK; /* Return code */
121223:
121224: assert( pExpr->eType==FTSQUERY_PHRASE );
121225: if( pExpr->aMI==0 ){
121226: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
121227: Fts3Expr *pRoot; /* Root of NEAR expression */
121228: Fts3Expr *p; /* Iterator used for several purposes */
121229:
121230: sqlite3_int64 iPrevId = pCsr->iPrevId;
121231: sqlite3_int64 iDocid;
121232: u8 bEof;
121233:
121234: /* Find the root of the NEAR expression */
121235: pRoot = pExpr;
121236: while( pRoot->pParent && pRoot->pParent->eType==FTSQUERY_NEAR ){
121237: pRoot = pRoot->pParent;
121238: }
121239: iDocid = pRoot->iDocid;
121240: bEof = pRoot->bEof;
121241: assert( pRoot->bStart );
121242:
121243: /* Allocate space for the aMSI[] array of each FTSQUERY_PHRASE node */
121244: for(p=pRoot; p; p=p->pLeft){
121245: Fts3Expr *pE = (p->eType==FTSQUERY_PHRASE?p:p->pRight);
121246: assert( pE->aMI==0 );
121247: pE->aMI = (u32 *)sqlite3_malloc(pTab->nColumn * 3 * sizeof(u32));
121248: if( !pE->aMI ) return SQLITE_NOMEM;
121249: memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
121250: }
121251:
121252: fts3EvalRestart(pCsr, pRoot, &rc);
121253:
121254: while( pCsr->isEof==0 && rc==SQLITE_OK ){
121255:
121256: do {
121257: /* Ensure the %_content statement is reset. */
121258: if( pCsr->isRequireSeek==0 ) sqlite3_reset(pCsr->pStmt);
121259: assert( sqlite3_data_count(pCsr->pStmt)==0 );
121260:
121261: /* Advance to the next document */
121262: fts3EvalNextRow(pCsr, pRoot, &rc);
121263: pCsr->isEof = pRoot->bEof;
121264: pCsr->isRequireSeek = 1;
121265: pCsr->isMatchinfoNeeded = 1;
121266: pCsr->iPrevId = pRoot->iDocid;
121267: }while( pCsr->isEof==0
121268: && pRoot->eType==FTSQUERY_NEAR
121269: && fts3EvalTestDeferredAndNear(pCsr, &rc)
121270: );
121271:
121272: if( rc==SQLITE_OK && pCsr->isEof==0 ){
121273: fts3EvalUpdateCounts(pRoot);
121274: }
121275: }
121276:
121277: pCsr->isEof = 0;
121278: pCsr->iPrevId = iPrevId;
121279:
121280: if( bEof ){
121281: pRoot->bEof = bEof;
121282: }else{
121283: /* Caution: pRoot may iterate through docids in ascending or descending
121284: ** order. For this reason, even though it seems more defensive, the
121285: ** do loop can not be written:
121286: **
121287: ** do {...} while( pRoot->iDocid<iDocid && rc==SQLITE_OK );
121288: */
121289: fts3EvalRestart(pCsr, pRoot, &rc);
121290: do {
121291: fts3EvalNextRow(pCsr, pRoot, &rc);
121292: assert( pRoot->bEof==0 );
121293: }while( pRoot->iDocid!=iDocid && rc==SQLITE_OK );
121294: fts3EvalTestDeferredAndNear(pCsr, &rc);
121295: }
121296: }
121297: return rc;
121298: }
121299:
121300: /*
121301: ** This function is used by the matchinfo() module to query a phrase
121302: ** expression node for the following information:
121303: **
121304: ** 1. The total number of occurrences of the phrase in each column of
121305: ** the FTS table (considering all rows), and
121306: **
121307: ** 2. For each column, the number of rows in the table for which the
121308: ** column contains at least one instance of the phrase.
121309: **
121310: ** If no error occurs, SQLITE_OK is returned and the values for each column
121311: ** written into the array aiOut as follows:
121312: **
121313: ** aiOut[iCol*3 + 1] = Number of occurrences
121314: ** aiOut[iCol*3 + 2] = Number of rows containing at least one instance
121315: **
121316: ** Caveats:
121317: **
121318: ** * If a phrase consists entirely of deferred tokens, then all output
121319: ** values are set to the number of documents in the table. In other
121320: ** words we assume that very common tokens occur exactly once in each
121321: ** column of each row of the table.
121322: **
121323: ** * If a phrase contains some deferred tokens (and some non-deferred
121324: ** tokens), count the potential occurrence identified by considering
121325: ** the non-deferred tokens instead of actual phrase occurrences.
121326: **
121327: ** * If the phrase is part of a NEAR expression, then only phrase instances
121328: ** that meet the NEAR constraint are included in the counts.
121329: */
121330: SQLITE_PRIVATE int sqlite3Fts3EvalPhraseStats(
121331: Fts3Cursor *pCsr, /* FTS cursor handle */
121332: Fts3Expr *pExpr, /* Phrase expression */
121333: u32 *aiOut /* Array to write results into (see above) */
121334: ){
121335: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
121336: int rc = SQLITE_OK;
121337: int iCol;
121338:
121339: if( pExpr->bDeferred && pExpr->pParent->eType!=FTSQUERY_NEAR ){
121340: assert( pCsr->nDoc>0 );
121341: for(iCol=0; iCol<pTab->nColumn; iCol++){
121342: aiOut[iCol*3 + 1] = (u32)pCsr->nDoc;
121343: aiOut[iCol*3 + 2] = (u32)pCsr->nDoc;
121344: }
121345: }else{
121346: rc = fts3EvalGatherStats(pCsr, pExpr);
121347: if( rc==SQLITE_OK ){
121348: assert( pExpr->aMI );
121349: for(iCol=0; iCol<pTab->nColumn; iCol++){
121350: aiOut[iCol*3 + 1] = pExpr->aMI[iCol*3 + 1];
121351: aiOut[iCol*3 + 2] = pExpr->aMI[iCol*3 + 2];
121352: }
121353: }
121354: }
121355:
121356: return rc;
121357: }
121358:
121359: /*
121360: ** The expression pExpr passed as the second argument to this function
121361: ** must be of type FTSQUERY_PHRASE.
121362: **
121363: ** The returned value is either NULL or a pointer to a buffer containing
121364: ** a position-list indicating the occurrences of the phrase in column iCol
121365: ** of the current row.
121366: **
121367: ** More specifically, the returned buffer contains 1 varint for each
121368: ** occurence of the phrase in the column, stored using the normal (delta+2)
121369: ** compression and is terminated by either an 0x01 or 0x00 byte. For example,
121370: ** if the requested column contains "a b X c d X X" and the position-list
121371: ** for 'X' is requested, the buffer returned may contain:
121372: **
121373: ** 0x04 0x05 0x03 0x01 or 0x04 0x05 0x03 0x00
121374: **
121375: ** This function works regardless of whether or not the phrase is deferred,
121376: ** incremental, or neither.
121377: */
121378: SQLITE_PRIVATE char *sqlite3Fts3EvalPhrasePoslist(
121379: Fts3Cursor *pCsr, /* FTS3 cursor object */
121380: Fts3Expr *pExpr, /* Phrase to return doclist for */
121381: int iCol /* Column to return position list for */
121382: ){
121383: Fts3Phrase *pPhrase = pExpr->pPhrase;
121384: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
121385: char *pIter = pPhrase->doclist.pList;
121386: int iThis;
121387:
121388: assert( iCol>=0 && iCol<pTab->nColumn );
121389: if( !pIter
121390: || pExpr->bEof
121391: || pExpr->iDocid!=pCsr->iPrevId
121392: || (pPhrase->iColumn<pTab->nColumn && pPhrase->iColumn!=iCol)
121393: ){
121394: return 0;
121395: }
121396:
121397: assert( pPhrase->doclist.nList>0 );
121398: if( *pIter==0x01 ){
121399: pIter++;
121400: pIter += sqlite3Fts3GetVarint32(pIter, &iThis);
121401: }else{
121402: iThis = 0;
121403: }
121404: while( iThis<iCol ){
121405: fts3ColumnlistCopy(0, &pIter);
121406: if( *pIter==0x00 ) return 0;
121407: pIter++;
121408: pIter += sqlite3Fts3GetVarint32(pIter, &iThis);
121409: }
121410:
121411: return ((iCol==iThis)?pIter:0);
121412: }
121413:
121414: /*
121415: ** Free all components of the Fts3Phrase structure that were allocated by
121416: ** the eval module. Specifically, this means to free:
121417: **
121418: ** * the contents of pPhrase->doclist, and
121419: ** * any Fts3MultiSegReader objects held by phrase tokens.
121420: */
121421: SQLITE_PRIVATE void sqlite3Fts3EvalPhraseCleanup(Fts3Phrase *pPhrase){
121422: if( pPhrase ){
121423: int i;
121424: sqlite3_free(pPhrase->doclist.aAll);
121425: fts3EvalInvalidatePoslist(pPhrase);
121426: memset(&pPhrase->doclist, 0, sizeof(Fts3Doclist));
121427: for(i=0; i<pPhrase->nToken; i++){
121428: fts3SegReaderCursorFree(pPhrase->aToken[i].pSegcsr);
121429: pPhrase->aToken[i].pSegcsr = 0;
121430: }
121431: }
121432: }
121433:
121434: /*
121435: ** Return SQLITE_CORRUPT_VTAB.
121436: */
121437: #ifdef SQLITE_DEBUG
121438: SQLITE_PRIVATE int sqlite3Fts3Corrupt(){
121439: return SQLITE_CORRUPT_VTAB;
121440: }
121441: #endif
121442:
121443: #if !SQLITE_CORE
121444: /*
121445: ** Initialize API pointer table, if required.
121446: */
121447: SQLITE_API int sqlite3_extension_init(
121448: sqlite3 *db,
121449: char **pzErrMsg,
121450: const sqlite3_api_routines *pApi
121451: ){
121452: SQLITE_EXTENSION_INIT2(pApi)
121453: return sqlite3Fts3Init(db);
121454: }
121455: #endif
121456:
121457: #endif
121458:
121459: /************** End of fts3.c ************************************************/
121460: /************** Begin file fts3_aux.c ****************************************/
121461: /*
121462: ** 2011 Jan 27
121463: **
121464: ** The author disclaims copyright to this source code. In place of
121465: ** a legal notice, here is a blessing:
121466: **
121467: ** May you do good and not evil.
121468: ** May you find forgiveness for yourself and forgive others.
121469: ** May you share freely, never taking more than you give.
121470: **
121471: ******************************************************************************
121472: **
121473: */
121474: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
121475:
121476: /* #include <string.h> */
121477: /* #include <assert.h> */
121478:
121479: typedef struct Fts3auxTable Fts3auxTable;
121480: typedef struct Fts3auxCursor Fts3auxCursor;
121481:
121482: struct Fts3auxTable {
121483: sqlite3_vtab base; /* Base class used by SQLite core */
121484: Fts3Table *pFts3Tab;
121485: };
121486:
121487: struct Fts3auxCursor {
121488: sqlite3_vtab_cursor base; /* Base class used by SQLite core */
121489: Fts3MultiSegReader csr; /* Must be right after "base" */
121490: Fts3SegFilter filter;
121491: char *zStop;
121492: int nStop; /* Byte-length of string zStop */
121493: int isEof; /* True if cursor is at EOF */
121494: sqlite3_int64 iRowid; /* Current rowid */
121495:
121496: int iCol; /* Current value of 'col' column */
121497: int nStat; /* Size of aStat[] array */
121498: struct Fts3auxColstats {
121499: sqlite3_int64 nDoc; /* 'documents' values for current csr row */
121500: sqlite3_int64 nOcc; /* 'occurrences' values for current csr row */
121501: } *aStat;
121502: };
121503:
121504: /*
121505: ** Schema of the terms table.
121506: */
121507: #define FTS3_TERMS_SCHEMA "CREATE TABLE x(term, col, documents, occurrences)"
121508:
121509: /*
121510: ** This function does all the work for both the xConnect and xCreate methods.
121511: ** These tables have no persistent representation of their own, so xConnect
121512: ** and xCreate are identical operations.
121513: */
121514: static int fts3auxConnectMethod(
121515: sqlite3 *db, /* Database connection */
121516: void *pUnused, /* Unused */
121517: int argc, /* Number of elements in argv array */
121518: const char * const *argv, /* xCreate/xConnect argument array */
121519: sqlite3_vtab **ppVtab, /* OUT: New sqlite3_vtab object */
121520: char **pzErr /* OUT: sqlite3_malloc'd error message */
121521: ){
121522: char const *zDb; /* Name of database (e.g. "main") */
121523: char const *zFts3; /* Name of fts3 table */
121524: int nDb; /* Result of strlen(zDb) */
121525: int nFts3; /* Result of strlen(zFts3) */
121526: int nByte; /* Bytes of space to allocate here */
121527: int rc; /* value returned by declare_vtab() */
121528: Fts3auxTable *p; /* Virtual table object to return */
121529:
121530: UNUSED_PARAMETER(pUnused);
121531:
121532: /* The user should specify a single argument - the name of an fts3 table. */
121533: if( argc!=4 ){
121534: *pzErr = sqlite3_mprintf(
121535: "wrong number of arguments to fts4aux constructor"
121536: );
121537: return SQLITE_ERROR;
121538: }
121539:
121540: zDb = argv[1];
121541: nDb = strlen(zDb);
121542: zFts3 = argv[3];
121543: nFts3 = strlen(zFts3);
121544:
121545: rc = sqlite3_declare_vtab(db, FTS3_TERMS_SCHEMA);
121546: if( rc!=SQLITE_OK ) return rc;
121547:
121548: nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
121549: p = (Fts3auxTable *)sqlite3_malloc(nByte);
121550: if( !p ) return SQLITE_NOMEM;
121551: memset(p, 0, nByte);
121552:
121553: p->pFts3Tab = (Fts3Table *)&p[1];
121554: p->pFts3Tab->zDb = (char *)&p->pFts3Tab[1];
121555: p->pFts3Tab->zName = &p->pFts3Tab->zDb[nDb+1];
121556: p->pFts3Tab->db = db;
121557: p->pFts3Tab->nIndex = 1;
121558:
121559: memcpy((char *)p->pFts3Tab->zDb, zDb, nDb);
121560: memcpy((char *)p->pFts3Tab->zName, zFts3, nFts3);
121561: sqlite3Fts3Dequote((char *)p->pFts3Tab->zName);
121562:
121563: *ppVtab = (sqlite3_vtab *)p;
121564: return SQLITE_OK;
121565: }
121566:
121567: /*
121568: ** This function does the work for both the xDisconnect and xDestroy methods.
121569: ** These tables have no persistent representation of their own, so xDisconnect
121570: ** and xDestroy are identical operations.
121571: */
121572: static int fts3auxDisconnectMethod(sqlite3_vtab *pVtab){
121573: Fts3auxTable *p = (Fts3auxTable *)pVtab;
121574: Fts3Table *pFts3 = p->pFts3Tab;
121575: int i;
121576:
121577: /* Free any prepared statements held */
121578: for(i=0; i<SizeofArray(pFts3->aStmt); i++){
121579: sqlite3_finalize(pFts3->aStmt[i]);
121580: }
121581: sqlite3_free(pFts3->zSegmentsTbl);
121582: sqlite3_free(p);
121583: return SQLITE_OK;
121584: }
121585:
121586: #define FTS4AUX_EQ_CONSTRAINT 1
121587: #define FTS4AUX_GE_CONSTRAINT 2
121588: #define FTS4AUX_LE_CONSTRAINT 4
121589:
121590: /*
121591: ** xBestIndex - Analyze a WHERE and ORDER BY clause.
121592: */
121593: static int fts3auxBestIndexMethod(
121594: sqlite3_vtab *pVTab,
121595: sqlite3_index_info *pInfo
121596: ){
121597: int i;
121598: int iEq = -1;
121599: int iGe = -1;
121600: int iLe = -1;
121601:
121602: UNUSED_PARAMETER(pVTab);
121603:
121604: /* This vtab delivers always results in "ORDER BY term ASC" order. */
121605: if( pInfo->nOrderBy==1
121606: && pInfo->aOrderBy[0].iColumn==0
121607: && pInfo->aOrderBy[0].desc==0
121608: ){
121609: pInfo->orderByConsumed = 1;
121610: }
121611:
121612: /* Search for equality and range constraints on the "term" column. */
121613: for(i=0; i<pInfo->nConstraint; i++){
121614: if( pInfo->aConstraint[i].usable && pInfo->aConstraint[i].iColumn==0 ){
121615: int op = pInfo->aConstraint[i].op;
121616: if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iEq = i;
121617: if( op==SQLITE_INDEX_CONSTRAINT_LT ) iLe = i;
121618: if( op==SQLITE_INDEX_CONSTRAINT_LE ) iLe = i;
121619: if( op==SQLITE_INDEX_CONSTRAINT_GT ) iGe = i;
121620: if( op==SQLITE_INDEX_CONSTRAINT_GE ) iGe = i;
121621: }
121622: }
121623:
121624: if( iEq>=0 ){
121625: pInfo->idxNum = FTS4AUX_EQ_CONSTRAINT;
121626: pInfo->aConstraintUsage[iEq].argvIndex = 1;
121627: pInfo->estimatedCost = 5;
121628: }else{
121629: pInfo->idxNum = 0;
121630: pInfo->estimatedCost = 20000;
121631: if( iGe>=0 ){
121632: pInfo->idxNum += FTS4AUX_GE_CONSTRAINT;
121633: pInfo->aConstraintUsage[iGe].argvIndex = 1;
121634: pInfo->estimatedCost /= 2;
121635: }
121636: if( iLe>=0 ){
121637: pInfo->idxNum += FTS4AUX_LE_CONSTRAINT;
121638: pInfo->aConstraintUsage[iLe].argvIndex = 1 + (iGe>=0);
121639: pInfo->estimatedCost /= 2;
121640: }
121641: }
121642:
121643: return SQLITE_OK;
121644: }
121645:
121646: /*
121647: ** xOpen - Open a cursor.
121648: */
121649: static int fts3auxOpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){
121650: Fts3auxCursor *pCsr; /* Pointer to cursor object to return */
121651:
121652: UNUSED_PARAMETER(pVTab);
121653:
121654: pCsr = (Fts3auxCursor *)sqlite3_malloc(sizeof(Fts3auxCursor));
121655: if( !pCsr ) return SQLITE_NOMEM;
121656: memset(pCsr, 0, sizeof(Fts3auxCursor));
121657:
121658: *ppCsr = (sqlite3_vtab_cursor *)pCsr;
121659: return SQLITE_OK;
121660: }
121661:
121662: /*
121663: ** xClose - Close a cursor.
121664: */
121665: static int fts3auxCloseMethod(sqlite3_vtab_cursor *pCursor){
121666: Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab;
121667: Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121668:
121669: sqlite3Fts3SegmentsClose(pFts3);
121670: sqlite3Fts3SegReaderFinish(&pCsr->csr);
121671: sqlite3_free((void *)pCsr->filter.zTerm);
121672: sqlite3_free(pCsr->zStop);
121673: sqlite3_free(pCsr->aStat);
121674: sqlite3_free(pCsr);
121675: return SQLITE_OK;
121676: }
121677:
121678: static int fts3auxGrowStatArray(Fts3auxCursor *pCsr, int nSize){
121679: if( nSize>pCsr->nStat ){
121680: struct Fts3auxColstats *aNew;
121681: aNew = (struct Fts3auxColstats *)sqlite3_realloc(pCsr->aStat,
121682: sizeof(struct Fts3auxColstats) * nSize
121683: );
121684: if( aNew==0 ) return SQLITE_NOMEM;
121685: memset(&aNew[pCsr->nStat], 0,
121686: sizeof(struct Fts3auxColstats) * (nSize - pCsr->nStat)
121687: );
121688: pCsr->aStat = aNew;
121689: pCsr->nStat = nSize;
121690: }
121691: return SQLITE_OK;
121692: }
121693:
121694: /*
121695: ** xNext - Advance the cursor to the next row, if any.
121696: */
121697: static int fts3auxNextMethod(sqlite3_vtab_cursor *pCursor){
121698: Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121699: Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab;
121700: int rc;
121701:
121702: /* Increment our pretend rowid value. */
121703: pCsr->iRowid++;
121704:
121705: for(pCsr->iCol++; pCsr->iCol<pCsr->nStat; pCsr->iCol++){
121706: if( pCsr->aStat[pCsr->iCol].nDoc>0 ) return SQLITE_OK;
121707: }
121708:
121709: rc = sqlite3Fts3SegReaderStep(pFts3, &pCsr->csr);
121710: if( rc==SQLITE_ROW ){
121711: int i = 0;
121712: int nDoclist = pCsr->csr.nDoclist;
121713: char *aDoclist = pCsr->csr.aDoclist;
121714: int iCol;
121715:
121716: int eState = 0;
121717:
121718: if( pCsr->zStop ){
121719: int n = (pCsr->nStop<pCsr->csr.nTerm) ? pCsr->nStop : pCsr->csr.nTerm;
121720: int mc = memcmp(pCsr->zStop, pCsr->csr.zTerm, n);
121721: if( mc<0 || (mc==0 && pCsr->csr.nTerm>pCsr->nStop) ){
121722: pCsr->isEof = 1;
121723: return SQLITE_OK;
121724: }
121725: }
121726:
121727: if( fts3auxGrowStatArray(pCsr, 2) ) return SQLITE_NOMEM;
121728: memset(pCsr->aStat, 0, sizeof(struct Fts3auxColstats) * pCsr->nStat);
121729: iCol = 0;
121730:
121731: while( i<nDoclist ){
121732: sqlite3_int64 v = 0;
121733:
121734: i += sqlite3Fts3GetVarint(&aDoclist[i], &v);
121735: switch( eState ){
121736: /* State 0. In this state the integer just read was a docid. */
121737: case 0:
121738: pCsr->aStat[0].nDoc++;
121739: eState = 1;
121740: iCol = 0;
121741: break;
121742:
121743: /* State 1. In this state we are expecting either a 1, indicating
121744: ** that the following integer will be a column number, or the
121745: ** start of a position list for column 0.
121746: **
121747: ** The only difference between state 1 and state 2 is that if the
121748: ** integer encountered in state 1 is not 0 or 1, then we need to
121749: ** increment the column 0 "nDoc" count for this term.
121750: */
121751: case 1:
121752: assert( iCol==0 );
121753: if( v>1 ){
121754: pCsr->aStat[1].nDoc++;
121755: }
121756: eState = 2;
121757: /* fall through */
121758:
121759: case 2:
121760: if( v==0 ){ /* 0x00. Next integer will be a docid. */
121761: eState = 0;
121762: }else if( v==1 ){ /* 0x01. Next integer will be a column number. */
121763: eState = 3;
121764: }else{ /* 2 or greater. A position. */
121765: pCsr->aStat[iCol+1].nOcc++;
121766: pCsr->aStat[0].nOcc++;
121767: }
121768: break;
121769:
121770: /* State 3. The integer just read is a column number. */
121771: default: assert( eState==3 );
121772: iCol = (int)v;
121773: if( fts3auxGrowStatArray(pCsr, iCol+2) ) return SQLITE_NOMEM;
121774: pCsr->aStat[iCol+1].nDoc++;
121775: eState = 2;
121776: break;
121777: }
121778: }
121779:
121780: pCsr->iCol = 0;
121781: rc = SQLITE_OK;
121782: }else{
121783: pCsr->isEof = 1;
121784: }
121785: return rc;
121786: }
121787:
121788: /*
121789: ** xFilter - Initialize a cursor to point at the start of its data.
121790: */
121791: static int fts3auxFilterMethod(
121792: sqlite3_vtab_cursor *pCursor, /* The cursor used for this query */
121793: int idxNum, /* Strategy index */
121794: const char *idxStr, /* Unused */
121795: int nVal, /* Number of elements in apVal */
121796: sqlite3_value **apVal /* Arguments for the indexing scheme */
121797: ){
121798: Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121799: Fts3Table *pFts3 = ((Fts3auxTable *)pCursor->pVtab)->pFts3Tab;
121800: int rc;
121801: int isScan;
121802:
121803: UNUSED_PARAMETER(nVal);
121804: UNUSED_PARAMETER(idxStr);
121805:
121806: assert( idxStr==0 );
121807: assert( idxNum==FTS4AUX_EQ_CONSTRAINT || idxNum==0
121808: || idxNum==FTS4AUX_LE_CONSTRAINT || idxNum==FTS4AUX_GE_CONSTRAINT
121809: || idxNum==(FTS4AUX_LE_CONSTRAINT|FTS4AUX_GE_CONSTRAINT)
121810: );
121811: isScan = (idxNum!=FTS4AUX_EQ_CONSTRAINT);
121812:
121813: /* In case this cursor is being reused, close and zero it. */
121814: testcase(pCsr->filter.zTerm);
121815: sqlite3Fts3SegReaderFinish(&pCsr->csr);
121816: sqlite3_free((void *)pCsr->filter.zTerm);
121817: sqlite3_free(pCsr->aStat);
121818: memset(&pCsr->csr, 0, ((u8*)&pCsr[1]) - (u8*)&pCsr->csr);
121819:
121820: pCsr->filter.flags = FTS3_SEGMENT_REQUIRE_POS|FTS3_SEGMENT_IGNORE_EMPTY;
121821: if( isScan ) pCsr->filter.flags |= FTS3_SEGMENT_SCAN;
121822:
121823: if( idxNum&(FTS4AUX_EQ_CONSTRAINT|FTS4AUX_GE_CONSTRAINT) ){
121824: const unsigned char *zStr = sqlite3_value_text(apVal[0]);
121825: if( zStr ){
121826: pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr);
121827: pCsr->filter.nTerm = sqlite3_value_bytes(apVal[0]);
121828: if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM;
121829: }
121830: }
121831: if( idxNum&FTS4AUX_LE_CONSTRAINT ){
121832: int iIdx = (idxNum&FTS4AUX_GE_CONSTRAINT) ? 1 : 0;
121833: pCsr->zStop = sqlite3_mprintf("%s", sqlite3_value_text(apVal[iIdx]));
121834: pCsr->nStop = sqlite3_value_bytes(apVal[iIdx]);
121835: if( pCsr->zStop==0 ) return SQLITE_NOMEM;
121836: }
121837:
121838: rc = sqlite3Fts3SegReaderCursor(pFts3, 0, FTS3_SEGCURSOR_ALL,
121839: pCsr->filter.zTerm, pCsr->filter.nTerm, 0, isScan, &pCsr->csr
121840: );
121841: if( rc==SQLITE_OK ){
121842: rc = sqlite3Fts3SegReaderStart(pFts3, &pCsr->csr, &pCsr->filter);
121843: }
121844:
121845: if( rc==SQLITE_OK ) rc = fts3auxNextMethod(pCursor);
121846: return rc;
121847: }
121848:
121849: /*
121850: ** xEof - Return true if the cursor is at EOF, or false otherwise.
121851: */
121852: static int fts3auxEofMethod(sqlite3_vtab_cursor *pCursor){
121853: Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121854: return pCsr->isEof;
121855: }
121856:
121857: /*
121858: ** xColumn - Return a column value.
121859: */
121860: static int fts3auxColumnMethod(
121861: sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
121862: sqlite3_context *pContext, /* Context for sqlite3_result_xxx() calls */
121863: int iCol /* Index of column to read value from */
121864: ){
121865: Fts3auxCursor *p = (Fts3auxCursor *)pCursor;
121866:
121867: assert( p->isEof==0 );
121868: if( iCol==0 ){ /* Column "term" */
121869: sqlite3_result_text(pContext, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT);
121870: }else if( iCol==1 ){ /* Column "col" */
121871: if( p->iCol ){
121872: sqlite3_result_int(pContext, p->iCol-1);
121873: }else{
121874: sqlite3_result_text(pContext, "*", -1, SQLITE_STATIC);
121875: }
121876: }else if( iCol==2 ){ /* Column "documents" */
121877: sqlite3_result_int64(pContext, p->aStat[p->iCol].nDoc);
121878: }else{ /* Column "occurrences" */
121879: sqlite3_result_int64(pContext, p->aStat[p->iCol].nOcc);
121880: }
121881:
121882: return SQLITE_OK;
121883: }
121884:
121885: /*
121886: ** xRowid - Return the current rowid for the cursor.
121887: */
121888: static int fts3auxRowidMethod(
121889: sqlite3_vtab_cursor *pCursor, /* Cursor to retrieve value from */
121890: sqlite_int64 *pRowid /* OUT: Rowid value */
121891: ){
121892: Fts3auxCursor *pCsr = (Fts3auxCursor *)pCursor;
121893: *pRowid = pCsr->iRowid;
121894: return SQLITE_OK;
121895: }
121896:
121897: /*
121898: ** Register the fts3aux module with database connection db. Return SQLITE_OK
121899: ** if successful or an error code if sqlite3_create_module() fails.
121900: */
121901: SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db){
121902: static const sqlite3_module fts3aux_module = {
121903: 0, /* iVersion */
121904: fts3auxConnectMethod, /* xCreate */
121905: fts3auxConnectMethod, /* xConnect */
121906: fts3auxBestIndexMethod, /* xBestIndex */
121907: fts3auxDisconnectMethod, /* xDisconnect */
121908: fts3auxDisconnectMethod, /* xDestroy */
121909: fts3auxOpenMethod, /* xOpen */
121910: fts3auxCloseMethod, /* xClose */
121911: fts3auxFilterMethod, /* xFilter */
121912: fts3auxNextMethod, /* xNext */
121913: fts3auxEofMethod, /* xEof */
121914: fts3auxColumnMethod, /* xColumn */
121915: fts3auxRowidMethod, /* xRowid */
121916: 0, /* xUpdate */
121917: 0, /* xBegin */
121918: 0, /* xSync */
121919: 0, /* xCommit */
121920: 0, /* xRollback */
121921: 0, /* xFindFunction */
121922: 0, /* xRename */
121923: 0, /* xSavepoint */
121924: 0, /* xRelease */
121925: 0 /* xRollbackTo */
121926: };
121927: int rc; /* Return code */
121928:
121929: rc = sqlite3_create_module(db, "fts4aux", &fts3aux_module, 0);
121930: return rc;
121931: }
121932:
121933: #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
121934:
121935: /************** End of fts3_aux.c ********************************************/
121936: /************** Begin file fts3_expr.c ***************************************/
121937: /*
121938: ** 2008 Nov 28
121939: **
121940: ** The author disclaims copyright to this source code. In place of
121941: ** a legal notice, here is a blessing:
121942: **
121943: ** May you do good and not evil.
121944: ** May you find forgiveness for yourself and forgive others.
121945: ** May you share freely, never taking more than you give.
121946: **
121947: ******************************************************************************
121948: **
121949: ** This module contains code that implements a parser for fts3 query strings
121950: ** (the right-hand argument to the MATCH operator). Because the supported
121951: ** syntax is relatively simple, the whole tokenizer/parser system is
121952: ** hand-coded.
121953: */
121954: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
121955:
121956: /*
121957: ** By default, this module parses the legacy syntax that has been
121958: ** traditionally used by fts3. Or, if SQLITE_ENABLE_FTS3_PARENTHESIS
121959: ** is defined, then it uses the new syntax. The differences between
121960: ** the new and the old syntaxes are:
121961: **
121962: ** a) The new syntax supports parenthesis. The old does not.
121963: **
121964: ** b) The new syntax supports the AND and NOT operators. The old does not.
121965: **
121966: ** c) The old syntax supports the "-" token qualifier. This is not
121967: ** supported by the new syntax (it is replaced by the NOT operator).
121968: **
121969: ** d) When using the old syntax, the OR operator has a greater precedence
121970: ** than an implicit AND. When using the new, both implicity and explicit
121971: ** AND operators have a higher precedence than OR.
121972: **
121973: ** If compiled with SQLITE_TEST defined, then this module exports the
121974: ** symbol "int sqlite3_fts3_enable_parentheses". Setting this variable
121975: ** to zero causes the module to use the old syntax. If it is set to
121976: ** non-zero the new syntax is activated. This is so both syntaxes can
121977: ** be tested using a single build of testfixture.
121978: **
121979: ** The following describes the syntax supported by the fts3 MATCH
121980: ** operator in a similar format to that used by the lemon parser
121981: ** generator. This module does not use actually lemon, it uses a
121982: ** custom parser.
121983: **
121984: ** query ::= andexpr (OR andexpr)*.
121985: **
121986: ** andexpr ::= notexpr (AND? notexpr)*.
121987: **
121988: ** notexpr ::= nearexpr (NOT nearexpr|-TOKEN)*.
121989: ** notexpr ::= LP query RP.
121990: **
121991: ** nearexpr ::= phrase (NEAR distance_opt nearexpr)*.
121992: **
121993: ** distance_opt ::= .
121994: ** distance_opt ::= / INTEGER.
121995: **
121996: ** phrase ::= TOKEN.
121997: ** phrase ::= COLUMN:TOKEN.
121998: ** phrase ::= "TOKEN TOKEN TOKEN...".
121999: */
122000:
122001: #ifdef SQLITE_TEST
122002: SQLITE_API int sqlite3_fts3_enable_parentheses = 0;
122003: #else
122004: # ifdef SQLITE_ENABLE_FTS3_PARENTHESIS
122005: # define sqlite3_fts3_enable_parentheses 1
122006: # else
122007: # define sqlite3_fts3_enable_parentheses 0
122008: # endif
122009: #endif
122010:
122011: /*
122012: ** Default span for NEAR operators.
122013: */
122014: #define SQLITE_FTS3_DEFAULT_NEAR_PARAM 10
122015:
122016: /* #include <string.h> */
122017: /* #include <assert.h> */
122018:
122019: /*
122020: ** isNot:
122021: ** This variable is used by function getNextNode(). When getNextNode() is
122022: ** called, it sets ParseContext.isNot to true if the 'next node' is a
122023: ** FTSQUERY_PHRASE with a unary "-" attached to it. i.e. "mysql" in the
122024: ** FTS3 query "sqlite -mysql". Otherwise, ParseContext.isNot is set to
122025: ** zero.
122026: */
122027: typedef struct ParseContext ParseContext;
122028: struct ParseContext {
122029: sqlite3_tokenizer *pTokenizer; /* Tokenizer module */
122030: const char **azCol; /* Array of column names for fts3 table */
122031: int bFts4; /* True to allow FTS4-only syntax */
122032: int nCol; /* Number of entries in azCol[] */
122033: int iDefaultCol; /* Default column to query */
122034: int isNot; /* True if getNextNode() sees a unary - */
122035: sqlite3_context *pCtx; /* Write error message here */
122036: int nNest; /* Number of nested brackets */
122037: };
122038:
122039: /*
122040: ** This function is equivalent to the standard isspace() function.
122041: **
122042: ** The standard isspace() can be awkward to use safely, because although it
122043: ** is defined to accept an argument of type int, its behaviour when passed
122044: ** an integer that falls outside of the range of the unsigned char type
122045: ** is undefined (and sometimes, "undefined" means segfault). This wrapper
122046: ** is defined to accept an argument of type char, and always returns 0 for
122047: ** any values that fall outside of the range of the unsigned char type (i.e.
122048: ** negative values).
122049: */
122050: static int fts3isspace(char c){
122051: return c==' ' || c=='\t' || c=='\n' || c=='\r' || c=='\v' || c=='\f';
122052: }
122053:
122054: /*
122055: ** Allocate nByte bytes of memory using sqlite3_malloc(). If successful,
122056: ** zero the memory before returning a pointer to it. If unsuccessful,
122057: ** return NULL.
122058: */
122059: static void *fts3MallocZero(int nByte){
122060: void *pRet = sqlite3_malloc(nByte);
122061: if( pRet ) memset(pRet, 0, nByte);
122062: return pRet;
122063: }
122064:
122065:
122066: /*
122067: ** Extract the next token from buffer z (length n) using the tokenizer
122068: ** and other information (column names etc.) in pParse. Create an Fts3Expr
122069: ** structure of type FTSQUERY_PHRASE containing a phrase consisting of this
122070: ** single token and set *ppExpr to point to it. If the end of the buffer is
122071: ** reached before a token is found, set *ppExpr to zero. It is the
122072: ** responsibility of the caller to eventually deallocate the allocated
122073: ** Fts3Expr structure (if any) by passing it to sqlite3_free().
122074: **
122075: ** Return SQLITE_OK if successful, or SQLITE_NOMEM if a memory allocation
122076: ** fails.
122077: */
122078: static int getNextToken(
122079: ParseContext *pParse, /* fts3 query parse context */
122080: int iCol, /* Value for Fts3Phrase.iColumn */
122081: const char *z, int n, /* Input string */
122082: Fts3Expr **ppExpr, /* OUT: expression */
122083: int *pnConsumed /* OUT: Number of bytes consumed */
122084: ){
122085: sqlite3_tokenizer *pTokenizer = pParse->pTokenizer;
122086: sqlite3_tokenizer_module const *pModule = pTokenizer->pModule;
122087: int rc;
122088: sqlite3_tokenizer_cursor *pCursor;
122089: Fts3Expr *pRet = 0;
122090: int nConsumed = 0;
122091:
122092: rc = pModule->xOpen(pTokenizer, z, n, &pCursor);
122093: if( rc==SQLITE_OK ){
122094: const char *zToken;
122095: int nToken, iStart, iEnd, iPosition;
122096: int nByte; /* total space to allocate */
122097:
122098: pCursor->pTokenizer = pTokenizer;
122099: rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition);
122100:
122101: if( rc==SQLITE_OK ){
122102: nByte = sizeof(Fts3Expr) + sizeof(Fts3Phrase) + nToken;
122103: pRet = (Fts3Expr *)fts3MallocZero(nByte);
122104: if( !pRet ){
122105: rc = SQLITE_NOMEM;
122106: }else{
122107: pRet->eType = FTSQUERY_PHRASE;
122108: pRet->pPhrase = (Fts3Phrase *)&pRet[1];
122109: pRet->pPhrase->nToken = 1;
122110: pRet->pPhrase->iColumn = iCol;
122111: pRet->pPhrase->aToken[0].n = nToken;
122112: pRet->pPhrase->aToken[0].z = (char *)&pRet->pPhrase[1];
122113: memcpy(pRet->pPhrase->aToken[0].z, zToken, nToken);
122114:
122115: if( iEnd<n && z[iEnd]=='*' ){
122116: pRet->pPhrase->aToken[0].isPrefix = 1;
122117: iEnd++;
122118: }
122119:
122120: while( 1 ){
122121: if( !sqlite3_fts3_enable_parentheses
122122: && iStart>0 && z[iStart-1]=='-'
122123: ){
122124: pParse->isNot = 1;
122125: iStart--;
122126: }else if( pParse->bFts4 && iStart>0 && z[iStart-1]=='^' ){
122127: pRet->pPhrase->aToken[0].bFirst = 1;
122128: iStart--;
122129: }else{
122130: break;
122131: }
122132: }
122133:
122134: }
122135: nConsumed = iEnd;
122136: }
122137:
122138: pModule->xClose(pCursor);
122139: }
122140:
122141: *pnConsumed = nConsumed;
122142: *ppExpr = pRet;
122143: return rc;
122144: }
122145:
122146:
122147: /*
122148: ** Enlarge a memory allocation. If an out-of-memory allocation occurs,
122149: ** then free the old allocation.
122150: */
122151: static void *fts3ReallocOrFree(void *pOrig, int nNew){
122152: void *pRet = sqlite3_realloc(pOrig, nNew);
122153: if( !pRet ){
122154: sqlite3_free(pOrig);
122155: }
122156: return pRet;
122157: }
122158:
122159: /*
122160: ** Buffer zInput, length nInput, contains the contents of a quoted string
122161: ** that appeared as part of an fts3 query expression. Neither quote character
122162: ** is included in the buffer. This function attempts to tokenize the entire
122163: ** input buffer and create an Fts3Expr structure of type FTSQUERY_PHRASE
122164: ** containing the results.
122165: **
122166: ** If successful, SQLITE_OK is returned and *ppExpr set to point at the
122167: ** allocated Fts3Expr structure. Otherwise, either SQLITE_NOMEM (out of memory
122168: ** error) or SQLITE_ERROR (tokenization error) is returned and *ppExpr set
122169: ** to 0.
122170: */
122171: static int getNextString(
122172: ParseContext *pParse, /* fts3 query parse context */
122173: const char *zInput, int nInput, /* Input string */
122174: Fts3Expr **ppExpr /* OUT: expression */
122175: ){
122176: sqlite3_tokenizer *pTokenizer = pParse->pTokenizer;
122177: sqlite3_tokenizer_module const *pModule = pTokenizer->pModule;
122178: int rc;
122179: Fts3Expr *p = 0;
122180: sqlite3_tokenizer_cursor *pCursor = 0;
122181: char *zTemp = 0;
122182: int nTemp = 0;
122183:
122184: const int nSpace = sizeof(Fts3Expr) + sizeof(Fts3Phrase);
122185: int nToken = 0;
122186:
122187: /* The final Fts3Expr data structure, including the Fts3Phrase,
122188: ** Fts3PhraseToken structures token buffers are all stored as a single
122189: ** allocation so that the expression can be freed with a single call to
122190: ** sqlite3_free(). Setting this up requires a two pass approach.
122191: **
122192: ** The first pass, in the block below, uses a tokenizer cursor to iterate
122193: ** through the tokens in the expression. This pass uses fts3ReallocOrFree()
122194: ** to assemble data in two dynamic buffers:
122195: **
122196: ** Buffer p: Points to the Fts3Expr structure, followed by the Fts3Phrase
122197: ** structure, followed by the array of Fts3PhraseToken
122198: ** structures. This pass only populates the Fts3PhraseToken array.
122199: **
122200: ** Buffer zTemp: Contains copies of all tokens.
122201: **
122202: ** The second pass, in the block that begins "if( rc==SQLITE_DONE )" below,
122203: ** appends buffer zTemp to buffer p, and fills in the Fts3Expr and Fts3Phrase
122204: ** structures.
122205: */
122206: rc = pModule->xOpen(pTokenizer, zInput, nInput, &pCursor);
122207: if( rc==SQLITE_OK ){
122208: int ii;
122209: pCursor->pTokenizer = pTokenizer;
122210: for(ii=0; rc==SQLITE_OK; ii++){
122211: const char *zByte;
122212: int nByte, iBegin, iEnd, iPos;
122213: rc = pModule->xNext(pCursor, &zByte, &nByte, &iBegin, &iEnd, &iPos);
122214: if( rc==SQLITE_OK ){
122215: Fts3PhraseToken *pToken;
122216:
122217: p = fts3ReallocOrFree(p, nSpace + ii*sizeof(Fts3PhraseToken));
122218: if( !p ) goto no_mem;
122219:
122220: zTemp = fts3ReallocOrFree(zTemp, nTemp + nByte);
122221: if( !zTemp ) goto no_mem;
122222:
122223: assert( nToken==ii );
122224: pToken = &((Fts3Phrase *)(&p[1]))->aToken[ii];
122225: memset(pToken, 0, sizeof(Fts3PhraseToken));
122226:
122227: memcpy(&zTemp[nTemp], zByte, nByte);
122228: nTemp += nByte;
122229:
122230: pToken->n = nByte;
122231: pToken->isPrefix = (iEnd<nInput && zInput[iEnd]=='*');
122232: pToken->bFirst = (iBegin>0 && zInput[iBegin-1]=='^');
122233: nToken = ii+1;
122234: }
122235: }
122236:
122237: pModule->xClose(pCursor);
122238: pCursor = 0;
122239: }
122240:
122241: if( rc==SQLITE_DONE ){
122242: int jj;
122243: char *zBuf = 0;
122244:
122245: p = fts3ReallocOrFree(p, nSpace + nToken*sizeof(Fts3PhraseToken) + nTemp);
122246: if( !p ) goto no_mem;
122247: memset(p, 0, (char *)&(((Fts3Phrase *)&p[1])->aToken[0])-(char *)p);
122248: p->eType = FTSQUERY_PHRASE;
122249: p->pPhrase = (Fts3Phrase *)&p[1];
122250: p->pPhrase->iColumn = pParse->iDefaultCol;
122251: p->pPhrase->nToken = nToken;
122252:
122253: zBuf = (char *)&p->pPhrase->aToken[nToken];
122254: if( zTemp ){
122255: memcpy(zBuf, zTemp, nTemp);
122256: sqlite3_free(zTemp);
122257: }else{
122258: assert( nTemp==0 );
122259: }
122260:
122261: for(jj=0; jj<p->pPhrase->nToken; jj++){
122262: p->pPhrase->aToken[jj].z = zBuf;
122263: zBuf += p->pPhrase->aToken[jj].n;
122264: }
122265: rc = SQLITE_OK;
122266: }
122267:
122268: *ppExpr = p;
122269: return rc;
122270: no_mem:
122271:
122272: if( pCursor ){
122273: pModule->xClose(pCursor);
122274: }
122275: sqlite3_free(zTemp);
122276: sqlite3_free(p);
122277: *ppExpr = 0;
122278: return SQLITE_NOMEM;
122279: }
122280:
122281: /*
122282: ** Function getNextNode(), which is called by fts3ExprParse(), may itself
122283: ** call fts3ExprParse(). So this forward declaration is required.
122284: */
122285: static int fts3ExprParse(ParseContext *, const char *, int, Fts3Expr **, int *);
122286:
122287: /*
122288: ** The output variable *ppExpr is populated with an allocated Fts3Expr
122289: ** structure, or set to 0 if the end of the input buffer is reached.
122290: **
122291: ** Returns an SQLite error code. SQLITE_OK if everything works, SQLITE_NOMEM
122292: ** if a malloc failure occurs, or SQLITE_ERROR if a parse error is encountered.
122293: ** If SQLITE_ERROR is returned, pContext is populated with an error message.
122294: */
122295: static int getNextNode(
122296: ParseContext *pParse, /* fts3 query parse context */
122297: const char *z, int n, /* Input string */
122298: Fts3Expr **ppExpr, /* OUT: expression */
122299: int *pnConsumed /* OUT: Number of bytes consumed */
122300: ){
122301: static const struct Fts3Keyword {
122302: char *z; /* Keyword text */
122303: unsigned char n; /* Length of the keyword */
122304: unsigned char parenOnly; /* Only valid in paren mode */
122305: unsigned char eType; /* Keyword code */
122306: } aKeyword[] = {
122307: { "OR" , 2, 0, FTSQUERY_OR },
122308: { "AND", 3, 1, FTSQUERY_AND },
122309: { "NOT", 3, 1, FTSQUERY_NOT },
122310: { "NEAR", 4, 0, FTSQUERY_NEAR }
122311: };
122312: int ii;
122313: int iCol;
122314: int iColLen;
122315: int rc;
122316: Fts3Expr *pRet = 0;
122317:
122318: const char *zInput = z;
122319: int nInput = n;
122320:
122321: pParse->isNot = 0;
122322:
122323: /* Skip over any whitespace before checking for a keyword, an open or
122324: ** close bracket, or a quoted string.
122325: */
122326: while( nInput>0 && fts3isspace(*zInput) ){
122327: nInput--;
122328: zInput++;
122329: }
122330: if( nInput==0 ){
122331: return SQLITE_DONE;
122332: }
122333:
122334: /* See if we are dealing with a keyword. */
122335: for(ii=0; ii<(int)(sizeof(aKeyword)/sizeof(struct Fts3Keyword)); ii++){
122336: const struct Fts3Keyword *pKey = &aKeyword[ii];
122337:
122338: if( (pKey->parenOnly & ~sqlite3_fts3_enable_parentheses)!=0 ){
122339: continue;
122340: }
122341:
122342: if( nInput>=pKey->n && 0==memcmp(zInput, pKey->z, pKey->n) ){
122343: int nNear = SQLITE_FTS3_DEFAULT_NEAR_PARAM;
122344: int nKey = pKey->n;
122345: char cNext;
122346:
122347: /* If this is a "NEAR" keyword, check for an explicit nearness. */
122348: if( pKey->eType==FTSQUERY_NEAR ){
122349: assert( nKey==4 );
122350: if( zInput[4]=='/' && zInput[5]>='0' && zInput[5]<='9' ){
122351: nNear = 0;
122352: for(nKey=5; zInput[nKey]>='0' && zInput[nKey]<='9'; nKey++){
122353: nNear = nNear * 10 + (zInput[nKey] - '0');
122354: }
122355: }
122356: }
122357:
122358: /* At this point this is probably a keyword. But for that to be true,
122359: ** the next byte must contain either whitespace, an open or close
122360: ** parenthesis, a quote character, or EOF.
122361: */
122362: cNext = zInput[nKey];
122363: if( fts3isspace(cNext)
122364: || cNext=='"' || cNext=='(' || cNext==')' || cNext==0
122365: ){
122366: pRet = (Fts3Expr *)fts3MallocZero(sizeof(Fts3Expr));
122367: if( !pRet ){
122368: return SQLITE_NOMEM;
122369: }
122370: pRet->eType = pKey->eType;
122371: pRet->nNear = nNear;
122372: *ppExpr = pRet;
122373: *pnConsumed = (int)((zInput - z) + nKey);
122374: return SQLITE_OK;
122375: }
122376:
122377: /* Turns out that wasn't a keyword after all. This happens if the
122378: ** user has supplied a token such as "ORacle". Continue.
122379: */
122380: }
122381: }
122382:
122383: /* Check for an open bracket. */
122384: if( sqlite3_fts3_enable_parentheses ){
122385: if( *zInput=='(' ){
122386: int nConsumed;
122387: pParse->nNest++;
122388: rc = fts3ExprParse(pParse, &zInput[1], nInput-1, ppExpr, &nConsumed);
122389: if( rc==SQLITE_OK && !*ppExpr ){
122390: rc = SQLITE_DONE;
122391: }
122392: *pnConsumed = (int)((zInput - z) + 1 + nConsumed);
122393: return rc;
122394: }
122395:
122396: /* Check for a close bracket. */
122397: if( *zInput==')' ){
122398: pParse->nNest--;
122399: *pnConsumed = (int)((zInput - z) + 1);
122400: return SQLITE_DONE;
122401: }
122402: }
122403:
122404: /* See if we are dealing with a quoted phrase. If this is the case, then
122405: ** search for the closing quote and pass the whole string to getNextString()
122406: ** for processing. This is easy to do, as fts3 has no syntax for escaping
122407: ** a quote character embedded in a string.
122408: */
122409: if( *zInput=='"' ){
122410: for(ii=1; ii<nInput && zInput[ii]!='"'; ii++);
122411: *pnConsumed = (int)((zInput - z) + ii + 1);
122412: if( ii==nInput ){
122413: return SQLITE_ERROR;
122414: }
122415: return getNextString(pParse, &zInput[1], ii-1, ppExpr);
122416: }
122417:
122418:
122419: /* If control flows to this point, this must be a regular token, or
122420: ** the end of the input. Read a regular token using the sqlite3_tokenizer
122421: ** interface. Before doing so, figure out if there is an explicit
122422: ** column specifier for the token.
122423: **
122424: ** TODO: Strangely, it is not possible to associate a column specifier
122425: ** with a quoted phrase, only with a single token. Not sure if this was
122426: ** an implementation artifact or an intentional decision when fts3 was
122427: ** first implemented. Whichever it was, this module duplicates the
122428: ** limitation.
122429: */
122430: iCol = pParse->iDefaultCol;
122431: iColLen = 0;
122432: for(ii=0; ii<pParse->nCol; ii++){
122433: const char *zStr = pParse->azCol[ii];
122434: int nStr = (int)strlen(zStr);
122435: if( nInput>nStr && zInput[nStr]==':'
122436: && sqlite3_strnicmp(zStr, zInput, nStr)==0
122437: ){
122438: iCol = ii;
122439: iColLen = (int)((zInput - z) + nStr + 1);
122440: break;
122441: }
122442: }
122443: rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
122444: *pnConsumed += iColLen;
122445: return rc;
122446: }
122447:
122448: /*
122449: ** The argument is an Fts3Expr structure for a binary operator (any type
122450: ** except an FTSQUERY_PHRASE). Return an integer value representing the
122451: ** precedence of the operator. Lower values have a higher precedence (i.e.
122452: ** group more tightly). For example, in the C language, the == operator
122453: ** groups more tightly than ||, and would therefore have a higher precedence.
122454: **
122455: ** When using the new fts3 query syntax (when SQLITE_ENABLE_FTS3_PARENTHESIS
122456: ** is defined), the order of the operators in precedence from highest to
122457: ** lowest is:
122458: **
122459: ** NEAR
122460: ** NOT
122461: ** AND (including implicit ANDs)
122462: ** OR
122463: **
122464: ** Note that when using the old query syntax, the OR operator has a higher
122465: ** precedence than the AND operator.
122466: */
122467: static int opPrecedence(Fts3Expr *p){
122468: assert( p->eType!=FTSQUERY_PHRASE );
122469: if( sqlite3_fts3_enable_parentheses ){
122470: return p->eType;
122471: }else if( p->eType==FTSQUERY_NEAR ){
122472: return 1;
122473: }else if( p->eType==FTSQUERY_OR ){
122474: return 2;
122475: }
122476: assert( p->eType==FTSQUERY_AND );
122477: return 3;
122478: }
122479:
122480: /*
122481: ** Argument ppHead contains a pointer to the current head of a query
122482: ** expression tree being parsed. pPrev is the expression node most recently
122483: ** inserted into the tree. This function adds pNew, which is always a binary
122484: ** operator node, into the expression tree based on the relative precedence
122485: ** of pNew and the existing nodes of the tree. This may result in the head
122486: ** of the tree changing, in which case *ppHead is set to the new root node.
122487: */
122488: static void insertBinaryOperator(
122489: Fts3Expr **ppHead, /* Pointer to the root node of a tree */
122490: Fts3Expr *pPrev, /* Node most recently inserted into the tree */
122491: Fts3Expr *pNew /* New binary node to insert into expression tree */
122492: ){
122493: Fts3Expr *pSplit = pPrev;
122494: while( pSplit->pParent && opPrecedence(pSplit->pParent)<=opPrecedence(pNew) ){
122495: pSplit = pSplit->pParent;
122496: }
122497:
122498: if( pSplit->pParent ){
122499: assert( pSplit->pParent->pRight==pSplit );
122500: pSplit->pParent->pRight = pNew;
122501: pNew->pParent = pSplit->pParent;
122502: }else{
122503: *ppHead = pNew;
122504: }
122505: pNew->pLeft = pSplit;
122506: pSplit->pParent = pNew;
122507: }
122508:
122509: /*
122510: ** Parse the fts3 query expression found in buffer z, length n. This function
122511: ** returns either when the end of the buffer is reached or an unmatched
122512: ** closing bracket - ')' - is encountered.
122513: **
122514: ** If successful, SQLITE_OK is returned, *ppExpr is set to point to the
122515: ** parsed form of the expression and *pnConsumed is set to the number of
122516: ** bytes read from buffer z. Otherwise, *ppExpr is set to 0 and SQLITE_NOMEM
122517: ** (out of memory error) or SQLITE_ERROR (parse error) is returned.
122518: */
122519: static int fts3ExprParse(
122520: ParseContext *pParse, /* fts3 query parse context */
122521: const char *z, int n, /* Text of MATCH query */
122522: Fts3Expr **ppExpr, /* OUT: Parsed query structure */
122523: int *pnConsumed /* OUT: Number of bytes consumed */
122524: ){
122525: Fts3Expr *pRet = 0;
122526: Fts3Expr *pPrev = 0;
122527: Fts3Expr *pNotBranch = 0; /* Only used in legacy parse mode */
122528: int nIn = n;
122529: const char *zIn = z;
122530: int rc = SQLITE_OK;
122531: int isRequirePhrase = 1;
122532:
122533: while( rc==SQLITE_OK ){
122534: Fts3Expr *p = 0;
122535: int nByte = 0;
122536: rc = getNextNode(pParse, zIn, nIn, &p, &nByte);
122537: if( rc==SQLITE_OK ){
122538: int isPhrase;
122539:
122540: if( !sqlite3_fts3_enable_parentheses
122541: && p->eType==FTSQUERY_PHRASE && pParse->isNot
122542: ){
122543: /* Create an implicit NOT operator. */
122544: Fts3Expr *pNot = fts3MallocZero(sizeof(Fts3Expr));
122545: if( !pNot ){
122546: sqlite3Fts3ExprFree(p);
122547: rc = SQLITE_NOMEM;
122548: goto exprparse_out;
122549: }
122550: pNot->eType = FTSQUERY_NOT;
122551: pNot->pRight = p;
122552: if( pNotBranch ){
122553: pNot->pLeft = pNotBranch;
122554: }
122555: pNotBranch = pNot;
122556: p = pPrev;
122557: }else{
122558: int eType = p->eType;
122559: isPhrase = (eType==FTSQUERY_PHRASE || p->pLeft);
122560:
122561: /* The isRequirePhrase variable is set to true if a phrase or
122562: ** an expression contained in parenthesis is required. If a
122563: ** binary operator (AND, OR, NOT or NEAR) is encounted when
122564: ** isRequirePhrase is set, this is a syntax error.
122565: */
122566: if( !isPhrase && isRequirePhrase ){
122567: sqlite3Fts3ExprFree(p);
122568: rc = SQLITE_ERROR;
122569: goto exprparse_out;
122570: }
122571:
122572: if( isPhrase && !isRequirePhrase ){
122573: /* Insert an implicit AND operator. */
122574: Fts3Expr *pAnd;
122575: assert( pRet && pPrev );
122576: pAnd = fts3MallocZero(sizeof(Fts3Expr));
122577: if( !pAnd ){
122578: sqlite3Fts3ExprFree(p);
122579: rc = SQLITE_NOMEM;
122580: goto exprparse_out;
122581: }
122582: pAnd->eType = FTSQUERY_AND;
122583: insertBinaryOperator(&pRet, pPrev, pAnd);
122584: pPrev = pAnd;
122585: }
122586:
122587: /* This test catches attempts to make either operand of a NEAR
122588: ** operator something other than a phrase. For example, either of
122589: ** the following:
122590: **
122591: ** (bracketed expression) NEAR phrase
122592: ** phrase NEAR (bracketed expression)
122593: **
122594: ** Return an error in either case.
122595: */
122596: if( pPrev && (
122597: (eType==FTSQUERY_NEAR && !isPhrase && pPrev->eType!=FTSQUERY_PHRASE)
122598: || (eType!=FTSQUERY_PHRASE && isPhrase && pPrev->eType==FTSQUERY_NEAR)
122599: )){
122600: sqlite3Fts3ExprFree(p);
122601: rc = SQLITE_ERROR;
122602: goto exprparse_out;
122603: }
122604:
122605: if( isPhrase ){
122606: if( pRet ){
122607: assert( pPrev && pPrev->pLeft && pPrev->pRight==0 );
122608: pPrev->pRight = p;
122609: p->pParent = pPrev;
122610: }else{
122611: pRet = p;
122612: }
122613: }else{
122614: insertBinaryOperator(&pRet, pPrev, p);
122615: }
122616: isRequirePhrase = !isPhrase;
122617: }
122618: assert( nByte>0 );
122619: }
122620: assert( rc!=SQLITE_OK || (nByte>0 && nByte<=nIn) );
122621: nIn -= nByte;
122622: zIn += nByte;
122623: pPrev = p;
122624: }
122625:
122626: if( rc==SQLITE_DONE && pRet && isRequirePhrase ){
122627: rc = SQLITE_ERROR;
122628: }
122629:
122630: if( rc==SQLITE_DONE ){
122631: rc = SQLITE_OK;
122632: if( !sqlite3_fts3_enable_parentheses && pNotBranch ){
122633: if( !pRet ){
122634: rc = SQLITE_ERROR;
122635: }else{
122636: Fts3Expr *pIter = pNotBranch;
122637: while( pIter->pLeft ){
122638: pIter = pIter->pLeft;
122639: }
122640: pIter->pLeft = pRet;
122641: pRet = pNotBranch;
122642: }
122643: }
122644: }
122645: *pnConsumed = n - nIn;
122646:
122647: exprparse_out:
122648: if( rc!=SQLITE_OK ){
122649: sqlite3Fts3ExprFree(pRet);
122650: sqlite3Fts3ExprFree(pNotBranch);
122651: pRet = 0;
122652: }
122653: *ppExpr = pRet;
122654: return rc;
122655: }
122656:
122657: /*
122658: ** Parameters z and n contain a pointer to and length of a buffer containing
122659: ** an fts3 query expression, respectively. This function attempts to parse the
122660: ** query expression and create a tree of Fts3Expr structures representing the
122661: ** parsed expression. If successful, *ppExpr is set to point to the head
122662: ** of the parsed expression tree and SQLITE_OK is returned. If an error
122663: ** occurs, either SQLITE_NOMEM (out-of-memory error) or SQLITE_ERROR (parse
122664: ** error) is returned and *ppExpr is set to 0.
122665: **
122666: ** If parameter n is a negative number, then z is assumed to point to a
122667: ** nul-terminated string and the length is determined using strlen().
122668: **
122669: ** The first parameter, pTokenizer, is passed the fts3 tokenizer module to
122670: ** use to normalize query tokens while parsing the expression. The azCol[]
122671: ** array, which is assumed to contain nCol entries, should contain the names
122672: ** of each column in the target fts3 table, in order from left to right.
122673: ** Column names must be nul-terminated strings.
122674: **
122675: ** The iDefaultCol parameter should be passed the index of the table column
122676: ** that appears on the left-hand-side of the MATCH operator (the default
122677: ** column to match against for tokens for which a column name is not explicitly
122678: ** specified as part of the query string), or -1 if tokens may by default
122679: ** match any table column.
122680: */
122681: SQLITE_PRIVATE int sqlite3Fts3ExprParse(
122682: sqlite3_tokenizer *pTokenizer, /* Tokenizer module */
122683: char **azCol, /* Array of column names for fts3 table */
122684: int bFts4, /* True to allow FTS4-only syntax */
122685: int nCol, /* Number of entries in azCol[] */
122686: int iDefaultCol, /* Default column to query */
122687: const char *z, int n, /* Text of MATCH query */
122688: Fts3Expr **ppExpr /* OUT: Parsed query structure */
122689: ){
122690: int nParsed;
122691: int rc;
122692: ParseContext sParse;
122693: sParse.pTokenizer = pTokenizer;
122694: sParse.azCol = (const char **)azCol;
122695: sParse.nCol = nCol;
122696: sParse.iDefaultCol = iDefaultCol;
122697: sParse.nNest = 0;
122698: sParse.bFts4 = bFts4;
122699: if( z==0 ){
122700: *ppExpr = 0;
122701: return SQLITE_OK;
122702: }
122703: if( n<0 ){
122704: n = (int)strlen(z);
122705: }
122706: rc = fts3ExprParse(&sParse, z, n, ppExpr, &nParsed);
122707:
122708: /* Check for mismatched parenthesis */
122709: if( rc==SQLITE_OK && sParse.nNest ){
122710: rc = SQLITE_ERROR;
122711: sqlite3Fts3ExprFree(*ppExpr);
122712: *ppExpr = 0;
122713: }
122714:
122715: return rc;
122716: }
122717:
122718: /*
122719: ** Free a parsed fts3 query expression allocated by sqlite3Fts3ExprParse().
122720: */
122721: SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *p){
122722: if( p ){
122723: assert( p->eType==FTSQUERY_PHRASE || p->pPhrase==0 );
122724: sqlite3Fts3ExprFree(p->pLeft);
122725: sqlite3Fts3ExprFree(p->pRight);
122726: sqlite3Fts3EvalPhraseCleanup(p->pPhrase);
122727: sqlite3_free(p->aMI);
122728: sqlite3_free(p);
122729: }
122730: }
122731:
122732: /****************************************************************************
122733: *****************************************************************************
122734: ** Everything after this point is just test code.
122735: */
122736:
122737: #ifdef SQLITE_TEST
122738:
122739: /* #include <stdio.h> */
122740:
122741: /*
122742: ** Function to query the hash-table of tokenizers (see README.tokenizers).
122743: */
122744: static int queryTestTokenizer(
122745: sqlite3 *db,
122746: const char *zName,
122747: const sqlite3_tokenizer_module **pp
122748: ){
122749: int rc;
122750: sqlite3_stmt *pStmt;
122751: const char zSql[] = "SELECT fts3_tokenizer(?)";
122752:
122753: *pp = 0;
122754: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
122755: if( rc!=SQLITE_OK ){
122756: return rc;
122757: }
122758:
122759: sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
122760: if( SQLITE_ROW==sqlite3_step(pStmt) ){
122761: if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){
122762: memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
122763: }
122764: }
122765:
122766: return sqlite3_finalize(pStmt);
122767: }
122768:
122769: /*
122770: ** Return a pointer to a buffer containing a text representation of the
122771: ** expression passed as the first argument. The buffer is obtained from
122772: ** sqlite3_malloc(). It is the responsibility of the caller to use
122773: ** sqlite3_free() to release the memory. If an OOM condition is encountered,
122774: ** NULL is returned.
122775: **
122776: ** If the second argument is not NULL, then its contents are prepended to
122777: ** the returned expression text and then freed using sqlite3_free().
122778: */
122779: static char *exprToString(Fts3Expr *pExpr, char *zBuf){
122780: switch( pExpr->eType ){
122781: case FTSQUERY_PHRASE: {
122782: Fts3Phrase *pPhrase = pExpr->pPhrase;
122783: int i;
122784: zBuf = sqlite3_mprintf(
122785: "%zPHRASE %d 0", zBuf, pPhrase->iColumn);
122786: for(i=0; zBuf && i<pPhrase->nToken; i++){
122787: zBuf = sqlite3_mprintf("%z %.*s%s", zBuf,
122788: pPhrase->aToken[i].n, pPhrase->aToken[i].z,
122789: (pPhrase->aToken[i].isPrefix?"+":"")
122790: );
122791: }
122792: return zBuf;
122793: }
122794:
122795: case FTSQUERY_NEAR:
122796: zBuf = sqlite3_mprintf("%zNEAR/%d ", zBuf, pExpr->nNear);
122797: break;
122798: case FTSQUERY_NOT:
122799: zBuf = sqlite3_mprintf("%zNOT ", zBuf);
122800: break;
122801: case FTSQUERY_AND:
122802: zBuf = sqlite3_mprintf("%zAND ", zBuf);
122803: break;
122804: case FTSQUERY_OR:
122805: zBuf = sqlite3_mprintf("%zOR ", zBuf);
122806: break;
122807: }
122808:
122809: if( zBuf ) zBuf = sqlite3_mprintf("%z{", zBuf);
122810: if( zBuf ) zBuf = exprToString(pExpr->pLeft, zBuf);
122811: if( zBuf ) zBuf = sqlite3_mprintf("%z} {", zBuf);
122812:
122813: if( zBuf ) zBuf = exprToString(pExpr->pRight, zBuf);
122814: if( zBuf ) zBuf = sqlite3_mprintf("%z}", zBuf);
122815:
122816: return zBuf;
122817: }
122818:
122819: /*
122820: ** This is the implementation of a scalar SQL function used to test the
122821: ** expression parser. It should be called as follows:
122822: **
122823: ** fts3_exprtest(<tokenizer>, <expr>, <column 1>, ...);
122824: **
122825: ** The first argument, <tokenizer>, is the name of the fts3 tokenizer used
122826: ** to parse the query expression (see README.tokenizers). The second argument
122827: ** is the query expression to parse. Each subsequent argument is the name
122828: ** of a column of the fts3 table that the query expression may refer to.
122829: ** For example:
122830: **
122831: ** SELECT fts3_exprtest('simple', 'Bill col2:Bloggs', 'col1', 'col2');
122832: */
122833: static void fts3ExprTest(
122834: sqlite3_context *context,
122835: int argc,
122836: sqlite3_value **argv
122837: ){
122838: sqlite3_tokenizer_module const *pModule = 0;
122839: sqlite3_tokenizer *pTokenizer = 0;
122840: int rc;
122841: char **azCol = 0;
122842: const char *zExpr;
122843: int nExpr;
122844: int nCol;
122845: int ii;
122846: Fts3Expr *pExpr;
122847: char *zBuf = 0;
122848: sqlite3 *db = sqlite3_context_db_handle(context);
122849:
122850: if( argc<3 ){
122851: sqlite3_result_error(context,
122852: "Usage: fts3_exprtest(tokenizer, expr, col1, ...", -1
122853: );
122854: return;
122855: }
122856:
122857: rc = queryTestTokenizer(db,
122858: (const char *)sqlite3_value_text(argv[0]), &pModule);
122859: if( rc==SQLITE_NOMEM ){
122860: sqlite3_result_error_nomem(context);
122861: goto exprtest_out;
122862: }else if( !pModule ){
122863: sqlite3_result_error(context, "No such tokenizer module", -1);
122864: goto exprtest_out;
122865: }
122866:
122867: rc = pModule->xCreate(0, 0, &pTokenizer);
122868: assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
122869: if( rc==SQLITE_NOMEM ){
122870: sqlite3_result_error_nomem(context);
122871: goto exprtest_out;
122872: }
122873: pTokenizer->pModule = pModule;
122874:
122875: zExpr = (const char *)sqlite3_value_text(argv[1]);
122876: nExpr = sqlite3_value_bytes(argv[1]);
122877: nCol = argc-2;
122878: azCol = (char **)sqlite3_malloc(nCol*sizeof(char *));
122879: if( !azCol ){
122880: sqlite3_result_error_nomem(context);
122881: goto exprtest_out;
122882: }
122883: for(ii=0; ii<nCol; ii++){
122884: azCol[ii] = (char *)sqlite3_value_text(argv[ii+2]);
122885: }
122886:
122887: rc = sqlite3Fts3ExprParse(
122888: pTokenizer, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr
122889: );
122890: if( rc!=SQLITE_OK && rc!=SQLITE_NOMEM ){
122891: sqlite3_result_error(context, "Error parsing expression", -1);
122892: }else if( rc==SQLITE_NOMEM || !(zBuf = exprToString(pExpr, 0)) ){
122893: sqlite3_result_error_nomem(context);
122894: }else{
122895: sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
122896: sqlite3_free(zBuf);
122897: }
122898:
122899: sqlite3Fts3ExprFree(pExpr);
122900:
122901: exprtest_out:
122902: if( pModule && pTokenizer ){
122903: rc = pModule->xDestroy(pTokenizer);
122904: }
122905: sqlite3_free(azCol);
122906: }
122907:
122908: /*
122909: ** Register the query expression parser test function fts3_exprtest()
122910: ** with database connection db.
122911: */
122912: SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3* db){
122913: return sqlite3_create_function(
122914: db, "fts3_exprtest", -1, SQLITE_UTF8, 0, fts3ExprTest, 0, 0
122915: );
122916: }
122917:
122918: #endif
122919: #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
122920:
122921: /************** End of fts3_expr.c *******************************************/
122922: /************** Begin file fts3_hash.c ***************************************/
122923: /*
122924: ** 2001 September 22
122925: **
122926: ** The author disclaims copyright to this source code. In place of
122927: ** a legal notice, here is a blessing:
122928: **
122929: ** May you do good and not evil.
122930: ** May you find forgiveness for yourself and forgive others.
122931: ** May you share freely, never taking more than you give.
122932: **
122933: *************************************************************************
122934: ** This is the implementation of generic hash-tables used in SQLite.
122935: ** We've modified it slightly to serve as a standalone hash table
122936: ** implementation for the full-text indexing module.
122937: */
122938:
122939: /*
122940: ** The code in this file is only compiled if:
122941: **
122942: ** * The FTS3 module is being built as an extension
122943: ** (in which case SQLITE_CORE is not defined), or
122944: **
122945: ** * The FTS3 module is being built into the core of
122946: ** SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
122947: */
122948: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
122949:
122950: /* #include <assert.h> */
122951: /* #include <stdlib.h> */
122952: /* #include <string.h> */
122953:
122954:
122955: /*
122956: ** Malloc and Free functions
122957: */
122958: static void *fts3HashMalloc(int n){
122959: void *p = sqlite3_malloc(n);
122960: if( p ){
122961: memset(p, 0, n);
122962: }
122963: return p;
122964: }
122965: static void fts3HashFree(void *p){
122966: sqlite3_free(p);
122967: }
122968:
122969: /* Turn bulk memory into a hash table object by initializing the
122970: ** fields of the Hash structure.
122971: **
122972: ** "pNew" is a pointer to the hash table that is to be initialized.
122973: ** keyClass is one of the constants
122974: ** FTS3_HASH_BINARY or FTS3_HASH_STRING. The value of keyClass
122975: ** determines what kind of key the hash table will use. "copyKey" is
122976: ** true if the hash table should make its own private copy of keys and
122977: ** false if it should just use the supplied pointer.
122978: */
122979: SQLITE_PRIVATE void sqlite3Fts3HashInit(Fts3Hash *pNew, char keyClass, char copyKey){
122980: assert( pNew!=0 );
122981: assert( keyClass>=FTS3_HASH_STRING && keyClass<=FTS3_HASH_BINARY );
122982: pNew->keyClass = keyClass;
122983: pNew->copyKey = copyKey;
122984: pNew->first = 0;
122985: pNew->count = 0;
122986: pNew->htsize = 0;
122987: pNew->ht = 0;
122988: }
122989:
122990: /* Remove all entries from a hash table. Reclaim all memory.
122991: ** Call this routine to delete a hash table or to reset a hash table
122992: ** to the empty state.
122993: */
122994: SQLITE_PRIVATE void sqlite3Fts3HashClear(Fts3Hash *pH){
122995: Fts3HashElem *elem; /* For looping over all elements of the table */
122996:
122997: assert( pH!=0 );
122998: elem = pH->first;
122999: pH->first = 0;
123000: fts3HashFree(pH->ht);
123001: pH->ht = 0;
123002: pH->htsize = 0;
123003: while( elem ){
123004: Fts3HashElem *next_elem = elem->next;
123005: if( pH->copyKey && elem->pKey ){
123006: fts3HashFree(elem->pKey);
123007: }
123008: fts3HashFree(elem);
123009: elem = next_elem;
123010: }
123011: pH->count = 0;
123012: }
123013:
123014: /*
123015: ** Hash and comparison functions when the mode is FTS3_HASH_STRING
123016: */
123017: static int fts3StrHash(const void *pKey, int nKey){
123018: const char *z = (const char *)pKey;
123019: int h = 0;
123020: if( nKey<=0 ) nKey = (int) strlen(z);
123021: while( nKey > 0 ){
123022: h = (h<<3) ^ h ^ *z++;
123023: nKey--;
123024: }
123025: return h & 0x7fffffff;
123026: }
123027: static int fts3StrCompare(const void *pKey1, int n1, const void *pKey2, int n2){
123028: if( n1!=n2 ) return 1;
123029: return strncmp((const char*)pKey1,(const char*)pKey2,n1);
123030: }
123031:
123032: /*
123033: ** Hash and comparison functions when the mode is FTS3_HASH_BINARY
123034: */
123035: static int fts3BinHash(const void *pKey, int nKey){
123036: int h = 0;
123037: const char *z = (const char *)pKey;
123038: while( nKey-- > 0 ){
123039: h = (h<<3) ^ h ^ *(z++);
123040: }
123041: return h & 0x7fffffff;
123042: }
123043: static int fts3BinCompare(const void *pKey1, int n1, const void *pKey2, int n2){
123044: if( n1!=n2 ) return 1;
123045: return memcmp(pKey1,pKey2,n1);
123046: }
123047:
123048: /*
123049: ** Return a pointer to the appropriate hash function given the key class.
123050: **
123051: ** The C syntax in this function definition may be unfamilar to some
123052: ** programmers, so we provide the following additional explanation:
123053: **
123054: ** The name of the function is "ftsHashFunction". The function takes a
123055: ** single parameter "keyClass". The return value of ftsHashFunction()
123056: ** is a pointer to another function. Specifically, the return value
123057: ** of ftsHashFunction() is a pointer to a function that takes two parameters
123058: ** with types "const void*" and "int" and returns an "int".
123059: */
123060: static int (*ftsHashFunction(int keyClass))(const void*,int){
123061: if( keyClass==FTS3_HASH_STRING ){
123062: return &fts3StrHash;
123063: }else{
123064: assert( keyClass==FTS3_HASH_BINARY );
123065: return &fts3BinHash;
123066: }
123067: }
123068:
123069: /*
123070: ** Return a pointer to the appropriate hash function given the key class.
123071: **
123072: ** For help in interpreted the obscure C code in the function definition,
123073: ** see the header comment on the previous function.
123074: */
123075: static int (*ftsCompareFunction(int keyClass))(const void*,int,const void*,int){
123076: if( keyClass==FTS3_HASH_STRING ){
123077: return &fts3StrCompare;
123078: }else{
123079: assert( keyClass==FTS3_HASH_BINARY );
123080: return &fts3BinCompare;
123081: }
123082: }
123083:
123084: /* Link an element into the hash table
123085: */
123086: static void fts3HashInsertElement(
123087: Fts3Hash *pH, /* The complete hash table */
123088: struct _fts3ht *pEntry, /* The entry into which pNew is inserted */
123089: Fts3HashElem *pNew /* The element to be inserted */
123090: ){
123091: Fts3HashElem *pHead; /* First element already in pEntry */
123092: pHead = pEntry->chain;
123093: if( pHead ){
123094: pNew->next = pHead;
123095: pNew->prev = pHead->prev;
123096: if( pHead->prev ){ pHead->prev->next = pNew; }
123097: else { pH->first = pNew; }
123098: pHead->prev = pNew;
123099: }else{
123100: pNew->next = pH->first;
123101: if( pH->first ){ pH->first->prev = pNew; }
123102: pNew->prev = 0;
123103: pH->first = pNew;
123104: }
123105: pEntry->count++;
123106: pEntry->chain = pNew;
123107: }
123108:
123109:
123110: /* Resize the hash table so that it cantains "new_size" buckets.
123111: ** "new_size" must be a power of 2. The hash table might fail
123112: ** to resize if sqliteMalloc() fails.
123113: **
123114: ** Return non-zero if a memory allocation error occurs.
123115: */
123116: static int fts3Rehash(Fts3Hash *pH, int new_size){
123117: struct _fts3ht *new_ht; /* The new hash table */
123118: Fts3HashElem *elem, *next_elem; /* For looping over existing elements */
123119: int (*xHash)(const void*,int); /* The hash function */
123120:
123121: assert( (new_size & (new_size-1))==0 );
123122: new_ht = (struct _fts3ht *)fts3HashMalloc( new_size*sizeof(struct _fts3ht) );
123123: if( new_ht==0 ) return 1;
123124: fts3HashFree(pH->ht);
123125: pH->ht = new_ht;
123126: pH->htsize = new_size;
123127: xHash = ftsHashFunction(pH->keyClass);
123128: for(elem=pH->first, pH->first=0; elem; elem = next_elem){
123129: int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
123130: next_elem = elem->next;
123131: fts3HashInsertElement(pH, &new_ht[h], elem);
123132: }
123133: return 0;
123134: }
123135:
123136: /* This function (for internal use only) locates an element in an
123137: ** hash table that matches the given key. The hash for this key has
123138: ** already been computed and is passed as the 4th parameter.
123139: */
123140: static Fts3HashElem *fts3FindElementByHash(
123141: const Fts3Hash *pH, /* The pH to be searched */
123142: const void *pKey, /* The key we are searching for */
123143: int nKey,
123144: int h /* The hash for this key. */
123145: ){
123146: Fts3HashElem *elem; /* Used to loop thru the element list */
123147: int count; /* Number of elements left to test */
123148: int (*xCompare)(const void*,int,const void*,int); /* comparison function */
123149:
123150: if( pH->ht ){
123151: struct _fts3ht *pEntry = &pH->ht[h];
123152: elem = pEntry->chain;
123153: count = pEntry->count;
123154: xCompare = ftsCompareFunction(pH->keyClass);
123155: while( count-- && elem ){
123156: if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){
123157: return elem;
123158: }
123159: elem = elem->next;
123160: }
123161: }
123162: return 0;
123163: }
123164:
123165: /* Remove a single entry from the hash table given a pointer to that
123166: ** element and a hash on the element's key.
123167: */
123168: static void fts3RemoveElementByHash(
123169: Fts3Hash *pH, /* The pH containing "elem" */
123170: Fts3HashElem* elem, /* The element to be removed from the pH */
123171: int h /* Hash value for the element */
123172: ){
123173: struct _fts3ht *pEntry;
123174: if( elem->prev ){
123175: elem->prev->next = elem->next;
123176: }else{
123177: pH->first = elem->next;
123178: }
123179: if( elem->next ){
123180: elem->next->prev = elem->prev;
123181: }
123182: pEntry = &pH->ht[h];
123183: if( pEntry->chain==elem ){
123184: pEntry->chain = elem->next;
123185: }
123186: pEntry->count--;
123187: if( pEntry->count<=0 ){
123188: pEntry->chain = 0;
123189: }
123190: if( pH->copyKey && elem->pKey ){
123191: fts3HashFree(elem->pKey);
123192: }
123193: fts3HashFree( elem );
123194: pH->count--;
123195: if( pH->count<=0 ){
123196: assert( pH->first==0 );
123197: assert( pH->count==0 );
123198: fts3HashClear(pH);
123199: }
123200: }
123201:
123202: SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(
123203: const Fts3Hash *pH,
123204: const void *pKey,
123205: int nKey
123206: ){
123207: int h; /* A hash on key */
123208: int (*xHash)(const void*,int); /* The hash function */
123209:
123210: if( pH==0 || pH->ht==0 ) return 0;
123211: xHash = ftsHashFunction(pH->keyClass);
123212: assert( xHash!=0 );
123213: h = (*xHash)(pKey,nKey);
123214: assert( (pH->htsize & (pH->htsize-1))==0 );
123215: return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
123216: }
123217:
123218: /*
123219: ** Attempt to locate an element of the hash table pH with a key
123220: ** that matches pKey,nKey. Return the data for this element if it is
123221: ** found, or NULL if there is no match.
123222: */
123223: SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
123224: Fts3HashElem *pElem; /* The element that matches key (if any) */
123225:
123226: pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey);
123227: return pElem ? pElem->data : 0;
123228: }
123229:
123230: /* Insert an element into the hash table pH. The key is pKey,nKey
123231: ** and the data is "data".
123232: **
123233: ** If no element exists with a matching key, then a new
123234: ** element is created. A copy of the key is made if the copyKey
123235: ** flag is set. NULL is returned.
123236: **
123237: ** If another element already exists with the same key, then the
123238: ** new data replaces the old data and the old data is returned.
123239: ** The key is not copied in this instance. If a malloc fails, then
123240: ** the new data is returned and the hash table is unchanged.
123241: **
123242: ** If the "data" parameter to this function is NULL, then the
123243: ** element corresponding to "key" is removed from the hash table.
123244: */
123245: SQLITE_PRIVATE void *sqlite3Fts3HashInsert(
123246: Fts3Hash *pH, /* The hash table to insert into */
123247: const void *pKey, /* The key */
123248: int nKey, /* Number of bytes in the key */
123249: void *data /* The data */
123250: ){
123251: int hraw; /* Raw hash value of the key */
123252: int h; /* the hash of the key modulo hash table size */
123253: Fts3HashElem *elem; /* Used to loop thru the element list */
123254: Fts3HashElem *new_elem; /* New element added to the pH */
123255: int (*xHash)(const void*,int); /* The hash function */
123256:
123257: assert( pH!=0 );
123258: xHash = ftsHashFunction(pH->keyClass);
123259: assert( xHash!=0 );
123260: hraw = (*xHash)(pKey, nKey);
123261: assert( (pH->htsize & (pH->htsize-1))==0 );
123262: h = hraw & (pH->htsize-1);
123263: elem = fts3FindElementByHash(pH,pKey,nKey,h);
123264: if( elem ){
123265: void *old_data = elem->data;
123266: if( data==0 ){
123267: fts3RemoveElementByHash(pH,elem,h);
123268: }else{
123269: elem->data = data;
123270: }
123271: return old_data;
123272: }
123273: if( data==0 ) return 0;
123274: if( (pH->htsize==0 && fts3Rehash(pH,8))
123275: || (pH->count>=pH->htsize && fts3Rehash(pH, pH->htsize*2))
123276: ){
123277: pH->count = 0;
123278: return data;
123279: }
123280: assert( pH->htsize>0 );
123281: new_elem = (Fts3HashElem*)fts3HashMalloc( sizeof(Fts3HashElem) );
123282: if( new_elem==0 ) return data;
123283: if( pH->copyKey && pKey!=0 ){
123284: new_elem->pKey = fts3HashMalloc( nKey );
123285: if( new_elem->pKey==0 ){
123286: fts3HashFree(new_elem);
123287: return data;
123288: }
123289: memcpy((void*)new_elem->pKey, pKey, nKey);
123290: }else{
123291: new_elem->pKey = (void*)pKey;
123292: }
123293: new_elem->nKey = nKey;
123294: pH->count++;
123295: assert( pH->htsize>0 );
123296: assert( (pH->htsize & (pH->htsize-1))==0 );
123297: h = hraw & (pH->htsize-1);
123298: fts3HashInsertElement(pH, &pH->ht[h], new_elem);
123299: new_elem->data = data;
123300: return 0;
123301: }
123302:
123303: #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
123304:
123305: /************** End of fts3_hash.c *******************************************/
123306: /************** Begin file fts3_porter.c *************************************/
123307: /*
123308: ** 2006 September 30
123309: **
123310: ** The author disclaims copyright to this source code. In place of
123311: ** a legal notice, here is a blessing:
123312: **
123313: ** May you do good and not evil.
123314: ** May you find forgiveness for yourself and forgive others.
123315: ** May you share freely, never taking more than you give.
123316: **
123317: *************************************************************************
123318: ** Implementation of the full-text-search tokenizer that implements
123319: ** a Porter stemmer.
123320: */
123321:
123322: /*
123323: ** The code in this file is only compiled if:
123324: **
123325: ** * The FTS3 module is being built as an extension
123326: ** (in which case SQLITE_CORE is not defined), or
123327: **
123328: ** * The FTS3 module is being built into the core of
123329: ** SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
123330: */
123331: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
123332:
123333: /* #include <assert.h> */
123334: /* #include <stdlib.h> */
123335: /* #include <stdio.h> */
123336: /* #include <string.h> */
123337:
123338:
123339: /*
123340: ** Class derived from sqlite3_tokenizer
123341: */
123342: typedef struct porter_tokenizer {
123343: sqlite3_tokenizer base; /* Base class */
123344: } porter_tokenizer;
123345:
123346: /*
123347: ** Class derived from sqlite3_tokenizer_cursor
123348: */
123349: typedef struct porter_tokenizer_cursor {
123350: sqlite3_tokenizer_cursor base;
123351: const char *zInput; /* input we are tokenizing */
123352: int nInput; /* size of the input */
123353: int iOffset; /* current position in zInput */
123354: int iToken; /* index of next token to be returned */
123355: char *zToken; /* storage for current token */
123356: int nAllocated; /* space allocated to zToken buffer */
123357: } porter_tokenizer_cursor;
123358:
123359:
123360: /*
123361: ** Create a new tokenizer instance.
123362: */
123363: static int porterCreate(
123364: int argc, const char * const *argv,
123365: sqlite3_tokenizer **ppTokenizer
123366: ){
123367: porter_tokenizer *t;
123368:
123369: UNUSED_PARAMETER(argc);
123370: UNUSED_PARAMETER(argv);
123371:
123372: t = (porter_tokenizer *) sqlite3_malloc(sizeof(*t));
123373: if( t==NULL ) return SQLITE_NOMEM;
123374: memset(t, 0, sizeof(*t));
123375: *ppTokenizer = &t->base;
123376: return SQLITE_OK;
123377: }
123378:
123379: /*
123380: ** Destroy a tokenizer
123381: */
123382: static int porterDestroy(sqlite3_tokenizer *pTokenizer){
123383: sqlite3_free(pTokenizer);
123384: return SQLITE_OK;
123385: }
123386:
123387: /*
123388: ** Prepare to begin tokenizing a particular string. The input
123389: ** string to be tokenized is zInput[0..nInput-1]. A cursor
123390: ** used to incrementally tokenize this string is returned in
123391: ** *ppCursor.
123392: */
123393: static int porterOpen(
123394: sqlite3_tokenizer *pTokenizer, /* The tokenizer */
123395: const char *zInput, int nInput, /* String to be tokenized */
123396: sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
123397: ){
123398: porter_tokenizer_cursor *c;
123399:
123400: UNUSED_PARAMETER(pTokenizer);
123401:
123402: c = (porter_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
123403: if( c==NULL ) return SQLITE_NOMEM;
123404:
123405: c->zInput = zInput;
123406: if( zInput==0 ){
123407: c->nInput = 0;
123408: }else if( nInput<0 ){
123409: c->nInput = (int)strlen(zInput);
123410: }else{
123411: c->nInput = nInput;
123412: }
123413: c->iOffset = 0; /* start tokenizing at the beginning */
123414: c->iToken = 0;
123415: c->zToken = NULL; /* no space allocated, yet. */
123416: c->nAllocated = 0;
123417:
123418: *ppCursor = &c->base;
123419: return SQLITE_OK;
123420: }
123421:
123422: /*
123423: ** Close a tokenization cursor previously opened by a call to
123424: ** porterOpen() above.
123425: */
123426: static int porterClose(sqlite3_tokenizer_cursor *pCursor){
123427: porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
123428: sqlite3_free(c->zToken);
123429: sqlite3_free(c);
123430: return SQLITE_OK;
123431: }
123432: /*
123433: ** Vowel or consonant
123434: */
123435: static const char cType[] = {
123436: 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0,
123437: 1, 1, 1, 2, 1
123438: };
123439:
123440: /*
123441: ** isConsonant() and isVowel() determine if their first character in
123442: ** the string they point to is a consonant or a vowel, according
123443: ** to Porter ruls.
123444: **
123445: ** A consonate is any letter other than 'a', 'e', 'i', 'o', or 'u'.
123446: ** 'Y' is a consonant unless it follows another consonant,
123447: ** in which case it is a vowel.
123448: **
123449: ** In these routine, the letters are in reverse order. So the 'y' rule
123450: ** is that 'y' is a consonant unless it is followed by another
123451: ** consonent.
123452: */
123453: static int isVowel(const char*);
123454: static int isConsonant(const char *z){
123455: int j;
123456: char x = *z;
123457: if( x==0 ) return 0;
123458: assert( x>='a' && x<='z' );
123459: j = cType[x-'a'];
123460: if( j<2 ) return j;
123461: return z[1]==0 || isVowel(z + 1);
123462: }
123463: static int isVowel(const char *z){
123464: int j;
123465: char x = *z;
123466: if( x==0 ) return 0;
123467: assert( x>='a' && x<='z' );
123468: j = cType[x-'a'];
123469: if( j<2 ) return 1-j;
123470: return isConsonant(z + 1);
123471: }
123472:
123473: /*
123474: ** Let any sequence of one or more vowels be represented by V and let
123475: ** C be sequence of one or more consonants. Then every word can be
123476: ** represented as:
123477: **
123478: ** [C] (VC){m} [V]
123479: **
123480: ** In prose: A word is an optional consonant followed by zero or
123481: ** vowel-consonant pairs followed by an optional vowel. "m" is the
123482: ** number of vowel consonant pairs. This routine computes the value
123483: ** of m for the first i bytes of a word.
123484: **
123485: ** Return true if the m-value for z is 1 or more. In other words,
123486: ** return true if z contains at least one vowel that is followed
123487: ** by a consonant.
123488: **
123489: ** In this routine z[] is in reverse order. So we are really looking
123490: ** for an instance of of a consonant followed by a vowel.
123491: */
123492: static int m_gt_0(const char *z){
123493: while( isVowel(z) ){ z++; }
123494: if( *z==0 ) return 0;
123495: while( isConsonant(z) ){ z++; }
123496: return *z!=0;
123497: }
123498:
123499: /* Like mgt0 above except we are looking for a value of m which is
123500: ** exactly 1
123501: */
123502: static int m_eq_1(const char *z){
123503: while( isVowel(z) ){ z++; }
123504: if( *z==0 ) return 0;
123505: while( isConsonant(z) ){ z++; }
123506: if( *z==0 ) return 0;
123507: while( isVowel(z) ){ z++; }
123508: if( *z==0 ) return 1;
123509: while( isConsonant(z) ){ z++; }
123510: return *z==0;
123511: }
123512:
123513: /* Like mgt0 above except we are looking for a value of m>1 instead
123514: ** or m>0
123515: */
123516: static int m_gt_1(const char *z){
123517: while( isVowel(z) ){ z++; }
123518: if( *z==0 ) return 0;
123519: while( isConsonant(z) ){ z++; }
123520: if( *z==0 ) return 0;
123521: while( isVowel(z) ){ z++; }
123522: if( *z==0 ) return 0;
123523: while( isConsonant(z) ){ z++; }
123524: return *z!=0;
123525: }
123526:
123527: /*
123528: ** Return TRUE if there is a vowel anywhere within z[0..n-1]
123529: */
123530: static int hasVowel(const char *z){
123531: while( isConsonant(z) ){ z++; }
123532: return *z!=0;
123533: }
123534:
123535: /*
123536: ** Return TRUE if the word ends in a double consonant.
123537: **
123538: ** The text is reversed here. So we are really looking at
123539: ** the first two characters of z[].
123540: */
123541: static int doubleConsonant(const char *z){
123542: return isConsonant(z) && z[0]==z[1];
123543: }
123544:
123545: /*
123546: ** Return TRUE if the word ends with three letters which
123547: ** are consonant-vowel-consonent and where the final consonant
123548: ** is not 'w', 'x', or 'y'.
123549: **
123550: ** The word is reversed here. So we are really checking the
123551: ** first three letters and the first one cannot be in [wxy].
123552: */
123553: static int star_oh(const char *z){
123554: return
123555: isConsonant(z) &&
123556: z[0]!='w' && z[0]!='x' && z[0]!='y' &&
123557: isVowel(z+1) &&
123558: isConsonant(z+2);
123559: }
123560:
123561: /*
123562: ** If the word ends with zFrom and xCond() is true for the stem
123563: ** of the word that preceeds the zFrom ending, then change the
123564: ** ending to zTo.
123565: **
123566: ** The input word *pz and zFrom are both in reverse order. zTo
123567: ** is in normal order.
123568: **
123569: ** Return TRUE if zFrom matches. Return FALSE if zFrom does not
123570: ** match. Not that TRUE is returned even if xCond() fails and
123571: ** no substitution occurs.
123572: */
123573: static int stem(
123574: char **pz, /* The word being stemmed (Reversed) */
123575: const char *zFrom, /* If the ending matches this... (Reversed) */
123576: const char *zTo, /* ... change the ending to this (not reversed) */
123577: int (*xCond)(const char*) /* Condition that must be true */
123578: ){
123579: char *z = *pz;
123580: while( *zFrom && *zFrom==*z ){ z++; zFrom++; }
123581: if( *zFrom!=0 ) return 0;
123582: if( xCond && !xCond(z) ) return 1;
123583: while( *zTo ){
123584: *(--z) = *(zTo++);
123585: }
123586: *pz = z;
123587: return 1;
123588: }
123589:
123590: /*
123591: ** This is the fallback stemmer used when the porter stemmer is
123592: ** inappropriate. The input word is copied into the output with
123593: ** US-ASCII case folding. If the input word is too long (more
123594: ** than 20 bytes if it contains no digits or more than 6 bytes if
123595: ** it contains digits) then word is truncated to 20 or 6 bytes
123596: ** by taking 10 or 3 bytes from the beginning and end.
123597: */
123598: static void copy_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
123599: int i, mx, j;
123600: int hasDigit = 0;
123601: for(i=0; i<nIn; i++){
123602: char c = zIn[i];
123603: if( c>='A' && c<='Z' ){
123604: zOut[i] = c - 'A' + 'a';
123605: }else{
123606: if( c>='0' && c<='9' ) hasDigit = 1;
123607: zOut[i] = c;
123608: }
123609: }
123610: mx = hasDigit ? 3 : 10;
123611: if( nIn>mx*2 ){
123612: for(j=mx, i=nIn-mx; i<nIn; i++, j++){
123613: zOut[j] = zOut[i];
123614: }
123615: i = j;
123616: }
123617: zOut[i] = 0;
123618: *pnOut = i;
123619: }
123620:
123621:
123622: /*
123623: ** Stem the input word zIn[0..nIn-1]. Store the output in zOut.
123624: ** zOut is at least big enough to hold nIn bytes. Write the actual
123625: ** size of the output word (exclusive of the '\0' terminator) into *pnOut.
123626: **
123627: ** Any upper-case characters in the US-ASCII character set ([A-Z])
123628: ** are converted to lower case. Upper-case UTF characters are
123629: ** unchanged.
123630: **
123631: ** Words that are longer than about 20 bytes are stemmed by retaining
123632: ** a few bytes from the beginning and the end of the word. If the
123633: ** word contains digits, 3 bytes are taken from the beginning and
123634: ** 3 bytes from the end. For long words without digits, 10 bytes
123635: ** are taken from each end. US-ASCII case folding still applies.
123636: **
123637: ** If the input word contains not digits but does characters not
123638: ** in [a-zA-Z] then no stemming is attempted and this routine just
123639: ** copies the input into the input into the output with US-ASCII
123640: ** case folding.
123641: **
123642: ** Stemming never increases the length of the word. So there is
123643: ** no chance of overflowing the zOut buffer.
123644: */
123645: static void porter_stemmer(const char *zIn, int nIn, char *zOut, int *pnOut){
123646: int i, j;
123647: char zReverse[28];
123648: char *z, *z2;
123649: if( nIn<3 || nIn>=(int)sizeof(zReverse)-7 ){
123650: /* The word is too big or too small for the porter stemmer.
123651: ** Fallback to the copy stemmer */
123652: copy_stemmer(zIn, nIn, zOut, pnOut);
123653: return;
123654: }
123655: for(i=0, j=sizeof(zReverse)-6; i<nIn; i++, j--){
123656: char c = zIn[i];
123657: if( c>='A' && c<='Z' ){
123658: zReverse[j] = c + 'a' - 'A';
123659: }else if( c>='a' && c<='z' ){
123660: zReverse[j] = c;
123661: }else{
123662: /* The use of a character not in [a-zA-Z] means that we fallback
123663: ** to the copy stemmer */
123664: copy_stemmer(zIn, nIn, zOut, pnOut);
123665: return;
123666: }
123667: }
123668: memset(&zReverse[sizeof(zReverse)-5], 0, 5);
123669: z = &zReverse[j+1];
123670:
123671:
123672: /* Step 1a */
123673: if( z[0]=='s' ){
123674: if(
123675: !stem(&z, "sess", "ss", 0) &&
123676: !stem(&z, "sei", "i", 0) &&
123677: !stem(&z, "ss", "ss", 0)
123678: ){
123679: z++;
123680: }
123681: }
123682:
123683: /* Step 1b */
123684: z2 = z;
123685: if( stem(&z, "dee", "ee", m_gt_0) ){
123686: /* Do nothing. The work was all in the test */
123687: }else if(
123688: (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel))
123689: && z!=z2
123690: ){
123691: if( stem(&z, "ta", "ate", 0) ||
123692: stem(&z, "lb", "ble", 0) ||
123693: stem(&z, "zi", "ize", 0) ){
123694: /* Do nothing. The work was all in the test */
123695: }else if( doubleConsonant(z) && (*z!='l' && *z!='s' && *z!='z') ){
123696: z++;
123697: }else if( m_eq_1(z) && star_oh(z) ){
123698: *(--z) = 'e';
123699: }
123700: }
123701:
123702: /* Step 1c */
123703: if( z[0]=='y' && hasVowel(z+1) ){
123704: z[0] = 'i';
123705: }
123706:
123707: /* Step 2 */
123708: switch( z[1] ){
123709: case 'a':
123710: stem(&z, "lanoita", "ate", m_gt_0) ||
123711: stem(&z, "lanoit", "tion", m_gt_0);
123712: break;
123713: case 'c':
123714: stem(&z, "icne", "ence", m_gt_0) ||
123715: stem(&z, "icna", "ance", m_gt_0);
123716: break;
123717: case 'e':
123718: stem(&z, "rezi", "ize", m_gt_0);
123719: break;
123720: case 'g':
123721: stem(&z, "igol", "log", m_gt_0);
123722: break;
123723: case 'l':
123724: stem(&z, "ilb", "ble", m_gt_0) ||
123725: stem(&z, "illa", "al", m_gt_0) ||
123726: stem(&z, "iltne", "ent", m_gt_0) ||
123727: stem(&z, "ile", "e", m_gt_0) ||
123728: stem(&z, "ilsuo", "ous", m_gt_0);
123729: break;
123730: case 'o':
123731: stem(&z, "noitazi", "ize", m_gt_0) ||
123732: stem(&z, "noita", "ate", m_gt_0) ||
123733: stem(&z, "rota", "ate", m_gt_0);
123734: break;
123735: case 's':
123736: stem(&z, "msila", "al", m_gt_0) ||
123737: stem(&z, "ssenevi", "ive", m_gt_0) ||
123738: stem(&z, "ssenluf", "ful", m_gt_0) ||
123739: stem(&z, "ssensuo", "ous", m_gt_0);
123740: break;
123741: case 't':
123742: stem(&z, "itila", "al", m_gt_0) ||
123743: stem(&z, "itivi", "ive", m_gt_0) ||
123744: stem(&z, "itilib", "ble", m_gt_0);
123745: break;
123746: }
123747:
123748: /* Step 3 */
123749: switch( z[0] ){
123750: case 'e':
123751: stem(&z, "etaci", "ic", m_gt_0) ||
123752: stem(&z, "evita", "", m_gt_0) ||
123753: stem(&z, "ezila", "al", m_gt_0);
123754: break;
123755: case 'i':
123756: stem(&z, "itici", "ic", m_gt_0);
123757: break;
123758: case 'l':
123759: stem(&z, "laci", "ic", m_gt_0) ||
123760: stem(&z, "luf", "", m_gt_0);
123761: break;
123762: case 's':
123763: stem(&z, "ssen", "", m_gt_0);
123764: break;
123765: }
123766:
123767: /* Step 4 */
123768: switch( z[1] ){
123769: case 'a':
123770: if( z[0]=='l' && m_gt_1(z+2) ){
123771: z += 2;
123772: }
123773: break;
123774: case 'c':
123775: if( z[0]=='e' && z[2]=='n' && (z[3]=='a' || z[3]=='e') && m_gt_1(z+4) ){
123776: z += 4;
123777: }
123778: break;
123779: case 'e':
123780: if( z[0]=='r' && m_gt_1(z+2) ){
123781: z += 2;
123782: }
123783: break;
123784: case 'i':
123785: if( z[0]=='c' && m_gt_1(z+2) ){
123786: z += 2;
123787: }
123788: break;
123789: case 'l':
123790: if( z[0]=='e' && z[2]=='b' && (z[3]=='a' || z[3]=='i') && m_gt_1(z+4) ){
123791: z += 4;
123792: }
123793: break;
123794: case 'n':
123795: if( z[0]=='t' ){
123796: if( z[2]=='a' ){
123797: if( m_gt_1(z+3) ){
123798: z += 3;
123799: }
123800: }else if( z[2]=='e' ){
123801: stem(&z, "tneme", "", m_gt_1) ||
123802: stem(&z, "tnem", "", m_gt_1) ||
123803: stem(&z, "tne", "", m_gt_1);
123804: }
123805: }
123806: break;
123807: case 'o':
123808: if( z[0]=='u' ){
123809: if( m_gt_1(z+2) ){
123810: z += 2;
123811: }
123812: }else if( z[3]=='s' || z[3]=='t' ){
123813: stem(&z, "noi", "", m_gt_1);
123814: }
123815: break;
123816: case 's':
123817: if( z[0]=='m' && z[2]=='i' && m_gt_1(z+3) ){
123818: z += 3;
123819: }
123820: break;
123821: case 't':
123822: stem(&z, "eta", "", m_gt_1) ||
123823: stem(&z, "iti", "", m_gt_1);
123824: break;
123825: case 'u':
123826: if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){
123827: z += 3;
123828: }
123829: break;
123830: case 'v':
123831: case 'z':
123832: if( z[0]=='e' && z[2]=='i' && m_gt_1(z+3) ){
123833: z += 3;
123834: }
123835: break;
123836: }
123837:
123838: /* Step 5a */
123839: if( z[0]=='e' ){
123840: if( m_gt_1(z+1) ){
123841: z++;
123842: }else if( m_eq_1(z+1) && !star_oh(z+1) ){
123843: z++;
123844: }
123845: }
123846:
123847: /* Step 5b */
123848: if( m_gt_1(z) && z[0]=='l' && z[1]=='l' ){
123849: z++;
123850: }
123851:
123852: /* z[] is now the stemmed word in reverse order. Flip it back
123853: ** around into forward order and return.
123854: */
123855: *pnOut = i = (int)strlen(z);
123856: zOut[i] = 0;
123857: while( *z ){
123858: zOut[--i] = *(z++);
123859: }
123860: }
123861:
123862: /*
123863: ** Characters that can be part of a token. We assume any character
123864: ** whose value is greater than 0x80 (any UTF character) can be
123865: ** part of a token. In other words, delimiters all must have
123866: ** values of 0x7f or lower.
123867: */
123868: static const char porterIdChar[] = {
123869: /* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */
123870: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */
123871: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */
123872: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */
123873: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */
123874: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */
123875: };
123876: #define isDelim(C) (((ch=C)&0x80)==0 && (ch<0x30 || !porterIdChar[ch-0x30]))
123877:
123878: /*
123879: ** Extract the next token from a tokenization cursor. The cursor must
123880: ** have been opened by a prior call to porterOpen().
123881: */
123882: static int porterNext(
123883: sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by porterOpen */
123884: const char **pzToken, /* OUT: *pzToken is the token text */
123885: int *pnBytes, /* OUT: Number of bytes in token */
123886: int *piStartOffset, /* OUT: Starting offset of token */
123887: int *piEndOffset, /* OUT: Ending offset of token */
123888: int *piPosition /* OUT: Position integer of token */
123889: ){
123890: porter_tokenizer_cursor *c = (porter_tokenizer_cursor *) pCursor;
123891: const char *z = c->zInput;
123892:
123893: while( c->iOffset<c->nInput ){
123894: int iStartOffset, ch;
123895:
123896: /* Scan past delimiter characters */
123897: while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
123898: c->iOffset++;
123899: }
123900:
123901: /* Count non-delimiter characters. */
123902: iStartOffset = c->iOffset;
123903: while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){
123904: c->iOffset++;
123905: }
123906:
123907: if( c->iOffset>iStartOffset ){
123908: int n = c->iOffset-iStartOffset;
123909: if( n>c->nAllocated ){
123910: char *pNew;
123911: c->nAllocated = n+20;
123912: pNew = sqlite3_realloc(c->zToken, c->nAllocated);
123913: if( !pNew ) return SQLITE_NOMEM;
123914: c->zToken = pNew;
123915: }
123916: porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes);
123917: *pzToken = c->zToken;
123918: *piStartOffset = iStartOffset;
123919: *piEndOffset = c->iOffset;
123920: *piPosition = c->iToken++;
123921: return SQLITE_OK;
123922: }
123923: }
123924: return SQLITE_DONE;
123925: }
123926:
123927: /*
123928: ** The set of routines that implement the porter-stemmer tokenizer
123929: */
123930: static const sqlite3_tokenizer_module porterTokenizerModule = {
123931: 0,
123932: porterCreate,
123933: porterDestroy,
123934: porterOpen,
123935: porterClose,
123936: porterNext,
123937: };
123938:
123939: /*
123940: ** Allocate a new porter tokenizer. Return a pointer to the new
123941: ** tokenizer in *ppModule
123942: */
123943: SQLITE_PRIVATE void sqlite3Fts3PorterTokenizerModule(
123944: sqlite3_tokenizer_module const**ppModule
123945: ){
123946: *ppModule = &porterTokenizerModule;
123947: }
123948:
123949: #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
123950:
123951: /************** End of fts3_porter.c *****************************************/
123952: /************** Begin file fts3_tokenizer.c **********************************/
123953: /*
123954: ** 2007 June 22
123955: **
123956: ** The author disclaims copyright to this source code. In place of
123957: ** a legal notice, here is a blessing:
123958: **
123959: ** May you do good and not evil.
123960: ** May you find forgiveness for yourself and forgive others.
123961: ** May you share freely, never taking more than you give.
123962: **
123963: ******************************************************************************
123964: **
123965: ** This is part of an SQLite module implementing full-text search.
123966: ** This particular file implements the generic tokenizer interface.
123967: */
123968:
123969: /*
123970: ** The code in this file is only compiled if:
123971: **
123972: ** * The FTS3 module is being built as an extension
123973: ** (in which case SQLITE_CORE is not defined), or
123974: **
123975: ** * The FTS3 module is being built into the core of
123976: ** SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
123977: */
123978: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
123979:
123980: /* #include <assert.h> */
123981: /* #include <string.h> */
123982:
123983: /*
123984: ** Implementation of the SQL scalar function for accessing the underlying
123985: ** hash table. This function may be called as follows:
123986: **
123987: ** SELECT <function-name>(<key-name>);
123988: ** SELECT <function-name>(<key-name>, <pointer>);
123989: **
123990: ** where <function-name> is the name passed as the second argument
123991: ** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer').
123992: **
123993: ** If the <pointer> argument is specified, it must be a blob value
123994: ** containing a pointer to be stored as the hash data corresponding
123995: ** to the string <key-name>. If <pointer> is not specified, then
123996: ** the string <key-name> must already exist in the has table. Otherwise,
123997: ** an error is returned.
123998: **
123999: ** Whether or not the <pointer> argument is specified, the value returned
124000: ** is a blob containing the pointer stored as the hash data corresponding
124001: ** to string <key-name> (after the hash-table is updated, if applicable).
124002: */
124003: static void scalarFunc(
124004: sqlite3_context *context,
124005: int argc,
124006: sqlite3_value **argv
124007: ){
124008: Fts3Hash *pHash;
124009: void *pPtr = 0;
124010: const unsigned char *zName;
124011: int nName;
124012:
124013: assert( argc==1 || argc==2 );
124014:
124015: pHash = (Fts3Hash *)sqlite3_user_data(context);
124016:
124017: zName = sqlite3_value_text(argv[0]);
124018: nName = sqlite3_value_bytes(argv[0])+1;
124019:
124020: if( argc==2 ){
124021: void *pOld;
124022: int n = sqlite3_value_bytes(argv[1]);
124023: if( n!=sizeof(pPtr) ){
124024: sqlite3_result_error(context, "argument type mismatch", -1);
124025: return;
124026: }
124027: pPtr = *(void **)sqlite3_value_blob(argv[1]);
124028: pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
124029: if( pOld==pPtr ){
124030: sqlite3_result_error(context, "out of memory", -1);
124031: return;
124032: }
124033: }else{
124034: pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
124035: if( !pPtr ){
124036: char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
124037: sqlite3_result_error(context, zErr, -1);
124038: sqlite3_free(zErr);
124039: return;
124040: }
124041: }
124042:
124043: sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
124044: }
124045:
124046: SQLITE_PRIVATE int sqlite3Fts3IsIdChar(char c){
124047: static const char isFtsIdChar[] = {
124048: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */
124049: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */
124050: 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */
124051: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */
124052: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */
124053: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */
124054: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */
124055: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */
124056: };
124057: return (c&0x80 || isFtsIdChar[(int)(c)]);
124058: }
124059:
124060: SQLITE_PRIVATE const char *sqlite3Fts3NextToken(const char *zStr, int *pn){
124061: const char *z1;
124062: const char *z2 = 0;
124063:
124064: /* Find the start of the next token. */
124065: z1 = zStr;
124066: while( z2==0 ){
124067: char c = *z1;
124068: switch( c ){
124069: case '\0': return 0; /* No more tokens here */
124070: case '\'':
124071: case '"':
124072: case '`': {
124073: z2 = z1;
124074: while( *++z2 && (*z2!=c || *++z2==c) );
124075: break;
124076: }
124077: case '[':
124078: z2 = &z1[1];
124079: while( *z2 && z2[0]!=']' ) z2++;
124080: if( *z2 ) z2++;
124081: break;
124082:
124083: default:
124084: if( sqlite3Fts3IsIdChar(*z1) ){
124085: z2 = &z1[1];
124086: while( sqlite3Fts3IsIdChar(*z2) ) z2++;
124087: }else{
124088: z1++;
124089: }
124090: }
124091: }
124092:
124093: *pn = (int)(z2-z1);
124094: return z1;
124095: }
124096:
124097: SQLITE_PRIVATE int sqlite3Fts3InitTokenizer(
124098: Fts3Hash *pHash, /* Tokenizer hash table */
124099: const char *zArg, /* Tokenizer name */
124100: sqlite3_tokenizer **ppTok, /* OUT: Tokenizer (if applicable) */
124101: char **pzErr /* OUT: Set to malloced error message */
124102: ){
124103: int rc;
124104: char *z = (char *)zArg;
124105: int n = 0;
124106: char *zCopy;
124107: char *zEnd; /* Pointer to nul-term of zCopy */
124108: sqlite3_tokenizer_module *m;
124109:
124110: zCopy = sqlite3_mprintf("%s", zArg);
124111: if( !zCopy ) return SQLITE_NOMEM;
124112: zEnd = &zCopy[strlen(zCopy)];
124113:
124114: z = (char *)sqlite3Fts3NextToken(zCopy, &n);
124115: z[n] = '\0';
124116: sqlite3Fts3Dequote(z);
124117:
124118: m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1);
124119: if( !m ){
124120: *pzErr = sqlite3_mprintf("unknown tokenizer: %s", z);
124121: rc = SQLITE_ERROR;
124122: }else{
124123: char const **aArg = 0;
124124: int iArg = 0;
124125: z = &z[n+1];
124126: while( z<zEnd && (NULL!=(z = (char *)sqlite3Fts3NextToken(z, &n))) ){
124127: int nNew = sizeof(char *)*(iArg+1);
124128: char const **aNew = (const char **)sqlite3_realloc((void *)aArg, nNew);
124129: if( !aNew ){
124130: sqlite3_free(zCopy);
124131: sqlite3_free((void *)aArg);
124132: return SQLITE_NOMEM;
124133: }
124134: aArg = aNew;
124135: aArg[iArg++] = z;
124136: z[n] = '\0';
124137: sqlite3Fts3Dequote(z);
124138: z = &z[n+1];
124139: }
124140: rc = m->xCreate(iArg, aArg, ppTok);
124141: assert( rc!=SQLITE_OK || *ppTok );
124142: if( rc!=SQLITE_OK ){
124143: *pzErr = sqlite3_mprintf("unknown tokenizer");
124144: }else{
124145: (*ppTok)->pModule = m;
124146: }
124147: sqlite3_free((void *)aArg);
124148: }
124149:
124150: sqlite3_free(zCopy);
124151: return rc;
124152: }
124153:
124154:
124155: #ifdef SQLITE_TEST
124156:
124157: /* #include <tcl.h> */
124158: /* #include <string.h> */
124159:
124160: /*
124161: ** Implementation of a special SQL scalar function for testing tokenizers
124162: ** designed to be used in concert with the Tcl testing framework. This
124163: ** function must be called with two arguments:
124164: **
124165: ** SELECT <function-name>(<key-name>, <input-string>);
124166: ** SELECT <function-name>(<key-name>, <pointer>);
124167: **
124168: ** where <function-name> is the name passed as the second argument
124169: ** to the sqlite3Fts3InitHashTable() function (e.g. 'fts3_tokenizer')
124170: ** concatenated with the string '_test' (e.g. 'fts3_tokenizer_test').
124171: **
124172: ** The return value is a string that may be interpreted as a Tcl
124173: ** list. For each token in the <input-string>, three elements are
124174: ** added to the returned list. The first is the token position, the
124175: ** second is the token text (folded, stemmed, etc.) and the third is the
124176: ** substring of <input-string> associated with the token. For example,
124177: ** using the built-in "simple" tokenizer:
124178: **
124179: ** SELECT fts_tokenizer_test('simple', 'I don't see how');
124180: **
124181: ** will return the string:
124182: **
124183: ** "{0 i I 1 dont don't 2 see see 3 how how}"
124184: **
124185: */
124186: static void testFunc(
124187: sqlite3_context *context,
124188: int argc,
124189: sqlite3_value **argv
124190: ){
124191: Fts3Hash *pHash;
124192: sqlite3_tokenizer_module *p;
124193: sqlite3_tokenizer *pTokenizer = 0;
124194: sqlite3_tokenizer_cursor *pCsr = 0;
124195:
124196: const char *zErr = 0;
124197:
124198: const char *zName;
124199: int nName;
124200: const char *zInput;
124201: int nInput;
124202:
124203: const char *zArg = 0;
124204:
124205: const char *zToken;
124206: int nToken;
124207: int iStart;
124208: int iEnd;
124209: int iPos;
124210:
124211: Tcl_Obj *pRet;
124212:
124213: assert( argc==2 || argc==3 );
124214:
124215: nName = sqlite3_value_bytes(argv[0]);
124216: zName = (const char *)sqlite3_value_text(argv[0]);
124217: nInput = sqlite3_value_bytes(argv[argc-1]);
124218: zInput = (const char *)sqlite3_value_text(argv[argc-1]);
124219:
124220: if( argc==3 ){
124221: zArg = (const char *)sqlite3_value_text(argv[1]);
124222: }
124223:
124224: pHash = (Fts3Hash *)sqlite3_user_data(context);
124225: p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
124226:
124227: if( !p ){
124228: char *zErr = sqlite3_mprintf("unknown tokenizer: %s", zName);
124229: sqlite3_result_error(context, zErr, -1);
124230: sqlite3_free(zErr);
124231: return;
124232: }
124233:
124234: pRet = Tcl_NewObj();
124235: Tcl_IncrRefCount(pRet);
124236:
124237: if( SQLITE_OK!=p->xCreate(zArg ? 1 : 0, &zArg, &pTokenizer) ){
124238: zErr = "error in xCreate()";
124239: goto finish;
124240: }
124241: pTokenizer->pModule = p;
124242: if( SQLITE_OK!=p->xOpen(pTokenizer, zInput, nInput, &pCsr) ){
124243: zErr = "error in xOpen()";
124244: goto finish;
124245: }
124246: pCsr->pTokenizer = pTokenizer;
124247:
124248: while( SQLITE_OK==p->xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos) ){
124249: Tcl_ListObjAppendElement(0, pRet, Tcl_NewIntObj(iPos));
124250: Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
124251: zToken = &zInput[iStart];
124252: nToken = iEnd-iStart;
124253: Tcl_ListObjAppendElement(0, pRet, Tcl_NewStringObj(zToken, nToken));
124254: }
124255:
124256: if( SQLITE_OK!=p->xClose(pCsr) ){
124257: zErr = "error in xClose()";
124258: goto finish;
124259: }
124260: if( SQLITE_OK!=p->xDestroy(pTokenizer) ){
124261: zErr = "error in xDestroy()";
124262: goto finish;
124263: }
124264:
124265: finish:
124266: if( zErr ){
124267: sqlite3_result_error(context, zErr, -1);
124268: }else{
124269: sqlite3_result_text(context, Tcl_GetString(pRet), -1, SQLITE_TRANSIENT);
124270: }
124271: Tcl_DecrRefCount(pRet);
124272: }
124273:
124274: static
124275: int registerTokenizer(
124276: sqlite3 *db,
124277: char *zName,
124278: const sqlite3_tokenizer_module *p
124279: ){
124280: int rc;
124281: sqlite3_stmt *pStmt;
124282: const char zSql[] = "SELECT fts3_tokenizer(?, ?)";
124283:
124284: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
124285: if( rc!=SQLITE_OK ){
124286: return rc;
124287: }
124288:
124289: sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
124290: sqlite3_bind_blob(pStmt, 2, &p, sizeof(p), SQLITE_STATIC);
124291: sqlite3_step(pStmt);
124292:
124293: return sqlite3_finalize(pStmt);
124294: }
124295:
124296: static
124297: int queryTokenizer(
124298: sqlite3 *db,
124299: char *zName,
124300: const sqlite3_tokenizer_module **pp
124301: ){
124302: int rc;
124303: sqlite3_stmt *pStmt;
124304: const char zSql[] = "SELECT fts3_tokenizer(?)";
124305:
124306: *pp = 0;
124307: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
124308: if( rc!=SQLITE_OK ){
124309: return rc;
124310: }
124311:
124312: sqlite3_bind_text(pStmt, 1, zName, -1, SQLITE_STATIC);
124313: if( SQLITE_ROW==sqlite3_step(pStmt) ){
124314: if( sqlite3_column_type(pStmt, 0)==SQLITE_BLOB ){
124315: memcpy((void *)pp, sqlite3_column_blob(pStmt, 0), sizeof(*pp));
124316: }
124317: }
124318:
124319: return sqlite3_finalize(pStmt);
124320: }
124321:
124322: SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(sqlite3_tokenizer_module const**ppModule);
124323:
124324: /*
124325: ** Implementation of the scalar function fts3_tokenizer_internal_test().
124326: ** This function is used for testing only, it is not included in the
124327: ** build unless SQLITE_TEST is defined.
124328: **
124329: ** The purpose of this is to test that the fts3_tokenizer() function
124330: ** can be used as designed by the C-code in the queryTokenizer and
124331: ** registerTokenizer() functions above. These two functions are repeated
124332: ** in the README.tokenizer file as an example, so it is important to
124333: ** test them.
124334: **
124335: ** To run the tests, evaluate the fts3_tokenizer_internal_test() scalar
124336: ** function with no arguments. An assert() will fail if a problem is
124337: ** detected. i.e.:
124338: **
124339: ** SELECT fts3_tokenizer_internal_test();
124340: **
124341: */
124342: static void intTestFunc(
124343: sqlite3_context *context,
124344: int argc,
124345: sqlite3_value **argv
124346: ){
124347: int rc;
124348: const sqlite3_tokenizer_module *p1;
124349: const sqlite3_tokenizer_module *p2;
124350: sqlite3 *db = (sqlite3 *)sqlite3_user_data(context);
124351:
124352: UNUSED_PARAMETER(argc);
124353: UNUSED_PARAMETER(argv);
124354:
124355: /* Test the query function */
124356: sqlite3Fts3SimpleTokenizerModule(&p1);
124357: rc = queryTokenizer(db, "simple", &p2);
124358: assert( rc==SQLITE_OK );
124359: assert( p1==p2 );
124360: rc = queryTokenizer(db, "nosuchtokenizer", &p2);
124361: assert( rc==SQLITE_ERROR );
124362: assert( p2==0 );
124363: assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
124364:
124365: /* Test the storage function */
124366: rc = registerTokenizer(db, "nosuchtokenizer", p1);
124367: assert( rc==SQLITE_OK );
124368: rc = queryTokenizer(db, "nosuchtokenizer", &p2);
124369: assert( rc==SQLITE_OK );
124370: assert( p2==p1 );
124371:
124372: sqlite3_result_text(context, "ok", -1, SQLITE_STATIC);
124373: }
124374:
124375: #endif
124376:
124377: /*
124378: ** Set up SQL objects in database db used to access the contents of
124379: ** the hash table pointed to by argument pHash. The hash table must
124380: ** been initialised to use string keys, and to take a private copy
124381: ** of the key when a value is inserted. i.e. by a call similar to:
124382: **
124383: ** sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
124384: **
124385: ** This function adds a scalar function (see header comment above
124386: ** scalarFunc() in this file for details) and, if ENABLE_TABLE is
124387: ** defined at compilation time, a temporary virtual table (see header
124388: ** comment above struct HashTableVtab) to the database schema. Both
124389: ** provide read/write access to the contents of *pHash.
124390: **
124391: ** The third argument to this function, zName, is used as the name
124392: ** of both the scalar and, if created, the virtual table.
124393: */
124394: SQLITE_PRIVATE int sqlite3Fts3InitHashTable(
124395: sqlite3 *db,
124396: Fts3Hash *pHash,
124397: const char *zName
124398: ){
124399: int rc = SQLITE_OK;
124400: void *p = (void *)pHash;
124401: const int any = SQLITE_ANY;
124402:
124403: #ifdef SQLITE_TEST
124404: char *zTest = 0;
124405: char *zTest2 = 0;
124406: void *pdb = (void *)db;
124407: zTest = sqlite3_mprintf("%s_test", zName);
124408: zTest2 = sqlite3_mprintf("%s_internal_test", zName);
124409: if( !zTest || !zTest2 ){
124410: rc = SQLITE_NOMEM;
124411: }
124412: #endif
124413:
124414: if( SQLITE_OK==rc ){
124415: rc = sqlite3_create_function(db, zName, 1, any, p, scalarFunc, 0, 0);
124416: }
124417: if( SQLITE_OK==rc ){
124418: rc = sqlite3_create_function(db, zName, 2, any, p, scalarFunc, 0, 0);
124419: }
124420: #ifdef SQLITE_TEST
124421: if( SQLITE_OK==rc ){
124422: rc = sqlite3_create_function(db, zTest, 2, any, p, testFunc, 0, 0);
124423: }
124424: if( SQLITE_OK==rc ){
124425: rc = sqlite3_create_function(db, zTest, 3, any, p, testFunc, 0, 0);
124426: }
124427: if( SQLITE_OK==rc ){
124428: rc = sqlite3_create_function(db, zTest2, 0, any, pdb, intTestFunc, 0, 0);
124429: }
124430: #endif
124431:
124432: #ifdef SQLITE_TEST
124433: sqlite3_free(zTest);
124434: sqlite3_free(zTest2);
124435: #endif
124436:
124437: return rc;
124438: }
124439:
124440: #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
124441:
124442: /************** End of fts3_tokenizer.c **************************************/
124443: /************** Begin file fts3_tokenizer1.c *********************************/
124444: /*
124445: ** 2006 Oct 10
124446: **
124447: ** The author disclaims copyright to this source code. In place of
124448: ** a legal notice, here is a blessing:
124449: **
124450: ** May you do good and not evil.
124451: ** May you find forgiveness for yourself and forgive others.
124452: ** May you share freely, never taking more than you give.
124453: **
124454: ******************************************************************************
124455: **
124456: ** Implementation of the "simple" full-text-search tokenizer.
124457: */
124458:
124459: /*
124460: ** The code in this file is only compiled if:
124461: **
124462: ** * The FTS3 module is being built as an extension
124463: ** (in which case SQLITE_CORE is not defined), or
124464: **
124465: ** * The FTS3 module is being built into the core of
124466: ** SQLite (in which case SQLITE_ENABLE_FTS3 is defined).
124467: */
124468: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
124469:
124470: /* #include <assert.h> */
124471: /* #include <stdlib.h> */
124472: /* #include <stdio.h> */
124473: /* #include <string.h> */
124474:
124475:
124476: typedef struct simple_tokenizer {
124477: sqlite3_tokenizer base;
124478: char delim[128]; /* flag ASCII delimiters */
124479: } simple_tokenizer;
124480:
124481: typedef struct simple_tokenizer_cursor {
124482: sqlite3_tokenizer_cursor base;
124483: const char *pInput; /* input we are tokenizing */
124484: int nBytes; /* size of the input */
124485: int iOffset; /* current position in pInput */
124486: int iToken; /* index of next token to be returned */
124487: char *pToken; /* storage for current token */
124488: int nTokenAllocated; /* space allocated to zToken buffer */
124489: } simple_tokenizer_cursor;
124490:
124491:
124492: static int simpleDelim(simple_tokenizer *t, unsigned char c){
124493: return c<0x80 && t->delim[c];
124494: }
124495: static int fts3_isalnum(int x){
124496: return (x>='0' && x<='9') || (x>='A' && x<='Z') || (x>='a' && x<='z');
124497: }
124498:
124499: /*
124500: ** Create a new tokenizer instance.
124501: */
124502: static int simpleCreate(
124503: int argc, const char * const *argv,
124504: sqlite3_tokenizer **ppTokenizer
124505: ){
124506: simple_tokenizer *t;
124507:
124508: t = (simple_tokenizer *) sqlite3_malloc(sizeof(*t));
124509: if( t==NULL ) return SQLITE_NOMEM;
124510: memset(t, 0, sizeof(*t));
124511:
124512: /* TODO(shess) Delimiters need to remain the same from run to run,
124513: ** else we need to reindex. One solution would be a meta-table to
124514: ** track such information in the database, then we'd only want this
124515: ** information on the initial create.
124516: */
124517: if( argc>1 ){
124518: int i, n = (int)strlen(argv[1]);
124519: for(i=0; i<n; i++){
124520: unsigned char ch = argv[1][i];
124521: /* We explicitly don't support UTF-8 delimiters for now. */
124522: if( ch>=0x80 ){
124523: sqlite3_free(t);
124524: return SQLITE_ERROR;
124525: }
124526: t->delim[ch] = 1;
124527: }
124528: } else {
124529: /* Mark non-alphanumeric ASCII characters as delimiters */
124530: int i;
124531: for(i=1; i<0x80; i++){
124532: t->delim[i] = !fts3_isalnum(i) ? -1 : 0;
124533: }
124534: }
124535:
124536: *ppTokenizer = &t->base;
124537: return SQLITE_OK;
124538: }
124539:
124540: /*
124541: ** Destroy a tokenizer
124542: */
124543: static int simpleDestroy(sqlite3_tokenizer *pTokenizer){
124544: sqlite3_free(pTokenizer);
124545: return SQLITE_OK;
124546: }
124547:
124548: /*
124549: ** Prepare to begin tokenizing a particular string. The input
124550: ** string to be tokenized is pInput[0..nBytes-1]. A cursor
124551: ** used to incrementally tokenize this string is returned in
124552: ** *ppCursor.
124553: */
124554: static int simpleOpen(
124555: sqlite3_tokenizer *pTokenizer, /* The tokenizer */
124556: const char *pInput, int nBytes, /* String to be tokenized */
124557: sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
124558: ){
124559: simple_tokenizer_cursor *c;
124560:
124561: UNUSED_PARAMETER(pTokenizer);
124562:
124563: c = (simple_tokenizer_cursor *) sqlite3_malloc(sizeof(*c));
124564: if( c==NULL ) return SQLITE_NOMEM;
124565:
124566: c->pInput = pInput;
124567: if( pInput==0 ){
124568: c->nBytes = 0;
124569: }else if( nBytes<0 ){
124570: c->nBytes = (int)strlen(pInput);
124571: }else{
124572: c->nBytes = nBytes;
124573: }
124574: c->iOffset = 0; /* start tokenizing at the beginning */
124575: c->iToken = 0;
124576: c->pToken = NULL; /* no space allocated, yet. */
124577: c->nTokenAllocated = 0;
124578:
124579: *ppCursor = &c->base;
124580: return SQLITE_OK;
124581: }
124582:
124583: /*
124584: ** Close a tokenization cursor previously opened by a call to
124585: ** simpleOpen() above.
124586: */
124587: static int simpleClose(sqlite3_tokenizer_cursor *pCursor){
124588: simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
124589: sqlite3_free(c->pToken);
124590: sqlite3_free(c);
124591: return SQLITE_OK;
124592: }
124593:
124594: /*
124595: ** Extract the next token from a tokenization cursor. The cursor must
124596: ** have been opened by a prior call to simpleOpen().
124597: */
124598: static int simpleNext(
124599: sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by simpleOpen */
124600: const char **ppToken, /* OUT: *ppToken is the token text */
124601: int *pnBytes, /* OUT: Number of bytes in token */
124602: int *piStartOffset, /* OUT: Starting offset of token */
124603: int *piEndOffset, /* OUT: Ending offset of token */
124604: int *piPosition /* OUT: Position integer of token */
124605: ){
124606: simple_tokenizer_cursor *c = (simple_tokenizer_cursor *) pCursor;
124607: simple_tokenizer *t = (simple_tokenizer *) pCursor->pTokenizer;
124608: unsigned char *p = (unsigned char *)c->pInput;
124609:
124610: while( c->iOffset<c->nBytes ){
124611: int iStartOffset;
124612:
124613: /* Scan past delimiter characters */
124614: while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
124615: c->iOffset++;
124616: }
124617:
124618: /* Count non-delimiter characters. */
124619: iStartOffset = c->iOffset;
124620: while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
124621: c->iOffset++;
124622: }
124623:
124624: if( c->iOffset>iStartOffset ){
124625: int i, n = c->iOffset-iStartOffset;
124626: if( n>c->nTokenAllocated ){
124627: char *pNew;
124628: c->nTokenAllocated = n+20;
124629: pNew = sqlite3_realloc(c->pToken, c->nTokenAllocated);
124630: if( !pNew ) return SQLITE_NOMEM;
124631: c->pToken = pNew;
124632: }
124633: for(i=0; i<n; i++){
124634: /* TODO(shess) This needs expansion to handle UTF-8
124635: ** case-insensitivity.
124636: */
124637: unsigned char ch = p[iStartOffset+i];
124638: c->pToken[i] = (char)((ch>='A' && ch<='Z') ? ch-'A'+'a' : ch);
124639: }
124640: *ppToken = c->pToken;
124641: *pnBytes = n;
124642: *piStartOffset = iStartOffset;
124643: *piEndOffset = c->iOffset;
124644: *piPosition = c->iToken++;
124645:
124646: return SQLITE_OK;
124647: }
124648: }
124649: return SQLITE_DONE;
124650: }
124651:
124652: /*
124653: ** The set of routines that implement the simple tokenizer
124654: */
124655: static const sqlite3_tokenizer_module simpleTokenizerModule = {
124656: 0,
124657: simpleCreate,
124658: simpleDestroy,
124659: simpleOpen,
124660: simpleClose,
124661: simpleNext,
124662: };
124663:
124664: /*
124665: ** Allocate a new simple tokenizer. Return a pointer to the new
124666: ** tokenizer in *ppModule
124667: */
124668: SQLITE_PRIVATE void sqlite3Fts3SimpleTokenizerModule(
124669: sqlite3_tokenizer_module const**ppModule
124670: ){
124671: *ppModule = &simpleTokenizerModule;
124672: }
124673:
124674: #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
124675:
124676: /************** End of fts3_tokenizer1.c *************************************/
124677: /************** Begin file fts3_write.c **************************************/
124678: /*
124679: ** 2009 Oct 23
124680: **
124681: ** The author disclaims copyright to this source code. In place of
124682: ** a legal notice, here is a blessing:
124683: **
124684: ** May you do good and not evil.
124685: ** May you find forgiveness for yourself and forgive others.
124686: ** May you share freely, never taking more than you give.
124687: **
124688: ******************************************************************************
124689: **
124690: ** This file is part of the SQLite FTS3 extension module. Specifically,
124691: ** this file contains code to insert, update and delete rows from FTS3
124692: ** tables. It also contains code to merge FTS3 b-tree segments. Some
124693: ** of the sub-routines used to merge segments are also used by the query
124694: ** code in fts3.c.
124695: */
124696:
124697: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
124698:
124699: /* #include <string.h> */
124700: /* #include <assert.h> */
124701: /* #include <stdlib.h> */
124702:
124703: /*
124704: ** When full-text index nodes are loaded from disk, the buffer that they
124705: ** are loaded into has the following number of bytes of padding at the end
124706: ** of it. i.e. if a full-text index node is 900 bytes in size, then a buffer
124707: ** of 920 bytes is allocated for it.
124708: **
124709: ** This means that if we have a pointer into a buffer containing node data,
124710: ** it is always safe to read up to two varints from it without risking an
124711: ** overread, even if the node data is corrupted.
124712: */
124713: #define FTS3_NODE_PADDING (FTS3_VARINT_MAX*2)
124714:
124715: /*
124716: ** Under certain circumstances, b-tree nodes (doclists) can be loaded into
124717: ** memory incrementally instead of all at once. This can be a big performance
124718: ** win (reduced IO and CPU) if SQLite stops calling the virtual table xNext()
124719: ** method before retrieving all query results (as may happen, for example,
124720: ** if a query has a LIMIT clause).
124721: **
124722: ** Incremental loading is used for b-tree nodes FTS3_NODE_CHUNK_THRESHOLD
124723: ** bytes and larger. Nodes are loaded in chunks of FTS3_NODE_CHUNKSIZE bytes.
124724: ** The code is written so that the hard lower-limit for each of these values
124725: ** is 1. Clearly such small values would be inefficient, but can be useful
124726: ** for testing purposes.
124727: **
124728: ** If this module is built with SQLITE_TEST defined, these constants may
124729: ** be overridden at runtime for testing purposes. File fts3_test.c contains
124730: ** a Tcl interface to read and write the values.
124731: */
124732: #ifdef SQLITE_TEST
124733: int test_fts3_node_chunksize = (4*1024);
124734: int test_fts3_node_chunk_threshold = (4*1024)*4;
124735: # define FTS3_NODE_CHUNKSIZE test_fts3_node_chunksize
124736: # define FTS3_NODE_CHUNK_THRESHOLD test_fts3_node_chunk_threshold
124737: #else
124738: # define FTS3_NODE_CHUNKSIZE (4*1024)
124739: # define FTS3_NODE_CHUNK_THRESHOLD (FTS3_NODE_CHUNKSIZE*4)
124740: #endif
124741:
124742: typedef struct PendingList PendingList;
124743: typedef struct SegmentNode SegmentNode;
124744: typedef struct SegmentWriter SegmentWriter;
124745:
124746: /*
124747: ** An instance of the following data structure is used to build doclists
124748: ** incrementally. See function fts3PendingListAppend() for details.
124749: */
124750: struct PendingList {
124751: int nData;
124752: char *aData;
124753: int nSpace;
124754: sqlite3_int64 iLastDocid;
124755: sqlite3_int64 iLastCol;
124756: sqlite3_int64 iLastPos;
124757: };
124758:
124759:
124760: /*
124761: ** Each cursor has a (possibly empty) linked list of the following objects.
124762: */
124763: struct Fts3DeferredToken {
124764: Fts3PhraseToken *pToken; /* Pointer to corresponding expr token */
124765: int iCol; /* Column token must occur in */
124766: Fts3DeferredToken *pNext; /* Next in list of deferred tokens */
124767: PendingList *pList; /* Doclist is assembled here */
124768: };
124769:
124770: /*
124771: ** An instance of this structure is used to iterate through the terms on
124772: ** a contiguous set of segment b-tree leaf nodes. Although the details of
124773: ** this structure are only manipulated by code in this file, opaque handles
124774: ** of type Fts3SegReader* are also used by code in fts3.c to iterate through
124775: ** terms when querying the full-text index. See functions:
124776: **
124777: ** sqlite3Fts3SegReaderNew()
124778: ** sqlite3Fts3SegReaderFree()
124779: ** sqlite3Fts3SegReaderIterate()
124780: **
124781: ** Methods used to manipulate Fts3SegReader structures:
124782: **
124783: ** fts3SegReaderNext()
124784: ** fts3SegReaderFirstDocid()
124785: ** fts3SegReaderNextDocid()
124786: */
124787: struct Fts3SegReader {
124788: int iIdx; /* Index within level, or 0x7FFFFFFF for PT */
124789:
124790: sqlite3_int64 iStartBlock; /* Rowid of first leaf block to traverse */
124791: sqlite3_int64 iLeafEndBlock; /* Rowid of final leaf block to traverse */
124792: sqlite3_int64 iEndBlock; /* Rowid of final block in segment (or 0) */
124793: sqlite3_int64 iCurrentBlock; /* Current leaf block (or 0) */
124794:
124795: char *aNode; /* Pointer to node data (or NULL) */
124796: int nNode; /* Size of buffer at aNode (or 0) */
124797: int nPopulate; /* If >0, bytes of buffer aNode[] loaded */
124798: sqlite3_blob *pBlob; /* If not NULL, blob handle to read node */
124799:
124800: Fts3HashElem **ppNextElem;
124801:
124802: /* Variables set by fts3SegReaderNext(). These may be read directly
124803: ** by the caller. They are valid from the time SegmentReaderNew() returns
124804: ** until SegmentReaderNext() returns something other than SQLITE_OK
124805: ** (i.e. SQLITE_DONE).
124806: */
124807: int nTerm; /* Number of bytes in current term */
124808: char *zTerm; /* Pointer to current term */
124809: int nTermAlloc; /* Allocated size of zTerm buffer */
124810: char *aDoclist; /* Pointer to doclist of current entry */
124811: int nDoclist; /* Size of doclist in current entry */
124812:
124813: /* The following variables are used by fts3SegReaderNextDocid() to iterate
124814: ** through the current doclist (aDoclist/nDoclist).
124815: */
124816: char *pOffsetList;
124817: int nOffsetList; /* For descending pending seg-readers only */
124818: sqlite3_int64 iDocid;
124819: };
124820:
124821: #define fts3SegReaderIsPending(p) ((p)->ppNextElem!=0)
124822: #define fts3SegReaderIsRootOnly(p) ((p)->aNode==(char *)&(p)[1])
124823:
124824: /*
124825: ** An instance of this structure is used to create a segment b-tree in the
124826: ** database. The internal details of this type are only accessed by the
124827: ** following functions:
124828: **
124829: ** fts3SegWriterAdd()
124830: ** fts3SegWriterFlush()
124831: ** fts3SegWriterFree()
124832: */
124833: struct SegmentWriter {
124834: SegmentNode *pTree; /* Pointer to interior tree structure */
124835: sqlite3_int64 iFirst; /* First slot in %_segments written */
124836: sqlite3_int64 iFree; /* Next free slot in %_segments */
124837: char *zTerm; /* Pointer to previous term buffer */
124838: int nTerm; /* Number of bytes in zTerm */
124839: int nMalloc; /* Size of malloc'd buffer at zMalloc */
124840: char *zMalloc; /* Malloc'd space (possibly) used for zTerm */
124841: int nSize; /* Size of allocation at aData */
124842: int nData; /* Bytes of data in aData */
124843: char *aData; /* Pointer to block from malloc() */
124844: };
124845:
124846: /*
124847: ** Type SegmentNode is used by the following three functions to create
124848: ** the interior part of the segment b+-tree structures (everything except
124849: ** the leaf nodes). These functions and type are only ever used by code
124850: ** within the fts3SegWriterXXX() family of functions described above.
124851: **
124852: ** fts3NodeAddTerm()
124853: ** fts3NodeWrite()
124854: ** fts3NodeFree()
124855: **
124856: ** When a b+tree is written to the database (either as a result of a merge
124857: ** or the pending-terms table being flushed), leaves are written into the
124858: ** database file as soon as they are completely populated. The interior of
124859: ** the tree is assembled in memory and written out only once all leaves have
124860: ** been populated and stored. This is Ok, as the b+-tree fanout is usually
124861: ** very large, meaning that the interior of the tree consumes relatively
124862: ** little memory.
124863: */
124864: struct SegmentNode {
124865: SegmentNode *pParent; /* Parent node (or NULL for root node) */
124866: SegmentNode *pRight; /* Pointer to right-sibling */
124867: SegmentNode *pLeftmost; /* Pointer to left-most node of this depth */
124868: int nEntry; /* Number of terms written to node so far */
124869: char *zTerm; /* Pointer to previous term buffer */
124870: int nTerm; /* Number of bytes in zTerm */
124871: int nMalloc; /* Size of malloc'd buffer at zMalloc */
124872: char *zMalloc; /* Malloc'd space (possibly) used for zTerm */
124873: int nData; /* Bytes of valid data so far */
124874: char *aData; /* Node data */
124875: };
124876:
124877: /*
124878: ** Valid values for the second argument to fts3SqlStmt().
124879: */
124880: #define SQL_DELETE_CONTENT 0
124881: #define SQL_IS_EMPTY 1
124882: #define SQL_DELETE_ALL_CONTENT 2
124883: #define SQL_DELETE_ALL_SEGMENTS 3
124884: #define SQL_DELETE_ALL_SEGDIR 4
124885: #define SQL_DELETE_ALL_DOCSIZE 5
124886: #define SQL_DELETE_ALL_STAT 6
124887: #define SQL_SELECT_CONTENT_BY_ROWID 7
124888: #define SQL_NEXT_SEGMENT_INDEX 8
124889: #define SQL_INSERT_SEGMENTS 9
124890: #define SQL_NEXT_SEGMENTS_ID 10
124891: #define SQL_INSERT_SEGDIR 11
124892: #define SQL_SELECT_LEVEL 12
124893: #define SQL_SELECT_LEVEL_RANGE 13
124894: #define SQL_SELECT_LEVEL_COUNT 14
124895: #define SQL_SELECT_SEGDIR_MAX_LEVEL 15
124896: #define SQL_DELETE_SEGDIR_LEVEL 16
124897: #define SQL_DELETE_SEGMENTS_RANGE 17
124898: #define SQL_CONTENT_INSERT 18
124899: #define SQL_DELETE_DOCSIZE 19
124900: #define SQL_REPLACE_DOCSIZE 20
124901: #define SQL_SELECT_DOCSIZE 21
124902: #define SQL_SELECT_DOCTOTAL 22
124903: #define SQL_REPLACE_DOCTOTAL 23
124904:
124905: #define SQL_SELECT_ALL_PREFIX_LEVEL 24
124906: #define SQL_DELETE_ALL_TERMS_SEGDIR 25
124907:
124908: #define SQL_DELETE_SEGDIR_RANGE 26
124909:
124910: /*
124911: ** This function is used to obtain an SQLite prepared statement handle
124912: ** for the statement identified by the second argument. If successful,
124913: ** *pp is set to the requested statement handle and SQLITE_OK returned.
124914: ** Otherwise, an SQLite error code is returned and *pp is set to 0.
124915: **
124916: ** If argument apVal is not NULL, then it must point to an array with
124917: ** at least as many entries as the requested statement has bound
124918: ** parameters. The values are bound to the statements parameters before
124919: ** returning.
124920: */
124921: static int fts3SqlStmt(
124922: Fts3Table *p, /* Virtual table handle */
124923: int eStmt, /* One of the SQL_XXX constants above */
124924: sqlite3_stmt **pp, /* OUT: Statement handle */
124925: sqlite3_value **apVal /* Values to bind to statement */
124926: ){
124927: const char *azSql[] = {
124928: /* 0 */ "DELETE FROM %Q.'%q_content' WHERE rowid = ?",
124929: /* 1 */ "SELECT NOT EXISTS(SELECT docid FROM %Q.'%q_content' WHERE rowid!=?)",
124930: /* 2 */ "DELETE FROM %Q.'%q_content'",
124931: /* 3 */ "DELETE FROM %Q.'%q_segments'",
124932: /* 4 */ "DELETE FROM %Q.'%q_segdir'",
124933: /* 5 */ "DELETE FROM %Q.'%q_docsize'",
124934: /* 6 */ "DELETE FROM %Q.'%q_stat'",
124935: /* 7 */ "SELECT %s WHERE rowid=?",
124936: /* 8 */ "SELECT (SELECT max(idx) FROM %Q.'%q_segdir' WHERE level = ?) + 1",
124937: /* 9 */ "INSERT INTO %Q.'%q_segments'(blockid, block) VALUES(?, ?)",
124938: /* 10 */ "SELECT coalesce((SELECT max(blockid) FROM %Q.'%q_segments') + 1, 1)",
124939: /* 11 */ "INSERT INTO %Q.'%q_segdir' VALUES(?,?,?,?,?,?)",
124940:
124941: /* Return segments in order from oldest to newest.*/
124942: /* 12 */ "SELECT idx, start_block, leaves_end_block, end_block, root "
124943: "FROM %Q.'%q_segdir' WHERE level = ? ORDER BY idx ASC",
124944: /* 13 */ "SELECT idx, start_block, leaves_end_block, end_block, root "
124945: "FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?"
124946: "ORDER BY level DESC, idx ASC",
124947:
124948: /* 14 */ "SELECT count(*) FROM %Q.'%q_segdir' WHERE level = ?",
124949: /* 15 */ "SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?",
124950:
124951: /* 16 */ "DELETE FROM %Q.'%q_segdir' WHERE level = ?",
124952: /* 17 */ "DELETE FROM %Q.'%q_segments' WHERE blockid BETWEEN ? AND ?",
124953: /* 18 */ "INSERT INTO %Q.'%q_content' VALUES(%s)",
124954: /* 19 */ "DELETE FROM %Q.'%q_docsize' WHERE docid = ?",
124955: /* 20 */ "REPLACE INTO %Q.'%q_docsize' VALUES(?,?)",
124956: /* 21 */ "SELECT size FROM %Q.'%q_docsize' WHERE docid=?",
124957: /* 22 */ "SELECT value FROM %Q.'%q_stat' WHERE id=0",
124958: /* 23 */ "REPLACE INTO %Q.'%q_stat' VALUES(0,?)",
124959: /* 24 */ "",
124960: /* 25 */ "",
124961:
124962: /* 26 */ "DELETE FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?",
124963:
124964: };
124965: int rc = SQLITE_OK;
124966: sqlite3_stmt *pStmt;
124967:
124968: assert( SizeofArray(azSql)==SizeofArray(p->aStmt) );
124969: assert( eStmt<SizeofArray(azSql) && eStmt>=0 );
124970:
124971: pStmt = p->aStmt[eStmt];
124972: if( !pStmt ){
124973: char *zSql;
124974: if( eStmt==SQL_CONTENT_INSERT ){
124975: zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
124976: }else if( eStmt==SQL_SELECT_CONTENT_BY_ROWID ){
124977: zSql = sqlite3_mprintf(azSql[eStmt], p->zReadExprlist);
124978: }else{
124979: zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
124980: }
124981: if( !zSql ){
124982: rc = SQLITE_NOMEM;
124983: }else{
124984: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, NULL);
124985: sqlite3_free(zSql);
124986: assert( rc==SQLITE_OK || pStmt==0 );
124987: p->aStmt[eStmt] = pStmt;
124988: }
124989: }
124990: if( apVal ){
124991: int i;
124992: int nParam = sqlite3_bind_parameter_count(pStmt);
124993: for(i=0; rc==SQLITE_OK && i<nParam; i++){
124994: rc = sqlite3_bind_value(pStmt, i+1, apVal[i]);
124995: }
124996: }
124997: *pp = pStmt;
124998: return rc;
124999: }
125000:
125001: static int fts3SelectDocsize(
125002: Fts3Table *pTab, /* FTS3 table handle */
125003: int eStmt, /* Either SQL_SELECT_DOCSIZE or DOCTOTAL */
125004: sqlite3_int64 iDocid, /* Docid to bind for SQL_SELECT_DOCSIZE */
125005: sqlite3_stmt **ppStmt /* OUT: Statement handle */
125006: ){
125007: sqlite3_stmt *pStmt = 0; /* Statement requested from fts3SqlStmt() */
125008: int rc; /* Return code */
125009:
125010: assert( eStmt==SQL_SELECT_DOCSIZE || eStmt==SQL_SELECT_DOCTOTAL );
125011:
125012: rc = fts3SqlStmt(pTab, eStmt, &pStmt, 0);
125013: if( rc==SQLITE_OK ){
125014: if( eStmt==SQL_SELECT_DOCSIZE ){
125015: sqlite3_bind_int64(pStmt, 1, iDocid);
125016: }
125017: rc = sqlite3_step(pStmt);
125018: if( rc!=SQLITE_ROW || sqlite3_column_type(pStmt, 0)!=SQLITE_BLOB ){
125019: rc = sqlite3_reset(pStmt);
125020: if( rc==SQLITE_OK ) rc = FTS_CORRUPT_VTAB;
125021: pStmt = 0;
125022: }else{
125023: rc = SQLITE_OK;
125024: }
125025: }
125026:
125027: *ppStmt = pStmt;
125028: return rc;
125029: }
125030:
125031: SQLITE_PRIVATE int sqlite3Fts3SelectDoctotal(
125032: Fts3Table *pTab, /* Fts3 table handle */
125033: sqlite3_stmt **ppStmt /* OUT: Statement handle */
125034: ){
125035: return fts3SelectDocsize(pTab, SQL_SELECT_DOCTOTAL, 0, ppStmt);
125036: }
125037:
125038: SQLITE_PRIVATE int sqlite3Fts3SelectDocsize(
125039: Fts3Table *pTab, /* Fts3 table handle */
125040: sqlite3_int64 iDocid, /* Docid to read size data for */
125041: sqlite3_stmt **ppStmt /* OUT: Statement handle */
125042: ){
125043: return fts3SelectDocsize(pTab, SQL_SELECT_DOCSIZE, iDocid, ppStmt);
125044: }
125045:
125046: /*
125047: ** Similar to fts3SqlStmt(). Except, after binding the parameters in
125048: ** array apVal[] to the SQL statement identified by eStmt, the statement
125049: ** is executed.
125050: **
125051: ** Returns SQLITE_OK if the statement is successfully executed, or an
125052: ** SQLite error code otherwise.
125053: */
125054: static void fts3SqlExec(
125055: int *pRC, /* Result code */
125056: Fts3Table *p, /* The FTS3 table */
125057: int eStmt, /* Index of statement to evaluate */
125058: sqlite3_value **apVal /* Parameters to bind */
125059: ){
125060: sqlite3_stmt *pStmt;
125061: int rc;
125062: if( *pRC ) return;
125063: rc = fts3SqlStmt(p, eStmt, &pStmt, apVal);
125064: if( rc==SQLITE_OK ){
125065: sqlite3_step(pStmt);
125066: rc = sqlite3_reset(pStmt);
125067: }
125068: *pRC = rc;
125069: }
125070:
125071:
125072: /*
125073: ** This function ensures that the caller has obtained a shared-cache
125074: ** table-lock on the %_content table. This is required before reading
125075: ** data from the fts3 table. If this lock is not acquired first, then
125076: ** the caller may end up holding read-locks on the %_segments and %_segdir
125077: ** tables, but no read-lock on the %_content table. If this happens
125078: ** a second connection will be able to write to the fts3 table, but
125079: ** attempting to commit those writes might return SQLITE_LOCKED or
125080: ** SQLITE_LOCKED_SHAREDCACHE (because the commit attempts to obtain
125081: ** write-locks on the %_segments and %_segdir ** tables).
125082: **
125083: ** We try to avoid this because if FTS3 returns any error when committing
125084: ** a transaction, the whole transaction will be rolled back. And this is
125085: ** not what users expect when they get SQLITE_LOCKED_SHAREDCACHE. It can
125086: ** still happen if the user reads data directly from the %_segments or
125087: ** %_segdir tables instead of going through FTS3 though.
125088: **
125089: ** This reasoning does not apply to a content=xxx table.
125090: */
125091: SQLITE_PRIVATE int sqlite3Fts3ReadLock(Fts3Table *p){
125092: int rc; /* Return code */
125093: sqlite3_stmt *pStmt; /* Statement used to obtain lock */
125094:
125095: if( p->zContentTbl==0 ){
125096: rc = fts3SqlStmt(p, SQL_SELECT_CONTENT_BY_ROWID, &pStmt, 0);
125097: if( rc==SQLITE_OK ){
125098: sqlite3_bind_null(pStmt, 1);
125099: sqlite3_step(pStmt);
125100: rc = sqlite3_reset(pStmt);
125101: }
125102: }else{
125103: rc = SQLITE_OK;
125104: }
125105:
125106: return rc;
125107: }
125108:
125109: /*
125110: ** Set *ppStmt to a statement handle that may be used to iterate through
125111: ** all rows in the %_segdir table, from oldest to newest. If successful,
125112: ** return SQLITE_OK. If an error occurs while preparing the statement,
125113: ** return an SQLite error code.
125114: **
125115: ** There is only ever one instance of this SQL statement compiled for
125116: ** each FTS3 table.
125117: **
125118: ** The statement returns the following columns from the %_segdir table:
125119: **
125120: ** 0: idx
125121: ** 1: start_block
125122: ** 2: leaves_end_block
125123: ** 3: end_block
125124: ** 4: root
125125: */
125126: SQLITE_PRIVATE int sqlite3Fts3AllSegdirs(
125127: Fts3Table *p, /* FTS3 table */
125128: int iIndex, /* Index for p->aIndex[] */
125129: int iLevel, /* Level to select */
125130: sqlite3_stmt **ppStmt /* OUT: Compiled statement */
125131: ){
125132: int rc;
125133: sqlite3_stmt *pStmt = 0;
125134:
125135: assert( iLevel==FTS3_SEGCURSOR_ALL || iLevel>=0 );
125136: assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
125137: assert( iIndex>=0 && iIndex<p->nIndex );
125138:
125139: if( iLevel<0 ){
125140: /* "SELECT * FROM %_segdir WHERE level BETWEEN ? AND ? ORDER BY ..." */
125141: rc = fts3SqlStmt(p, SQL_SELECT_LEVEL_RANGE, &pStmt, 0);
125142: if( rc==SQLITE_OK ){
125143: sqlite3_bind_int(pStmt, 1, iIndex*FTS3_SEGDIR_MAXLEVEL);
125144: sqlite3_bind_int(pStmt, 2, (iIndex+1)*FTS3_SEGDIR_MAXLEVEL-1);
125145: }
125146: }else{
125147: /* "SELECT * FROM %_segdir WHERE level = ? ORDER BY ..." */
125148: rc = fts3SqlStmt(p, SQL_SELECT_LEVEL, &pStmt, 0);
125149: if( rc==SQLITE_OK ){
125150: sqlite3_bind_int(pStmt, 1, iLevel+iIndex*FTS3_SEGDIR_MAXLEVEL);
125151: }
125152: }
125153: *ppStmt = pStmt;
125154: return rc;
125155: }
125156:
125157:
125158: /*
125159: ** Append a single varint to a PendingList buffer. SQLITE_OK is returned
125160: ** if successful, or an SQLite error code otherwise.
125161: **
125162: ** This function also serves to allocate the PendingList structure itself.
125163: ** For example, to create a new PendingList structure containing two
125164: ** varints:
125165: **
125166: ** PendingList *p = 0;
125167: ** fts3PendingListAppendVarint(&p, 1);
125168: ** fts3PendingListAppendVarint(&p, 2);
125169: */
125170: static int fts3PendingListAppendVarint(
125171: PendingList **pp, /* IN/OUT: Pointer to PendingList struct */
125172: sqlite3_int64 i /* Value to append to data */
125173: ){
125174: PendingList *p = *pp;
125175:
125176: /* Allocate or grow the PendingList as required. */
125177: if( !p ){
125178: p = sqlite3_malloc(sizeof(*p) + 100);
125179: if( !p ){
125180: return SQLITE_NOMEM;
125181: }
125182: p->nSpace = 100;
125183: p->aData = (char *)&p[1];
125184: p->nData = 0;
125185: }
125186: else if( p->nData+FTS3_VARINT_MAX+1>p->nSpace ){
125187: int nNew = p->nSpace * 2;
125188: p = sqlite3_realloc(p, sizeof(*p) + nNew);
125189: if( !p ){
125190: sqlite3_free(*pp);
125191: *pp = 0;
125192: return SQLITE_NOMEM;
125193: }
125194: p->nSpace = nNew;
125195: p->aData = (char *)&p[1];
125196: }
125197:
125198: /* Append the new serialized varint to the end of the list. */
125199: p->nData += sqlite3Fts3PutVarint(&p->aData[p->nData], i);
125200: p->aData[p->nData] = '\0';
125201: *pp = p;
125202: return SQLITE_OK;
125203: }
125204:
125205: /*
125206: ** Add a docid/column/position entry to a PendingList structure. Non-zero
125207: ** is returned if the structure is sqlite3_realloced as part of adding
125208: ** the entry. Otherwise, zero.
125209: **
125210: ** If an OOM error occurs, *pRc is set to SQLITE_NOMEM before returning.
125211: ** Zero is always returned in this case. Otherwise, if no OOM error occurs,
125212: ** it is set to SQLITE_OK.
125213: */
125214: static int fts3PendingListAppend(
125215: PendingList **pp, /* IN/OUT: PendingList structure */
125216: sqlite3_int64 iDocid, /* Docid for entry to add */
125217: sqlite3_int64 iCol, /* Column for entry to add */
125218: sqlite3_int64 iPos, /* Position of term for entry to add */
125219: int *pRc /* OUT: Return code */
125220: ){
125221: PendingList *p = *pp;
125222: int rc = SQLITE_OK;
125223:
125224: assert( !p || p->iLastDocid<=iDocid );
125225:
125226: if( !p || p->iLastDocid!=iDocid ){
125227: sqlite3_int64 iDelta = iDocid - (p ? p->iLastDocid : 0);
125228: if( p ){
125229: assert( p->nData<p->nSpace );
125230: assert( p->aData[p->nData]==0 );
125231: p->nData++;
125232: }
125233: if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iDelta)) ){
125234: goto pendinglistappend_out;
125235: }
125236: p->iLastCol = -1;
125237: p->iLastPos = 0;
125238: p->iLastDocid = iDocid;
125239: }
125240: if( iCol>0 && p->iLastCol!=iCol ){
125241: if( SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, 1))
125242: || SQLITE_OK!=(rc = fts3PendingListAppendVarint(&p, iCol))
125243: ){
125244: goto pendinglistappend_out;
125245: }
125246: p->iLastCol = iCol;
125247: p->iLastPos = 0;
125248: }
125249: if( iCol>=0 ){
125250: assert( iPos>p->iLastPos || (iPos==0 && p->iLastPos==0) );
125251: rc = fts3PendingListAppendVarint(&p, 2+iPos-p->iLastPos);
125252: if( rc==SQLITE_OK ){
125253: p->iLastPos = iPos;
125254: }
125255: }
125256:
125257: pendinglistappend_out:
125258: *pRc = rc;
125259: if( p!=*pp ){
125260: *pp = p;
125261: return 1;
125262: }
125263: return 0;
125264: }
125265:
125266: /*
125267: ** Free a PendingList object allocated by fts3PendingListAppend().
125268: */
125269: static void fts3PendingListDelete(PendingList *pList){
125270: sqlite3_free(pList);
125271: }
125272:
125273: /*
125274: ** Add an entry to one of the pending-terms hash tables.
125275: */
125276: static int fts3PendingTermsAddOne(
125277: Fts3Table *p,
125278: int iCol,
125279: int iPos,
125280: Fts3Hash *pHash, /* Pending terms hash table to add entry to */
125281: const char *zToken,
125282: int nToken
125283: ){
125284: PendingList *pList;
125285: int rc = SQLITE_OK;
125286:
125287: pList = (PendingList *)fts3HashFind(pHash, zToken, nToken);
125288: if( pList ){
125289: p->nPendingData -= (pList->nData + nToken + sizeof(Fts3HashElem));
125290: }
125291: if( fts3PendingListAppend(&pList, p->iPrevDocid, iCol, iPos, &rc) ){
125292: if( pList==fts3HashInsert(pHash, zToken, nToken, pList) ){
125293: /* Malloc failed while inserting the new entry. This can only
125294: ** happen if there was no previous entry for this token.
125295: */
125296: assert( 0==fts3HashFind(pHash, zToken, nToken) );
125297: sqlite3_free(pList);
125298: rc = SQLITE_NOMEM;
125299: }
125300: }
125301: if( rc==SQLITE_OK ){
125302: p->nPendingData += (pList->nData + nToken + sizeof(Fts3HashElem));
125303: }
125304: return rc;
125305: }
125306:
125307: /*
125308: ** Tokenize the nul-terminated string zText and add all tokens to the
125309: ** pending-terms hash-table. The docid used is that currently stored in
125310: ** p->iPrevDocid, and the column is specified by argument iCol.
125311: **
125312: ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
125313: */
125314: static int fts3PendingTermsAdd(
125315: Fts3Table *p, /* Table into which text will be inserted */
125316: const char *zText, /* Text of document to be inserted */
125317: int iCol, /* Column into which text is being inserted */
125318: u32 *pnWord /* OUT: Number of tokens inserted */
125319: ){
125320: int rc;
125321: int iStart;
125322: int iEnd;
125323: int iPos;
125324: int nWord = 0;
125325:
125326: char const *zToken;
125327: int nToken;
125328:
125329: sqlite3_tokenizer *pTokenizer = p->pTokenizer;
125330: sqlite3_tokenizer_module const *pModule = pTokenizer->pModule;
125331: sqlite3_tokenizer_cursor *pCsr;
125332: int (*xNext)(sqlite3_tokenizer_cursor *pCursor,
125333: const char**,int*,int*,int*,int*);
125334:
125335: assert( pTokenizer && pModule );
125336:
125337: /* If the user has inserted a NULL value, this function may be called with
125338: ** zText==0. In this case, add zero token entries to the hash table and
125339: ** return early. */
125340: if( zText==0 ){
125341: *pnWord = 0;
125342: return SQLITE_OK;
125343: }
125344:
125345: rc = pModule->xOpen(pTokenizer, zText, -1, &pCsr);
125346: if( rc!=SQLITE_OK ){
125347: return rc;
125348: }
125349: pCsr->pTokenizer = pTokenizer;
125350:
125351: xNext = pModule->xNext;
125352: while( SQLITE_OK==rc
125353: && SQLITE_OK==(rc = xNext(pCsr, &zToken, &nToken, &iStart, &iEnd, &iPos))
125354: ){
125355: int i;
125356: if( iPos>=nWord ) nWord = iPos+1;
125357:
125358: /* Positions cannot be negative; we use -1 as a terminator internally.
125359: ** Tokens must have a non-zero length.
125360: */
125361: if( iPos<0 || !zToken || nToken<=0 ){
125362: rc = SQLITE_ERROR;
125363: break;
125364: }
125365:
125366: /* Add the term to the terms index */
125367: rc = fts3PendingTermsAddOne(
125368: p, iCol, iPos, &p->aIndex[0].hPending, zToken, nToken
125369: );
125370:
125371: /* Add the term to each of the prefix indexes that it is not too
125372: ** short for. */
125373: for(i=1; rc==SQLITE_OK && i<p->nIndex; i++){
125374: struct Fts3Index *pIndex = &p->aIndex[i];
125375: if( nToken<pIndex->nPrefix ) continue;
125376: rc = fts3PendingTermsAddOne(
125377: p, iCol, iPos, &pIndex->hPending, zToken, pIndex->nPrefix
125378: );
125379: }
125380: }
125381:
125382: pModule->xClose(pCsr);
125383: *pnWord = nWord;
125384: return (rc==SQLITE_DONE ? SQLITE_OK : rc);
125385: }
125386:
125387: /*
125388: ** Calling this function indicates that subsequent calls to
125389: ** fts3PendingTermsAdd() are to add term/position-list pairs for the
125390: ** contents of the document with docid iDocid.
125391: */
125392: static int fts3PendingTermsDocid(Fts3Table *p, sqlite_int64 iDocid){
125393: /* TODO(shess) Explore whether partially flushing the buffer on
125394: ** forced-flush would provide better performance. I suspect that if
125395: ** we ordered the doclists by size and flushed the largest until the
125396: ** buffer was half empty, that would let the less frequent terms
125397: ** generate longer doclists.
125398: */
125399: if( iDocid<=p->iPrevDocid || p->nPendingData>p->nMaxPendingData ){
125400: int rc = sqlite3Fts3PendingTermsFlush(p);
125401: if( rc!=SQLITE_OK ) return rc;
125402: }
125403: p->iPrevDocid = iDocid;
125404: return SQLITE_OK;
125405: }
125406:
125407: /*
125408: ** Discard the contents of the pending-terms hash tables.
125409: */
125410: SQLITE_PRIVATE void sqlite3Fts3PendingTermsClear(Fts3Table *p){
125411: int i;
125412: for(i=0; i<p->nIndex; i++){
125413: Fts3HashElem *pElem;
125414: Fts3Hash *pHash = &p->aIndex[i].hPending;
125415: for(pElem=fts3HashFirst(pHash); pElem; pElem=fts3HashNext(pElem)){
125416: PendingList *pList = (PendingList *)fts3HashData(pElem);
125417: fts3PendingListDelete(pList);
125418: }
125419: fts3HashClear(pHash);
125420: }
125421: p->nPendingData = 0;
125422: }
125423:
125424: /*
125425: ** This function is called by the xUpdate() method as part of an INSERT
125426: ** operation. It adds entries for each term in the new record to the
125427: ** pendingTerms hash table.
125428: **
125429: ** Argument apVal is the same as the similarly named argument passed to
125430: ** fts3InsertData(). Parameter iDocid is the docid of the new row.
125431: */
125432: static int fts3InsertTerms(Fts3Table *p, sqlite3_value **apVal, u32 *aSz){
125433: int i; /* Iterator variable */
125434: for(i=2; i<p->nColumn+2; i++){
125435: const char *zText = (const char *)sqlite3_value_text(apVal[i]);
125436: int rc = fts3PendingTermsAdd(p, zText, i-2, &aSz[i-2]);
125437: if( rc!=SQLITE_OK ){
125438: return rc;
125439: }
125440: aSz[p->nColumn] += sqlite3_value_bytes(apVal[i]);
125441: }
125442: return SQLITE_OK;
125443: }
125444:
125445: /*
125446: ** This function is called by the xUpdate() method for an INSERT operation.
125447: ** The apVal parameter is passed a copy of the apVal argument passed by
125448: ** SQLite to the xUpdate() method. i.e:
125449: **
125450: ** apVal[0] Not used for INSERT.
125451: ** apVal[1] rowid
125452: ** apVal[2] Left-most user-defined column
125453: ** ...
125454: ** apVal[p->nColumn+1] Right-most user-defined column
125455: ** apVal[p->nColumn+2] Hidden column with same name as table
125456: ** apVal[p->nColumn+3] Hidden "docid" column (alias for rowid)
125457: */
125458: static int fts3InsertData(
125459: Fts3Table *p, /* Full-text table */
125460: sqlite3_value **apVal, /* Array of values to insert */
125461: sqlite3_int64 *piDocid /* OUT: Docid for row just inserted */
125462: ){
125463: int rc; /* Return code */
125464: sqlite3_stmt *pContentInsert; /* INSERT INTO %_content VALUES(...) */
125465:
125466: if( p->zContentTbl ){
125467: sqlite3_value *pRowid = apVal[p->nColumn+3];
125468: if( sqlite3_value_type(pRowid)==SQLITE_NULL ){
125469: pRowid = apVal[1];
125470: }
125471: if( sqlite3_value_type(pRowid)!=SQLITE_INTEGER ){
125472: return SQLITE_CONSTRAINT;
125473: }
125474: *piDocid = sqlite3_value_int64(pRowid);
125475: return SQLITE_OK;
125476: }
125477:
125478: /* Locate the statement handle used to insert data into the %_content
125479: ** table. The SQL for this statement is:
125480: **
125481: ** INSERT INTO %_content VALUES(?, ?, ?, ...)
125482: **
125483: ** The statement features N '?' variables, where N is the number of user
125484: ** defined columns in the FTS3 table, plus one for the docid field.
125485: */
125486: rc = fts3SqlStmt(p, SQL_CONTENT_INSERT, &pContentInsert, &apVal[1]);
125487: if( rc!=SQLITE_OK ){
125488: return rc;
125489: }
125490:
125491: /* There is a quirk here. The users INSERT statement may have specified
125492: ** a value for the "rowid" field, for the "docid" field, or for both.
125493: ** Which is a problem, since "rowid" and "docid" are aliases for the
125494: ** same value. For example:
125495: **
125496: ** INSERT INTO fts3tbl(rowid, docid) VALUES(1, 2);
125497: **
125498: ** In FTS3, this is an error. It is an error to specify non-NULL values
125499: ** for both docid and some other rowid alias.
125500: */
125501: if( SQLITE_NULL!=sqlite3_value_type(apVal[3+p->nColumn]) ){
125502: if( SQLITE_NULL==sqlite3_value_type(apVal[0])
125503: && SQLITE_NULL!=sqlite3_value_type(apVal[1])
125504: ){
125505: /* A rowid/docid conflict. */
125506: return SQLITE_ERROR;
125507: }
125508: rc = sqlite3_bind_value(pContentInsert, 1, apVal[3+p->nColumn]);
125509: if( rc!=SQLITE_OK ) return rc;
125510: }
125511:
125512: /* Execute the statement to insert the record. Set *piDocid to the
125513: ** new docid value.
125514: */
125515: sqlite3_step(pContentInsert);
125516: rc = sqlite3_reset(pContentInsert);
125517:
125518: *piDocid = sqlite3_last_insert_rowid(p->db);
125519: return rc;
125520: }
125521:
125522:
125523:
125524: /*
125525: ** Remove all data from the FTS3 table. Clear the hash table containing
125526: ** pending terms.
125527: */
125528: static int fts3DeleteAll(Fts3Table *p, int bContent){
125529: int rc = SQLITE_OK; /* Return code */
125530:
125531: /* Discard the contents of the pending-terms hash table. */
125532: sqlite3Fts3PendingTermsClear(p);
125533:
125534: /* Delete everything from the shadow tables. Except, leave %_content as
125535: ** is if bContent is false. */
125536: assert( p->zContentTbl==0 || bContent==0 );
125537: if( bContent ) fts3SqlExec(&rc, p, SQL_DELETE_ALL_CONTENT, 0);
125538: fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGMENTS, 0);
125539: fts3SqlExec(&rc, p, SQL_DELETE_ALL_SEGDIR, 0);
125540: if( p->bHasDocsize ){
125541: fts3SqlExec(&rc, p, SQL_DELETE_ALL_DOCSIZE, 0);
125542: }
125543: if( p->bHasStat ){
125544: fts3SqlExec(&rc, p, SQL_DELETE_ALL_STAT, 0);
125545: }
125546: return rc;
125547: }
125548:
125549: /*
125550: ** The first element in the apVal[] array is assumed to contain the docid
125551: ** (an integer) of a row about to be deleted. Remove all terms from the
125552: ** full-text index.
125553: */
125554: static void fts3DeleteTerms(
125555: int *pRC, /* Result code */
125556: Fts3Table *p, /* The FTS table to delete from */
125557: sqlite3_value *pRowid, /* The docid to be deleted */
125558: u32 *aSz /* Sizes of deleted document written here */
125559: ){
125560: int rc;
125561: sqlite3_stmt *pSelect;
125562:
125563: if( *pRC ) return;
125564: rc = fts3SqlStmt(p, SQL_SELECT_CONTENT_BY_ROWID, &pSelect, &pRowid);
125565: if( rc==SQLITE_OK ){
125566: if( SQLITE_ROW==sqlite3_step(pSelect) ){
125567: int i;
125568: for(i=1; i<=p->nColumn; i++){
125569: const char *zText = (const char *)sqlite3_column_text(pSelect, i);
125570: rc = fts3PendingTermsAdd(p, zText, -1, &aSz[i-1]);
125571: if( rc!=SQLITE_OK ){
125572: sqlite3_reset(pSelect);
125573: *pRC = rc;
125574: return;
125575: }
125576: aSz[p->nColumn] += sqlite3_column_bytes(pSelect, i);
125577: }
125578: }
125579: rc = sqlite3_reset(pSelect);
125580: }else{
125581: sqlite3_reset(pSelect);
125582: }
125583: *pRC = rc;
125584: }
125585:
125586: /*
125587: ** Forward declaration to account for the circular dependency between
125588: ** functions fts3SegmentMerge() and fts3AllocateSegdirIdx().
125589: */
125590: static int fts3SegmentMerge(Fts3Table *, int, int);
125591:
125592: /*
125593: ** This function allocates a new level iLevel index in the segdir table.
125594: ** Usually, indexes are allocated within a level sequentially starting
125595: ** with 0, so the allocated index is one greater than the value returned
125596: ** by:
125597: **
125598: ** SELECT max(idx) FROM %_segdir WHERE level = :iLevel
125599: **
125600: ** However, if there are already FTS3_MERGE_COUNT indexes at the requested
125601: ** level, they are merged into a single level (iLevel+1) segment and the
125602: ** allocated index is 0.
125603: **
125604: ** If successful, *piIdx is set to the allocated index slot and SQLITE_OK
125605: ** returned. Otherwise, an SQLite error code is returned.
125606: */
125607: static int fts3AllocateSegdirIdx(
125608: Fts3Table *p,
125609: int iIndex, /* Index for p->aIndex */
125610: int iLevel,
125611: int *piIdx
125612: ){
125613: int rc; /* Return Code */
125614: sqlite3_stmt *pNextIdx; /* Query for next idx at level iLevel */
125615: int iNext = 0; /* Result of query pNextIdx */
125616:
125617: /* Set variable iNext to the next available segdir index at level iLevel. */
125618: rc = fts3SqlStmt(p, SQL_NEXT_SEGMENT_INDEX, &pNextIdx, 0);
125619: if( rc==SQLITE_OK ){
125620: sqlite3_bind_int(pNextIdx, 1, iIndex*FTS3_SEGDIR_MAXLEVEL + iLevel);
125621: if( SQLITE_ROW==sqlite3_step(pNextIdx) ){
125622: iNext = sqlite3_column_int(pNextIdx, 0);
125623: }
125624: rc = sqlite3_reset(pNextIdx);
125625: }
125626:
125627: if( rc==SQLITE_OK ){
125628: /* If iNext is FTS3_MERGE_COUNT, indicating that level iLevel is already
125629: ** full, merge all segments in level iLevel into a single iLevel+1
125630: ** segment and allocate (newly freed) index 0 at level iLevel. Otherwise,
125631: ** if iNext is less than FTS3_MERGE_COUNT, allocate index iNext.
125632: */
125633: if( iNext>=FTS3_MERGE_COUNT ){
125634: rc = fts3SegmentMerge(p, iIndex, iLevel);
125635: *piIdx = 0;
125636: }else{
125637: *piIdx = iNext;
125638: }
125639: }
125640:
125641: return rc;
125642: }
125643:
125644: /*
125645: ** The %_segments table is declared as follows:
125646: **
125647: ** CREATE TABLE %_segments(blockid INTEGER PRIMARY KEY, block BLOB)
125648: **
125649: ** This function reads data from a single row of the %_segments table. The
125650: ** specific row is identified by the iBlockid parameter. If paBlob is not
125651: ** NULL, then a buffer is allocated using sqlite3_malloc() and populated
125652: ** with the contents of the blob stored in the "block" column of the
125653: ** identified table row is. Whether or not paBlob is NULL, *pnBlob is set
125654: ** to the size of the blob in bytes before returning.
125655: **
125656: ** If an error occurs, or the table does not contain the specified row,
125657: ** an SQLite error code is returned. Otherwise, SQLITE_OK is returned. If
125658: ** paBlob is non-NULL, then it is the responsibility of the caller to
125659: ** eventually free the returned buffer.
125660: **
125661: ** This function may leave an open sqlite3_blob* handle in the
125662: ** Fts3Table.pSegments variable. This handle is reused by subsequent calls
125663: ** to this function. The handle may be closed by calling the
125664: ** sqlite3Fts3SegmentsClose() function. Reusing a blob handle is a handy
125665: ** performance improvement, but the blob handle should always be closed
125666: ** before control is returned to the user (to prevent a lock being held
125667: ** on the database file for longer than necessary). Thus, any virtual table
125668: ** method (xFilter etc.) that may directly or indirectly call this function
125669: ** must call sqlite3Fts3SegmentsClose() before returning.
125670: */
125671: SQLITE_PRIVATE int sqlite3Fts3ReadBlock(
125672: Fts3Table *p, /* FTS3 table handle */
125673: sqlite3_int64 iBlockid, /* Access the row with blockid=$iBlockid */
125674: char **paBlob, /* OUT: Blob data in malloc'd buffer */
125675: int *pnBlob, /* OUT: Size of blob data */
125676: int *pnLoad /* OUT: Bytes actually loaded */
125677: ){
125678: int rc; /* Return code */
125679:
125680: /* pnBlob must be non-NULL. paBlob may be NULL or non-NULL. */
125681: assert( pnBlob);
125682:
125683: if( p->pSegments ){
125684: rc = sqlite3_blob_reopen(p->pSegments, iBlockid);
125685: }else{
125686: if( 0==p->zSegmentsTbl ){
125687: p->zSegmentsTbl = sqlite3_mprintf("%s_segments", p->zName);
125688: if( 0==p->zSegmentsTbl ) return SQLITE_NOMEM;
125689: }
125690: rc = sqlite3_blob_open(
125691: p->db, p->zDb, p->zSegmentsTbl, "block", iBlockid, 0, &p->pSegments
125692: );
125693: }
125694:
125695: if( rc==SQLITE_OK ){
125696: int nByte = sqlite3_blob_bytes(p->pSegments);
125697: *pnBlob = nByte;
125698: if( paBlob ){
125699: char *aByte = sqlite3_malloc(nByte + FTS3_NODE_PADDING);
125700: if( !aByte ){
125701: rc = SQLITE_NOMEM;
125702: }else{
125703: if( pnLoad && nByte>(FTS3_NODE_CHUNK_THRESHOLD) ){
125704: nByte = FTS3_NODE_CHUNKSIZE;
125705: *pnLoad = nByte;
125706: }
125707: rc = sqlite3_blob_read(p->pSegments, aByte, nByte, 0);
125708: memset(&aByte[nByte], 0, FTS3_NODE_PADDING);
125709: if( rc!=SQLITE_OK ){
125710: sqlite3_free(aByte);
125711: aByte = 0;
125712: }
125713: }
125714: *paBlob = aByte;
125715: }
125716: }
125717:
125718: return rc;
125719: }
125720:
125721: /*
125722: ** Close the blob handle at p->pSegments, if it is open. See comments above
125723: ** the sqlite3Fts3ReadBlock() function for details.
125724: */
125725: SQLITE_PRIVATE void sqlite3Fts3SegmentsClose(Fts3Table *p){
125726: sqlite3_blob_close(p->pSegments);
125727: p->pSegments = 0;
125728: }
125729:
125730: static int fts3SegReaderIncrRead(Fts3SegReader *pReader){
125731: int nRead; /* Number of bytes to read */
125732: int rc; /* Return code */
125733:
125734: nRead = MIN(pReader->nNode - pReader->nPopulate, FTS3_NODE_CHUNKSIZE);
125735: rc = sqlite3_blob_read(
125736: pReader->pBlob,
125737: &pReader->aNode[pReader->nPopulate],
125738: nRead,
125739: pReader->nPopulate
125740: );
125741:
125742: if( rc==SQLITE_OK ){
125743: pReader->nPopulate += nRead;
125744: memset(&pReader->aNode[pReader->nPopulate], 0, FTS3_NODE_PADDING);
125745: if( pReader->nPopulate==pReader->nNode ){
125746: sqlite3_blob_close(pReader->pBlob);
125747: pReader->pBlob = 0;
125748: pReader->nPopulate = 0;
125749: }
125750: }
125751: return rc;
125752: }
125753:
125754: static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){
125755: int rc = SQLITE_OK;
125756: assert( !pReader->pBlob
125757: || (pFrom>=pReader->aNode && pFrom<&pReader->aNode[pReader->nNode])
125758: );
125759: while( pReader->pBlob && rc==SQLITE_OK
125760: && (pFrom - pReader->aNode + nByte)>pReader->nPopulate
125761: ){
125762: rc = fts3SegReaderIncrRead(pReader);
125763: }
125764: return rc;
125765: }
125766:
125767: /*
125768: ** Move the iterator passed as the first argument to the next term in the
125769: ** segment. If successful, SQLITE_OK is returned. If there is no next term,
125770: ** SQLITE_DONE. Otherwise, an SQLite error code.
125771: */
125772: static int fts3SegReaderNext(
125773: Fts3Table *p,
125774: Fts3SegReader *pReader,
125775: int bIncr
125776: ){
125777: int rc; /* Return code of various sub-routines */
125778: char *pNext; /* Cursor variable */
125779: int nPrefix; /* Number of bytes in term prefix */
125780: int nSuffix; /* Number of bytes in term suffix */
125781:
125782: if( !pReader->aDoclist ){
125783: pNext = pReader->aNode;
125784: }else{
125785: pNext = &pReader->aDoclist[pReader->nDoclist];
125786: }
125787:
125788: if( !pNext || pNext>=&pReader->aNode[pReader->nNode] ){
125789:
125790: if( fts3SegReaderIsPending(pReader) ){
125791: Fts3HashElem *pElem = *(pReader->ppNextElem);
125792: if( pElem==0 ){
125793: pReader->aNode = 0;
125794: }else{
125795: PendingList *pList = (PendingList *)fts3HashData(pElem);
125796: pReader->zTerm = (char *)fts3HashKey(pElem);
125797: pReader->nTerm = fts3HashKeysize(pElem);
125798: pReader->nNode = pReader->nDoclist = pList->nData + 1;
125799: pReader->aNode = pReader->aDoclist = pList->aData;
125800: pReader->ppNextElem++;
125801: assert( pReader->aNode );
125802: }
125803: return SQLITE_OK;
125804: }
125805:
125806: if( !fts3SegReaderIsRootOnly(pReader) ){
125807: sqlite3_free(pReader->aNode);
125808: sqlite3_blob_close(pReader->pBlob);
125809: pReader->pBlob = 0;
125810: }
125811: pReader->aNode = 0;
125812:
125813: /* If iCurrentBlock>=iLeafEndBlock, this is an EOF condition. All leaf
125814: ** blocks have already been traversed. */
125815: assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock );
125816: if( pReader->iCurrentBlock>=pReader->iLeafEndBlock ){
125817: return SQLITE_OK;
125818: }
125819:
125820: rc = sqlite3Fts3ReadBlock(
125821: p, ++pReader->iCurrentBlock, &pReader->aNode, &pReader->nNode,
125822: (bIncr ? &pReader->nPopulate : 0)
125823: );
125824: if( rc!=SQLITE_OK ) return rc;
125825: assert( pReader->pBlob==0 );
125826: if( bIncr && pReader->nPopulate<pReader->nNode ){
125827: pReader->pBlob = p->pSegments;
125828: p->pSegments = 0;
125829: }
125830: pNext = pReader->aNode;
125831: }
125832:
125833: assert( !fts3SegReaderIsPending(pReader) );
125834:
125835: rc = fts3SegReaderRequire(pReader, pNext, FTS3_VARINT_MAX*2);
125836: if( rc!=SQLITE_OK ) return rc;
125837:
125838: /* Because of the FTS3_NODE_PADDING bytes of padding, the following is
125839: ** safe (no risk of overread) even if the node data is corrupted. */
125840: pNext += sqlite3Fts3GetVarint32(pNext, &nPrefix);
125841: pNext += sqlite3Fts3GetVarint32(pNext, &nSuffix);
125842: if( nPrefix<0 || nSuffix<=0
125843: || &pNext[nSuffix]>&pReader->aNode[pReader->nNode]
125844: ){
125845: return FTS_CORRUPT_VTAB;
125846: }
125847:
125848: if( nPrefix+nSuffix>pReader->nTermAlloc ){
125849: int nNew = (nPrefix+nSuffix)*2;
125850: char *zNew = sqlite3_realloc(pReader->zTerm, nNew);
125851: if( !zNew ){
125852: return SQLITE_NOMEM;
125853: }
125854: pReader->zTerm = zNew;
125855: pReader->nTermAlloc = nNew;
125856: }
125857:
125858: rc = fts3SegReaderRequire(pReader, pNext, nSuffix+FTS3_VARINT_MAX);
125859: if( rc!=SQLITE_OK ) return rc;
125860:
125861: memcpy(&pReader->zTerm[nPrefix], pNext, nSuffix);
125862: pReader->nTerm = nPrefix+nSuffix;
125863: pNext += nSuffix;
125864: pNext += sqlite3Fts3GetVarint32(pNext, &pReader->nDoclist);
125865: pReader->aDoclist = pNext;
125866: pReader->pOffsetList = 0;
125867:
125868: /* Check that the doclist does not appear to extend past the end of the
125869: ** b-tree node. And that the final byte of the doclist is 0x00. If either
125870: ** of these statements is untrue, then the data structure is corrupt.
125871: */
125872: if( &pReader->aDoclist[pReader->nDoclist]>&pReader->aNode[pReader->nNode]
125873: || (pReader->nPopulate==0 && pReader->aDoclist[pReader->nDoclist-1])
125874: ){
125875: return FTS_CORRUPT_VTAB;
125876: }
125877: return SQLITE_OK;
125878: }
125879:
125880: /*
125881: ** Set the SegReader to point to the first docid in the doclist associated
125882: ** with the current term.
125883: */
125884: static int fts3SegReaderFirstDocid(Fts3Table *pTab, Fts3SegReader *pReader){
125885: int rc = SQLITE_OK;
125886: assert( pReader->aDoclist );
125887: assert( !pReader->pOffsetList );
125888: if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
125889: u8 bEof = 0;
125890: pReader->iDocid = 0;
125891: pReader->nOffsetList = 0;
125892: sqlite3Fts3DoclistPrev(0,
125893: pReader->aDoclist, pReader->nDoclist, &pReader->pOffsetList,
125894: &pReader->iDocid, &pReader->nOffsetList, &bEof
125895: );
125896: }else{
125897: rc = fts3SegReaderRequire(pReader, pReader->aDoclist, FTS3_VARINT_MAX);
125898: if( rc==SQLITE_OK ){
125899: int n = sqlite3Fts3GetVarint(pReader->aDoclist, &pReader->iDocid);
125900: pReader->pOffsetList = &pReader->aDoclist[n];
125901: }
125902: }
125903: return rc;
125904: }
125905:
125906: /*
125907: ** Advance the SegReader to point to the next docid in the doclist
125908: ** associated with the current term.
125909: **
125910: ** If arguments ppOffsetList and pnOffsetList are not NULL, then
125911: ** *ppOffsetList is set to point to the first column-offset list
125912: ** in the doclist entry (i.e. immediately past the docid varint).
125913: ** *pnOffsetList is set to the length of the set of column-offset
125914: ** lists, not including the nul-terminator byte. For example:
125915: */
125916: static int fts3SegReaderNextDocid(
125917: Fts3Table *pTab,
125918: Fts3SegReader *pReader, /* Reader to advance to next docid */
125919: char **ppOffsetList, /* OUT: Pointer to current position-list */
125920: int *pnOffsetList /* OUT: Length of *ppOffsetList in bytes */
125921: ){
125922: int rc = SQLITE_OK;
125923: char *p = pReader->pOffsetList;
125924: char c = 0;
125925:
125926: assert( p );
125927:
125928: if( pTab->bDescIdx && fts3SegReaderIsPending(pReader) ){
125929: /* A pending-terms seg-reader for an FTS4 table that uses order=desc.
125930: ** Pending-terms doclists are always built up in ascending order, so
125931: ** we have to iterate through them backwards here. */
125932: u8 bEof = 0;
125933: if( ppOffsetList ){
125934: *ppOffsetList = pReader->pOffsetList;
125935: *pnOffsetList = pReader->nOffsetList - 1;
125936: }
125937: sqlite3Fts3DoclistPrev(0,
125938: pReader->aDoclist, pReader->nDoclist, &p, &pReader->iDocid,
125939: &pReader->nOffsetList, &bEof
125940: );
125941: if( bEof ){
125942: pReader->pOffsetList = 0;
125943: }else{
125944: pReader->pOffsetList = p;
125945: }
125946: }else{
125947: char *pEnd = &pReader->aDoclist[pReader->nDoclist];
125948:
125949: /* Pointer p currently points at the first byte of an offset list. The
125950: ** following block advances it to point one byte past the end of
125951: ** the same offset list. */
125952: while( 1 ){
125953:
125954: /* The following line of code (and the "p++" below the while() loop) is
125955: ** normally all that is required to move pointer p to the desired
125956: ** position. The exception is if this node is being loaded from disk
125957: ** incrementally and pointer "p" now points to the first byte passed
125958: ** the populated part of pReader->aNode[].
125959: */
125960: while( *p | c ) c = *p++ & 0x80;
125961: assert( *p==0 );
125962:
125963: if( pReader->pBlob==0 || p<&pReader->aNode[pReader->nPopulate] ) break;
125964: rc = fts3SegReaderIncrRead(pReader);
125965: if( rc!=SQLITE_OK ) return rc;
125966: }
125967: p++;
125968:
125969: /* If required, populate the output variables with a pointer to and the
125970: ** size of the previous offset-list.
125971: */
125972: if( ppOffsetList ){
125973: *ppOffsetList = pReader->pOffsetList;
125974: *pnOffsetList = (int)(p - pReader->pOffsetList - 1);
125975: }
125976:
125977: while( p<pEnd && *p==0 ) p++;
125978:
125979: /* If there are no more entries in the doclist, set pOffsetList to
125980: ** NULL. Otherwise, set Fts3SegReader.iDocid to the next docid and
125981: ** Fts3SegReader.pOffsetList to point to the next offset list before
125982: ** returning.
125983: */
125984: if( p>=pEnd ){
125985: pReader->pOffsetList = 0;
125986: }else{
125987: rc = fts3SegReaderRequire(pReader, p, FTS3_VARINT_MAX);
125988: if( rc==SQLITE_OK ){
125989: sqlite3_int64 iDelta;
125990: pReader->pOffsetList = p + sqlite3Fts3GetVarint(p, &iDelta);
125991: if( pTab->bDescIdx ){
125992: pReader->iDocid -= iDelta;
125993: }else{
125994: pReader->iDocid += iDelta;
125995: }
125996: }
125997: }
125998: }
125999:
126000: return SQLITE_OK;
126001: }
126002:
126003:
126004: SQLITE_PRIVATE int sqlite3Fts3MsrOvfl(
126005: Fts3Cursor *pCsr,
126006: Fts3MultiSegReader *pMsr,
126007: int *pnOvfl
126008: ){
126009: Fts3Table *p = (Fts3Table*)pCsr->base.pVtab;
126010: int nOvfl = 0;
126011: int ii;
126012: int rc = SQLITE_OK;
126013: int pgsz = p->nPgsz;
126014:
126015: assert( p->bHasStat );
126016: assert( pgsz>0 );
126017:
126018: for(ii=0; rc==SQLITE_OK && ii<pMsr->nSegment; ii++){
126019: Fts3SegReader *pReader = pMsr->apSegment[ii];
126020: if( !fts3SegReaderIsPending(pReader)
126021: && !fts3SegReaderIsRootOnly(pReader)
126022: ){
126023: sqlite3_int64 jj;
126024: for(jj=pReader->iStartBlock; jj<=pReader->iLeafEndBlock; jj++){
126025: int nBlob;
126026: rc = sqlite3Fts3ReadBlock(p, jj, 0, &nBlob, 0);
126027: if( rc!=SQLITE_OK ) break;
126028: if( (nBlob+35)>pgsz ){
126029: nOvfl += (nBlob + 34)/pgsz;
126030: }
126031: }
126032: }
126033: }
126034: *pnOvfl = nOvfl;
126035: return rc;
126036: }
126037:
126038: /*
126039: ** Free all allocations associated with the iterator passed as the
126040: ** second argument.
126041: */
126042: SQLITE_PRIVATE void sqlite3Fts3SegReaderFree(Fts3SegReader *pReader){
126043: if( pReader && !fts3SegReaderIsPending(pReader) ){
126044: sqlite3_free(pReader->zTerm);
126045: if( !fts3SegReaderIsRootOnly(pReader) ){
126046: sqlite3_free(pReader->aNode);
126047: sqlite3_blob_close(pReader->pBlob);
126048: }
126049: }
126050: sqlite3_free(pReader);
126051: }
126052:
126053: /*
126054: ** Allocate a new SegReader object.
126055: */
126056: SQLITE_PRIVATE int sqlite3Fts3SegReaderNew(
126057: int iAge, /* Segment "age". */
126058: sqlite3_int64 iStartLeaf, /* First leaf to traverse */
126059: sqlite3_int64 iEndLeaf, /* Final leaf to traverse */
126060: sqlite3_int64 iEndBlock, /* Final block of segment */
126061: const char *zRoot, /* Buffer containing root node */
126062: int nRoot, /* Size of buffer containing root node */
126063: Fts3SegReader **ppReader /* OUT: Allocated Fts3SegReader */
126064: ){
126065: Fts3SegReader *pReader; /* Newly allocated SegReader object */
126066: int nExtra = 0; /* Bytes to allocate segment root node */
126067:
126068: assert( iStartLeaf<=iEndLeaf );
126069: if( iStartLeaf==0 ){
126070: nExtra = nRoot + FTS3_NODE_PADDING;
126071: }
126072:
126073: pReader = (Fts3SegReader *)sqlite3_malloc(sizeof(Fts3SegReader) + nExtra);
126074: if( !pReader ){
126075: return SQLITE_NOMEM;
126076: }
126077: memset(pReader, 0, sizeof(Fts3SegReader));
126078: pReader->iIdx = iAge;
126079: pReader->iStartBlock = iStartLeaf;
126080: pReader->iLeafEndBlock = iEndLeaf;
126081: pReader->iEndBlock = iEndBlock;
126082:
126083: if( nExtra ){
126084: /* The entire segment is stored in the root node. */
126085: pReader->aNode = (char *)&pReader[1];
126086: pReader->nNode = nRoot;
126087: memcpy(pReader->aNode, zRoot, nRoot);
126088: memset(&pReader->aNode[nRoot], 0, FTS3_NODE_PADDING);
126089: }else{
126090: pReader->iCurrentBlock = iStartLeaf-1;
126091: }
126092: *ppReader = pReader;
126093: return SQLITE_OK;
126094: }
126095:
126096: /*
126097: ** This is a comparison function used as a qsort() callback when sorting
126098: ** an array of pending terms by term. This occurs as part of flushing
126099: ** the contents of the pending-terms hash table to the database.
126100: */
126101: static int fts3CompareElemByTerm(const void *lhs, const void *rhs){
126102: char *z1 = fts3HashKey(*(Fts3HashElem **)lhs);
126103: char *z2 = fts3HashKey(*(Fts3HashElem **)rhs);
126104: int n1 = fts3HashKeysize(*(Fts3HashElem **)lhs);
126105: int n2 = fts3HashKeysize(*(Fts3HashElem **)rhs);
126106:
126107: int n = (n1<n2 ? n1 : n2);
126108: int c = memcmp(z1, z2, n);
126109: if( c==0 ){
126110: c = n1 - n2;
126111: }
126112: return c;
126113: }
126114:
126115: /*
126116: ** This function is used to allocate an Fts3SegReader that iterates through
126117: ** a subset of the terms stored in the Fts3Table.pendingTerms array.
126118: **
126119: ** If the isPrefixIter parameter is zero, then the returned SegReader iterates
126120: ** through each term in the pending-terms table. Or, if isPrefixIter is
126121: ** non-zero, it iterates through each term and its prefixes. For example, if
126122: ** the pending terms hash table contains the terms "sqlite", "mysql" and
126123: ** "firebird", then the iterator visits the following 'terms' (in the order
126124: ** shown):
126125: **
126126: ** f fi fir fire fireb firebi firebir firebird
126127: ** m my mys mysq mysql
126128: ** s sq sql sqli sqlit sqlite
126129: **
126130: ** Whereas if isPrefixIter is zero, the terms visited are:
126131: **
126132: ** firebird mysql sqlite
126133: */
126134: SQLITE_PRIVATE int sqlite3Fts3SegReaderPending(
126135: Fts3Table *p, /* Virtual table handle */
126136: int iIndex, /* Index for p->aIndex */
126137: const char *zTerm, /* Term to search for */
126138: int nTerm, /* Size of buffer zTerm */
126139: int bPrefix, /* True for a prefix iterator */
126140: Fts3SegReader **ppReader /* OUT: SegReader for pending-terms */
126141: ){
126142: Fts3SegReader *pReader = 0; /* Fts3SegReader object to return */
126143: Fts3HashElem *pE; /* Iterator variable */
126144: Fts3HashElem **aElem = 0; /* Array of term hash entries to scan */
126145: int nElem = 0; /* Size of array at aElem */
126146: int rc = SQLITE_OK; /* Return Code */
126147: Fts3Hash *pHash;
126148:
126149: pHash = &p->aIndex[iIndex].hPending;
126150: if( bPrefix ){
126151: int nAlloc = 0; /* Size of allocated array at aElem */
126152:
126153: for(pE=fts3HashFirst(pHash); pE; pE=fts3HashNext(pE)){
126154: char *zKey = (char *)fts3HashKey(pE);
126155: int nKey = fts3HashKeysize(pE);
126156: if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){
126157: if( nElem==nAlloc ){
126158: Fts3HashElem **aElem2;
126159: nAlloc += 16;
126160: aElem2 = (Fts3HashElem **)sqlite3_realloc(
126161: aElem, nAlloc*sizeof(Fts3HashElem *)
126162: );
126163: if( !aElem2 ){
126164: rc = SQLITE_NOMEM;
126165: nElem = 0;
126166: break;
126167: }
126168: aElem = aElem2;
126169: }
126170:
126171: aElem[nElem++] = pE;
126172: }
126173: }
126174:
126175: /* If more than one term matches the prefix, sort the Fts3HashElem
126176: ** objects in term order using qsort(). This uses the same comparison
126177: ** callback as is used when flushing terms to disk.
126178: */
126179: if( nElem>1 ){
126180: qsort(aElem, nElem, sizeof(Fts3HashElem *), fts3CompareElemByTerm);
126181: }
126182:
126183: }else{
126184: /* The query is a simple term lookup that matches at most one term in
126185: ** the index. All that is required is a straight hash-lookup.
126186: **
126187: ** Because the stack address of pE may be accessed via the aElem pointer
126188: ** below, the "Fts3HashElem *pE" must be declared so that it is valid
126189: ** within this entire function, not just this "else{...}" block.
126190: */
126191: pE = fts3HashFindElem(pHash, zTerm, nTerm);
126192: if( pE ){
126193: aElem = &pE;
126194: nElem = 1;
126195: }
126196: }
126197:
126198: if( nElem>0 ){
126199: int nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *);
126200: pReader = (Fts3SegReader *)sqlite3_malloc(nByte);
126201: if( !pReader ){
126202: rc = SQLITE_NOMEM;
126203: }else{
126204: memset(pReader, 0, nByte);
126205: pReader->iIdx = 0x7FFFFFFF;
126206: pReader->ppNextElem = (Fts3HashElem **)&pReader[1];
126207: memcpy(pReader->ppNextElem, aElem, nElem*sizeof(Fts3HashElem *));
126208: }
126209: }
126210:
126211: if( bPrefix ){
126212: sqlite3_free(aElem);
126213: }
126214: *ppReader = pReader;
126215: return rc;
126216: }
126217:
126218: /*
126219: ** Compare the entries pointed to by two Fts3SegReader structures.
126220: ** Comparison is as follows:
126221: **
126222: ** 1) EOF is greater than not EOF.
126223: **
126224: ** 2) The current terms (if any) are compared using memcmp(). If one
126225: ** term is a prefix of another, the longer term is considered the
126226: ** larger.
126227: **
126228: ** 3) By segment age. An older segment is considered larger.
126229: */
126230: static int fts3SegReaderCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){
126231: int rc;
126232: if( pLhs->aNode && pRhs->aNode ){
126233: int rc2 = pLhs->nTerm - pRhs->nTerm;
126234: if( rc2<0 ){
126235: rc = memcmp(pLhs->zTerm, pRhs->zTerm, pLhs->nTerm);
126236: }else{
126237: rc = memcmp(pLhs->zTerm, pRhs->zTerm, pRhs->nTerm);
126238: }
126239: if( rc==0 ){
126240: rc = rc2;
126241: }
126242: }else{
126243: rc = (pLhs->aNode==0) - (pRhs->aNode==0);
126244: }
126245: if( rc==0 ){
126246: rc = pRhs->iIdx - pLhs->iIdx;
126247: }
126248: assert( rc!=0 );
126249: return rc;
126250: }
126251:
126252: /*
126253: ** A different comparison function for SegReader structures. In this
126254: ** version, it is assumed that each SegReader points to an entry in
126255: ** a doclist for identical terms. Comparison is made as follows:
126256: **
126257: ** 1) EOF (end of doclist in this case) is greater than not EOF.
126258: **
126259: ** 2) By current docid.
126260: **
126261: ** 3) By segment age. An older segment is considered larger.
126262: */
126263: static int fts3SegReaderDoclistCmp(Fts3SegReader *pLhs, Fts3SegReader *pRhs){
126264: int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0);
126265: if( rc==0 ){
126266: if( pLhs->iDocid==pRhs->iDocid ){
126267: rc = pRhs->iIdx - pLhs->iIdx;
126268: }else{
126269: rc = (pLhs->iDocid > pRhs->iDocid) ? 1 : -1;
126270: }
126271: }
126272: assert( pLhs->aNode && pRhs->aNode );
126273: return rc;
126274: }
126275: static int fts3SegReaderDoclistCmpRev(Fts3SegReader *pLhs, Fts3SegReader *pRhs){
126276: int rc = (pLhs->pOffsetList==0)-(pRhs->pOffsetList==0);
126277: if( rc==0 ){
126278: if( pLhs->iDocid==pRhs->iDocid ){
126279: rc = pRhs->iIdx - pLhs->iIdx;
126280: }else{
126281: rc = (pLhs->iDocid < pRhs->iDocid) ? 1 : -1;
126282: }
126283: }
126284: assert( pLhs->aNode && pRhs->aNode );
126285: return rc;
126286: }
126287:
126288: /*
126289: ** Compare the term that the Fts3SegReader object passed as the first argument
126290: ** points to with the term specified by arguments zTerm and nTerm.
126291: **
126292: ** If the pSeg iterator is already at EOF, return 0. Otherwise, return
126293: ** -ve if the pSeg term is less than zTerm/nTerm, 0 if the two terms are
126294: ** equal, or +ve if the pSeg term is greater than zTerm/nTerm.
126295: */
126296: static int fts3SegReaderTermCmp(
126297: Fts3SegReader *pSeg, /* Segment reader object */
126298: const char *zTerm, /* Term to compare to */
126299: int nTerm /* Size of term zTerm in bytes */
126300: ){
126301: int res = 0;
126302: if( pSeg->aNode ){
126303: if( pSeg->nTerm>nTerm ){
126304: res = memcmp(pSeg->zTerm, zTerm, nTerm);
126305: }else{
126306: res = memcmp(pSeg->zTerm, zTerm, pSeg->nTerm);
126307: }
126308: if( res==0 ){
126309: res = pSeg->nTerm-nTerm;
126310: }
126311: }
126312: return res;
126313: }
126314:
126315: /*
126316: ** Argument apSegment is an array of nSegment elements. It is known that
126317: ** the final (nSegment-nSuspect) members are already in sorted order
126318: ** (according to the comparison function provided). This function shuffles
126319: ** the array around until all entries are in sorted order.
126320: */
126321: static void fts3SegReaderSort(
126322: Fts3SegReader **apSegment, /* Array to sort entries of */
126323: int nSegment, /* Size of apSegment array */
126324: int nSuspect, /* Unsorted entry count */
126325: int (*xCmp)(Fts3SegReader *, Fts3SegReader *) /* Comparison function */
126326: ){
126327: int i; /* Iterator variable */
126328:
126329: assert( nSuspect<=nSegment );
126330:
126331: if( nSuspect==nSegment ) nSuspect--;
126332: for(i=nSuspect-1; i>=0; i--){
126333: int j;
126334: for(j=i; j<(nSegment-1); j++){
126335: Fts3SegReader *pTmp;
126336: if( xCmp(apSegment[j], apSegment[j+1])<0 ) break;
126337: pTmp = apSegment[j+1];
126338: apSegment[j+1] = apSegment[j];
126339: apSegment[j] = pTmp;
126340: }
126341: }
126342:
126343: #ifndef NDEBUG
126344: /* Check that the list really is sorted now. */
126345: for(i=0; i<(nSuspect-1); i++){
126346: assert( xCmp(apSegment[i], apSegment[i+1])<0 );
126347: }
126348: #endif
126349: }
126350:
126351: /*
126352: ** Insert a record into the %_segments table.
126353: */
126354: static int fts3WriteSegment(
126355: Fts3Table *p, /* Virtual table handle */
126356: sqlite3_int64 iBlock, /* Block id for new block */
126357: char *z, /* Pointer to buffer containing block data */
126358: int n /* Size of buffer z in bytes */
126359: ){
126360: sqlite3_stmt *pStmt;
126361: int rc = fts3SqlStmt(p, SQL_INSERT_SEGMENTS, &pStmt, 0);
126362: if( rc==SQLITE_OK ){
126363: sqlite3_bind_int64(pStmt, 1, iBlock);
126364: sqlite3_bind_blob(pStmt, 2, z, n, SQLITE_STATIC);
126365: sqlite3_step(pStmt);
126366: rc = sqlite3_reset(pStmt);
126367: }
126368: return rc;
126369: }
126370:
126371: /*
126372: ** Insert a record into the %_segdir table.
126373: */
126374: static int fts3WriteSegdir(
126375: Fts3Table *p, /* Virtual table handle */
126376: int iLevel, /* Value for "level" field */
126377: int iIdx, /* Value for "idx" field */
126378: sqlite3_int64 iStartBlock, /* Value for "start_block" field */
126379: sqlite3_int64 iLeafEndBlock, /* Value for "leaves_end_block" field */
126380: sqlite3_int64 iEndBlock, /* Value for "end_block" field */
126381: char *zRoot, /* Blob value for "root" field */
126382: int nRoot /* Number of bytes in buffer zRoot */
126383: ){
126384: sqlite3_stmt *pStmt;
126385: int rc = fts3SqlStmt(p, SQL_INSERT_SEGDIR, &pStmt, 0);
126386: if( rc==SQLITE_OK ){
126387: sqlite3_bind_int(pStmt, 1, iLevel);
126388: sqlite3_bind_int(pStmt, 2, iIdx);
126389: sqlite3_bind_int64(pStmt, 3, iStartBlock);
126390: sqlite3_bind_int64(pStmt, 4, iLeafEndBlock);
126391: sqlite3_bind_int64(pStmt, 5, iEndBlock);
126392: sqlite3_bind_blob(pStmt, 6, zRoot, nRoot, SQLITE_STATIC);
126393: sqlite3_step(pStmt);
126394: rc = sqlite3_reset(pStmt);
126395: }
126396: return rc;
126397: }
126398:
126399: /*
126400: ** Return the size of the common prefix (if any) shared by zPrev and
126401: ** zNext, in bytes. For example,
126402: **
126403: ** fts3PrefixCompress("abc", 3, "abcdef", 6) // returns 3
126404: ** fts3PrefixCompress("abX", 3, "abcdef", 6) // returns 2
126405: ** fts3PrefixCompress("abX", 3, "Xbcdef", 6) // returns 0
126406: */
126407: static int fts3PrefixCompress(
126408: const char *zPrev, /* Buffer containing previous term */
126409: int nPrev, /* Size of buffer zPrev in bytes */
126410: const char *zNext, /* Buffer containing next term */
126411: int nNext /* Size of buffer zNext in bytes */
126412: ){
126413: int n;
126414: UNUSED_PARAMETER(nNext);
126415: for(n=0; n<nPrev && zPrev[n]==zNext[n]; n++);
126416: return n;
126417: }
126418:
126419: /*
126420: ** Add term zTerm to the SegmentNode. It is guaranteed that zTerm is larger
126421: ** (according to memcmp) than the previous term.
126422: */
126423: static int fts3NodeAddTerm(
126424: Fts3Table *p, /* Virtual table handle */
126425: SegmentNode **ppTree, /* IN/OUT: SegmentNode handle */
126426: int isCopyTerm, /* True if zTerm/nTerm is transient */
126427: const char *zTerm, /* Pointer to buffer containing term */
126428: int nTerm /* Size of term in bytes */
126429: ){
126430: SegmentNode *pTree = *ppTree;
126431: int rc;
126432: SegmentNode *pNew;
126433:
126434: /* First try to append the term to the current node. Return early if
126435: ** this is possible.
126436: */
126437: if( pTree ){
126438: int nData = pTree->nData; /* Current size of node in bytes */
126439: int nReq = nData; /* Required space after adding zTerm */
126440: int nPrefix; /* Number of bytes of prefix compression */
126441: int nSuffix; /* Suffix length */
126442:
126443: nPrefix = fts3PrefixCompress(pTree->zTerm, pTree->nTerm, zTerm, nTerm);
126444: nSuffix = nTerm-nPrefix;
126445:
126446: nReq += sqlite3Fts3VarintLen(nPrefix)+sqlite3Fts3VarintLen(nSuffix)+nSuffix;
126447: if( nReq<=p->nNodeSize || !pTree->zTerm ){
126448:
126449: if( nReq>p->nNodeSize ){
126450: /* An unusual case: this is the first term to be added to the node
126451: ** and the static node buffer (p->nNodeSize bytes) is not large
126452: ** enough. Use a separately malloced buffer instead This wastes
126453: ** p->nNodeSize bytes, but since this scenario only comes about when
126454: ** the database contain two terms that share a prefix of almost 2KB,
126455: ** this is not expected to be a serious problem.
126456: */
126457: assert( pTree->aData==(char *)&pTree[1] );
126458: pTree->aData = (char *)sqlite3_malloc(nReq);
126459: if( !pTree->aData ){
126460: return SQLITE_NOMEM;
126461: }
126462: }
126463:
126464: if( pTree->zTerm ){
126465: /* There is no prefix-length field for first term in a node */
126466: nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nPrefix);
126467: }
126468:
126469: nData += sqlite3Fts3PutVarint(&pTree->aData[nData], nSuffix);
126470: memcpy(&pTree->aData[nData], &zTerm[nPrefix], nSuffix);
126471: pTree->nData = nData + nSuffix;
126472: pTree->nEntry++;
126473:
126474: if( isCopyTerm ){
126475: if( pTree->nMalloc<nTerm ){
126476: char *zNew = sqlite3_realloc(pTree->zMalloc, nTerm*2);
126477: if( !zNew ){
126478: return SQLITE_NOMEM;
126479: }
126480: pTree->nMalloc = nTerm*2;
126481: pTree->zMalloc = zNew;
126482: }
126483: pTree->zTerm = pTree->zMalloc;
126484: memcpy(pTree->zTerm, zTerm, nTerm);
126485: pTree->nTerm = nTerm;
126486: }else{
126487: pTree->zTerm = (char *)zTerm;
126488: pTree->nTerm = nTerm;
126489: }
126490: return SQLITE_OK;
126491: }
126492: }
126493:
126494: /* If control flows to here, it was not possible to append zTerm to the
126495: ** current node. Create a new node (a right-sibling of the current node).
126496: ** If this is the first node in the tree, the term is added to it.
126497: **
126498: ** Otherwise, the term is not added to the new node, it is left empty for
126499: ** now. Instead, the term is inserted into the parent of pTree. If pTree
126500: ** has no parent, one is created here.
126501: */
126502: pNew = (SegmentNode *)sqlite3_malloc(sizeof(SegmentNode) + p->nNodeSize);
126503: if( !pNew ){
126504: return SQLITE_NOMEM;
126505: }
126506: memset(pNew, 0, sizeof(SegmentNode));
126507: pNew->nData = 1 + FTS3_VARINT_MAX;
126508: pNew->aData = (char *)&pNew[1];
126509:
126510: if( pTree ){
126511: SegmentNode *pParent = pTree->pParent;
126512: rc = fts3NodeAddTerm(p, &pParent, isCopyTerm, zTerm, nTerm);
126513: if( pTree->pParent==0 ){
126514: pTree->pParent = pParent;
126515: }
126516: pTree->pRight = pNew;
126517: pNew->pLeftmost = pTree->pLeftmost;
126518: pNew->pParent = pParent;
126519: pNew->zMalloc = pTree->zMalloc;
126520: pNew->nMalloc = pTree->nMalloc;
126521: pTree->zMalloc = 0;
126522: }else{
126523: pNew->pLeftmost = pNew;
126524: rc = fts3NodeAddTerm(p, &pNew, isCopyTerm, zTerm, nTerm);
126525: }
126526:
126527: *ppTree = pNew;
126528: return rc;
126529: }
126530:
126531: /*
126532: ** Helper function for fts3NodeWrite().
126533: */
126534: static int fts3TreeFinishNode(
126535: SegmentNode *pTree,
126536: int iHeight,
126537: sqlite3_int64 iLeftChild
126538: ){
126539: int nStart;
126540: assert( iHeight>=1 && iHeight<128 );
126541: nStart = FTS3_VARINT_MAX - sqlite3Fts3VarintLen(iLeftChild);
126542: pTree->aData[nStart] = (char)iHeight;
126543: sqlite3Fts3PutVarint(&pTree->aData[nStart+1], iLeftChild);
126544: return nStart;
126545: }
126546:
126547: /*
126548: ** Write the buffer for the segment node pTree and all of its peers to the
126549: ** database. Then call this function recursively to write the parent of
126550: ** pTree and its peers to the database.
126551: **
126552: ** Except, if pTree is a root node, do not write it to the database. Instead,
126553: ** set output variables *paRoot and *pnRoot to contain the root node.
126554: **
126555: ** If successful, SQLITE_OK is returned and output variable *piLast is
126556: ** set to the largest blockid written to the database (or zero if no
126557: ** blocks were written to the db). Otherwise, an SQLite error code is
126558: ** returned.
126559: */
126560: static int fts3NodeWrite(
126561: Fts3Table *p, /* Virtual table handle */
126562: SegmentNode *pTree, /* SegmentNode handle */
126563: int iHeight, /* Height of this node in tree */
126564: sqlite3_int64 iLeaf, /* Block id of first leaf node */
126565: sqlite3_int64 iFree, /* Block id of next free slot in %_segments */
126566: sqlite3_int64 *piLast, /* OUT: Block id of last entry written */
126567: char **paRoot, /* OUT: Data for root node */
126568: int *pnRoot /* OUT: Size of root node in bytes */
126569: ){
126570: int rc = SQLITE_OK;
126571:
126572: if( !pTree->pParent ){
126573: /* Root node of the tree. */
126574: int nStart = fts3TreeFinishNode(pTree, iHeight, iLeaf);
126575: *piLast = iFree-1;
126576: *pnRoot = pTree->nData - nStart;
126577: *paRoot = &pTree->aData[nStart];
126578: }else{
126579: SegmentNode *pIter;
126580: sqlite3_int64 iNextFree = iFree;
126581: sqlite3_int64 iNextLeaf = iLeaf;
126582: for(pIter=pTree->pLeftmost; pIter && rc==SQLITE_OK; pIter=pIter->pRight){
126583: int nStart = fts3TreeFinishNode(pIter, iHeight, iNextLeaf);
126584: int nWrite = pIter->nData - nStart;
126585:
126586: rc = fts3WriteSegment(p, iNextFree, &pIter->aData[nStart], nWrite);
126587: iNextFree++;
126588: iNextLeaf += (pIter->nEntry+1);
126589: }
126590: if( rc==SQLITE_OK ){
126591: assert( iNextLeaf==iFree );
126592: rc = fts3NodeWrite(
126593: p, pTree->pParent, iHeight+1, iFree, iNextFree, piLast, paRoot, pnRoot
126594: );
126595: }
126596: }
126597:
126598: return rc;
126599: }
126600:
126601: /*
126602: ** Free all memory allocations associated with the tree pTree.
126603: */
126604: static void fts3NodeFree(SegmentNode *pTree){
126605: if( pTree ){
126606: SegmentNode *p = pTree->pLeftmost;
126607: fts3NodeFree(p->pParent);
126608: while( p ){
126609: SegmentNode *pRight = p->pRight;
126610: if( p->aData!=(char *)&p[1] ){
126611: sqlite3_free(p->aData);
126612: }
126613: assert( pRight==0 || p->zMalloc==0 );
126614: sqlite3_free(p->zMalloc);
126615: sqlite3_free(p);
126616: p = pRight;
126617: }
126618: }
126619: }
126620:
126621: /*
126622: ** Add a term to the segment being constructed by the SegmentWriter object
126623: ** *ppWriter. When adding the first term to a segment, *ppWriter should
126624: ** be passed NULL. This function will allocate a new SegmentWriter object
126625: ** and return it via the input/output variable *ppWriter in this case.
126626: **
126627: ** If successful, SQLITE_OK is returned. Otherwise, an SQLite error code.
126628: */
126629: static int fts3SegWriterAdd(
126630: Fts3Table *p, /* Virtual table handle */
126631: SegmentWriter **ppWriter, /* IN/OUT: SegmentWriter handle */
126632: int isCopyTerm, /* True if buffer zTerm must be copied */
126633: const char *zTerm, /* Pointer to buffer containing term */
126634: int nTerm, /* Size of term in bytes */
126635: const char *aDoclist, /* Pointer to buffer containing doclist */
126636: int nDoclist /* Size of doclist in bytes */
126637: ){
126638: int nPrefix; /* Size of term prefix in bytes */
126639: int nSuffix; /* Size of term suffix in bytes */
126640: int nReq; /* Number of bytes required on leaf page */
126641: int nData;
126642: SegmentWriter *pWriter = *ppWriter;
126643:
126644: if( !pWriter ){
126645: int rc;
126646: sqlite3_stmt *pStmt;
126647:
126648: /* Allocate the SegmentWriter structure */
126649: pWriter = (SegmentWriter *)sqlite3_malloc(sizeof(SegmentWriter));
126650: if( !pWriter ) return SQLITE_NOMEM;
126651: memset(pWriter, 0, sizeof(SegmentWriter));
126652: *ppWriter = pWriter;
126653:
126654: /* Allocate a buffer in which to accumulate data */
126655: pWriter->aData = (char *)sqlite3_malloc(p->nNodeSize);
126656: if( !pWriter->aData ) return SQLITE_NOMEM;
126657: pWriter->nSize = p->nNodeSize;
126658:
126659: /* Find the next free blockid in the %_segments table */
126660: rc = fts3SqlStmt(p, SQL_NEXT_SEGMENTS_ID, &pStmt, 0);
126661: if( rc!=SQLITE_OK ) return rc;
126662: if( SQLITE_ROW==sqlite3_step(pStmt) ){
126663: pWriter->iFree = sqlite3_column_int64(pStmt, 0);
126664: pWriter->iFirst = pWriter->iFree;
126665: }
126666: rc = sqlite3_reset(pStmt);
126667: if( rc!=SQLITE_OK ) return rc;
126668: }
126669: nData = pWriter->nData;
126670:
126671: nPrefix = fts3PrefixCompress(pWriter->zTerm, pWriter->nTerm, zTerm, nTerm);
126672: nSuffix = nTerm-nPrefix;
126673:
126674: /* Figure out how many bytes are required by this new entry */
126675: nReq = sqlite3Fts3VarintLen(nPrefix) + /* varint containing prefix size */
126676: sqlite3Fts3VarintLen(nSuffix) + /* varint containing suffix size */
126677: nSuffix + /* Term suffix */
126678: sqlite3Fts3VarintLen(nDoclist) + /* Size of doclist */
126679: nDoclist; /* Doclist data */
126680:
126681: if( nData>0 && nData+nReq>p->nNodeSize ){
126682: int rc;
126683:
126684: /* The current leaf node is full. Write it out to the database. */
126685: rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, nData);
126686: if( rc!=SQLITE_OK ) return rc;
126687:
126688: /* Add the current term to the interior node tree. The term added to
126689: ** the interior tree must:
126690: **
126691: ** a) be greater than the largest term on the leaf node just written
126692: ** to the database (still available in pWriter->zTerm), and
126693: **
126694: ** b) be less than or equal to the term about to be added to the new
126695: ** leaf node (zTerm/nTerm).
126696: **
126697: ** In other words, it must be the prefix of zTerm 1 byte longer than
126698: ** the common prefix (if any) of zTerm and pWriter->zTerm.
126699: */
126700: assert( nPrefix<nTerm );
126701: rc = fts3NodeAddTerm(p, &pWriter->pTree, isCopyTerm, zTerm, nPrefix+1);
126702: if( rc!=SQLITE_OK ) return rc;
126703:
126704: nData = 0;
126705: pWriter->nTerm = 0;
126706:
126707: nPrefix = 0;
126708: nSuffix = nTerm;
126709: nReq = 1 + /* varint containing prefix size */
126710: sqlite3Fts3VarintLen(nTerm) + /* varint containing suffix size */
126711: nTerm + /* Term suffix */
126712: sqlite3Fts3VarintLen(nDoclist) + /* Size of doclist */
126713: nDoclist; /* Doclist data */
126714: }
126715:
126716: /* If the buffer currently allocated is too small for this entry, realloc
126717: ** the buffer to make it large enough.
126718: */
126719: if( nReq>pWriter->nSize ){
126720: char *aNew = sqlite3_realloc(pWriter->aData, nReq);
126721: if( !aNew ) return SQLITE_NOMEM;
126722: pWriter->aData = aNew;
126723: pWriter->nSize = nReq;
126724: }
126725: assert( nData+nReq<=pWriter->nSize );
126726:
126727: /* Append the prefix-compressed term and doclist to the buffer. */
126728: nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nPrefix);
126729: nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nSuffix);
126730: memcpy(&pWriter->aData[nData], &zTerm[nPrefix], nSuffix);
126731: nData += nSuffix;
126732: nData += sqlite3Fts3PutVarint(&pWriter->aData[nData], nDoclist);
126733: memcpy(&pWriter->aData[nData], aDoclist, nDoclist);
126734: pWriter->nData = nData + nDoclist;
126735:
126736: /* Save the current term so that it can be used to prefix-compress the next.
126737: ** If the isCopyTerm parameter is true, then the buffer pointed to by
126738: ** zTerm is transient, so take a copy of the term data. Otherwise, just
126739: ** store a copy of the pointer.
126740: */
126741: if( isCopyTerm ){
126742: if( nTerm>pWriter->nMalloc ){
126743: char *zNew = sqlite3_realloc(pWriter->zMalloc, nTerm*2);
126744: if( !zNew ){
126745: return SQLITE_NOMEM;
126746: }
126747: pWriter->nMalloc = nTerm*2;
126748: pWriter->zMalloc = zNew;
126749: pWriter->zTerm = zNew;
126750: }
126751: assert( pWriter->zTerm==pWriter->zMalloc );
126752: memcpy(pWriter->zTerm, zTerm, nTerm);
126753: }else{
126754: pWriter->zTerm = (char *)zTerm;
126755: }
126756: pWriter->nTerm = nTerm;
126757:
126758: return SQLITE_OK;
126759: }
126760:
126761: /*
126762: ** Flush all data associated with the SegmentWriter object pWriter to the
126763: ** database. This function must be called after all terms have been added
126764: ** to the segment using fts3SegWriterAdd(). If successful, SQLITE_OK is
126765: ** returned. Otherwise, an SQLite error code.
126766: */
126767: static int fts3SegWriterFlush(
126768: Fts3Table *p, /* Virtual table handle */
126769: SegmentWriter *pWriter, /* SegmentWriter to flush to the db */
126770: int iLevel, /* Value for 'level' column of %_segdir */
126771: int iIdx /* Value for 'idx' column of %_segdir */
126772: ){
126773: int rc; /* Return code */
126774: if( pWriter->pTree ){
126775: sqlite3_int64 iLast = 0; /* Largest block id written to database */
126776: sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */
126777: char *zRoot = NULL; /* Pointer to buffer containing root node */
126778: int nRoot = 0; /* Size of buffer zRoot */
126779:
126780: iLastLeaf = pWriter->iFree;
126781: rc = fts3WriteSegment(p, pWriter->iFree++, pWriter->aData, pWriter->nData);
126782: if( rc==SQLITE_OK ){
126783: rc = fts3NodeWrite(p, pWriter->pTree, 1,
126784: pWriter->iFirst, pWriter->iFree, &iLast, &zRoot, &nRoot);
126785: }
126786: if( rc==SQLITE_OK ){
126787: rc = fts3WriteSegdir(
126788: p, iLevel, iIdx, pWriter->iFirst, iLastLeaf, iLast, zRoot, nRoot);
126789: }
126790: }else{
126791: /* The entire tree fits on the root node. Write it to the segdir table. */
126792: rc = fts3WriteSegdir(
126793: p, iLevel, iIdx, 0, 0, 0, pWriter->aData, pWriter->nData);
126794: }
126795: return rc;
126796: }
126797:
126798: /*
126799: ** Release all memory held by the SegmentWriter object passed as the
126800: ** first argument.
126801: */
126802: static void fts3SegWriterFree(SegmentWriter *pWriter){
126803: if( pWriter ){
126804: sqlite3_free(pWriter->aData);
126805: sqlite3_free(pWriter->zMalloc);
126806: fts3NodeFree(pWriter->pTree);
126807: sqlite3_free(pWriter);
126808: }
126809: }
126810:
126811: /*
126812: ** The first value in the apVal[] array is assumed to contain an integer.
126813: ** This function tests if there exist any documents with docid values that
126814: ** are different from that integer. i.e. if deleting the document with docid
126815: ** pRowid would mean the FTS3 table were empty.
126816: **
126817: ** If successful, *pisEmpty is set to true if the table is empty except for
126818: ** document pRowid, or false otherwise, and SQLITE_OK is returned. If an
126819: ** error occurs, an SQLite error code is returned.
126820: */
126821: static int fts3IsEmpty(Fts3Table *p, sqlite3_value *pRowid, int *pisEmpty){
126822: sqlite3_stmt *pStmt;
126823: int rc;
126824: if( p->zContentTbl ){
126825: /* If using the content=xxx option, assume the table is never empty */
126826: *pisEmpty = 0;
126827: rc = SQLITE_OK;
126828: }else{
126829: rc = fts3SqlStmt(p, SQL_IS_EMPTY, &pStmt, &pRowid);
126830: if( rc==SQLITE_OK ){
126831: if( SQLITE_ROW==sqlite3_step(pStmt) ){
126832: *pisEmpty = sqlite3_column_int(pStmt, 0);
126833: }
126834: rc = sqlite3_reset(pStmt);
126835: }
126836: }
126837: return rc;
126838: }
126839:
126840: /*
126841: ** Set *pnMax to the largest segment level in the database for the index
126842: ** iIndex.
126843: **
126844: ** Segment levels are stored in the 'level' column of the %_segdir table.
126845: **
126846: ** Return SQLITE_OK if successful, or an SQLite error code if not.
126847: */
126848: static int fts3SegmentMaxLevel(Fts3Table *p, int iIndex, int *pnMax){
126849: sqlite3_stmt *pStmt;
126850: int rc;
126851: assert( iIndex>=0 && iIndex<p->nIndex );
126852:
126853: /* Set pStmt to the compiled version of:
126854: **
126855: ** SELECT max(level) FROM %Q.'%q_segdir' WHERE level BETWEEN ? AND ?
126856: **
126857: ** (1024 is actually the value of macro FTS3_SEGDIR_PREFIXLEVEL_STR).
126858: */
126859: rc = fts3SqlStmt(p, SQL_SELECT_SEGDIR_MAX_LEVEL, &pStmt, 0);
126860: if( rc!=SQLITE_OK ) return rc;
126861: sqlite3_bind_int(pStmt, 1, iIndex*FTS3_SEGDIR_MAXLEVEL);
126862: sqlite3_bind_int(pStmt, 2, (iIndex+1)*FTS3_SEGDIR_MAXLEVEL - 1);
126863: if( SQLITE_ROW==sqlite3_step(pStmt) ){
126864: *pnMax = sqlite3_column_int(pStmt, 0);
126865: }
126866: return sqlite3_reset(pStmt);
126867: }
126868:
126869: /*
126870: ** This function is used after merging multiple segments into a single large
126871: ** segment to delete the old, now redundant, segment b-trees. Specifically,
126872: ** it:
126873: **
126874: ** 1) Deletes all %_segments entries for the segments associated with
126875: ** each of the SegReader objects in the array passed as the third
126876: ** argument, and
126877: **
126878: ** 2) deletes all %_segdir entries with level iLevel, or all %_segdir
126879: ** entries regardless of level if (iLevel<0).
126880: **
126881: ** SQLITE_OK is returned if successful, otherwise an SQLite error code.
126882: */
126883: static int fts3DeleteSegdir(
126884: Fts3Table *p, /* Virtual table handle */
126885: int iIndex, /* Index for p->aIndex */
126886: int iLevel, /* Level of %_segdir entries to delete */
126887: Fts3SegReader **apSegment, /* Array of SegReader objects */
126888: int nReader /* Size of array apSegment */
126889: ){
126890: int rc; /* Return Code */
126891: int i; /* Iterator variable */
126892: sqlite3_stmt *pDelete; /* SQL statement to delete rows */
126893:
126894: rc = fts3SqlStmt(p, SQL_DELETE_SEGMENTS_RANGE, &pDelete, 0);
126895: for(i=0; rc==SQLITE_OK && i<nReader; i++){
126896: Fts3SegReader *pSegment = apSegment[i];
126897: if( pSegment->iStartBlock ){
126898: sqlite3_bind_int64(pDelete, 1, pSegment->iStartBlock);
126899: sqlite3_bind_int64(pDelete, 2, pSegment->iEndBlock);
126900: sqlite3_step(pDelete);
126901: rc = sqlite3_reset(pDelete);
126902: }
126903: }
126904: if( rc!=SQLITE_OK ){
126905: return rc;
126906: }
126907:
126908: assert( iLevel>=0 || iLevel==FTS3_SEGCURSOR_ALL );
126909: if( iLevel==FTS3_SEGCURSOR_ALL ){
126910: rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_RANGE, &pDelete, 0);
126911: if( rc==SQLITE_OK ){
126912: sqlite3_bind_int(pDelete, 1, iIndex*FTS3_SEGDIR_MAXLEVEL);
126913: sqlite3_bind_int(pDelete, 2, (iIndex+1) * FTS3_SEGDIR_MAXLEVEL - 1);
126914: }
126915: }else{
126916: rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pDelete, 0);
126917: if( rc==SQLITE_OK ){
126918: sqlite3_bind_int(pDelete, 1, iIndex*FTS3_SEGDIR_MAXLEVEL + iLevel);
126919: }
126920: }
126921:
126922: if( rc==SQLITE_OK ){
126923: sqlite3_step(pDelete);
126924: rc = sqlite3_reset(pDelete);
126925: }
126926:
126927: return rc;
126928: }
126929:
126930: /*
126931: ** When this function is called, buffer *ppList (size *pnList bytes) contains
126932: ** a position list that may (or may not) feature multiple columns. This
126933: ** function adjusts the pointer *ppList and the length *pnList so that they
126934: ** identify the subset of the position list that corresponds to column iCol.
126935: **
126936: ** If there are no entries in the input position list for column iCol, then
126937: ** *pnList is set to zero before returning.
126938: */
126939: static void fts3ColumnFilter(
126940: int iCol, /* Column to filter on */
126941: char **ppList, /* IN/OUT: Pointer to position list */
126942: int *pnList /* IN/OUT: Size of buffer *ppList in bytes */
126943: ){
126944: char *pList = *ppList;
126945: int nList = *pnList;
126946: char *pEnd = &pList[nList];
126947: int iCurrent = 0;
126948: char *p = pList;
126949:
126950: assert( iCol>=0 );
126951: while( 1 ){
126952: char c = 0;
126953: while( p<pEnd && (c | *p)&0xFE ) c = *p++ & 0x80;
126954:
126955: if( iCol==iCurrent ){
126956: nList = (int)(p - pList);
126957: break;
126958: }
126959:
126960: nList -= (int)(p - pList);
126961: pList = p;
126962: if( nList==0 ){
126963: break;
126964: }
126965: p = &pList[1];
126966: p += sqlite3Fts3GetVarint32(p, &iCurrent);
126967: }
126968:
126969: *ppList = pList;
126970: *pnList = nList;
126971: }
126972:
126973: /*
126974: ** Cache data in the Fts3MultiSegReader.aBuffer[] buffer (overwriting any
126975: ** existing data). Grow the buffer if required.
126976: **
126977: ** If successful, return SQLITE_OK. Otherwise, if an OOM error is encountered
126978: ** trying to resize the buffer, return SQLITE_NOMEM.
126979: */
126980: static int fts3MsrBufferData(
126981: Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */
126982: char *pList,
126983: int nList
126984: ){
126985: if( nList>pMsr->nBuffer ){
126986: char *pNew;
126987: pMsr->nBuffer = nList*2;
126988: pNew = (char *)sqlite3_realloc(pMsr->aBuffer, pMsr->nBuffer);
126989: if( !pNew ) return SQLITE_NOMEM;
126990: pMsr->aBuffer = pNew;
126991: }
126992:
126993: memcpy(pMsr->aBuffer, pList, nList);
126994: return SQLITE_OK;
126995: }
126996:
126997: SQLITE_PRIVATE int sqlite3Fts3MsrIncrNext(
126998: Fts3Table *p, /* Virtual table handle */
126999: Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */
127000: sqlite3_int64 *piDocid, /* OUT: Docid value */
127001: char **paPoslist, /* OUT: Pointer to position list */
127002: int *pnPoslist /* OUT: Size of position list in bytes */
127003: ){
127004: int nMerge = pMsr->nAdvance;
127005: Fts3SegReader **apSegment = pMsr->apSegment;
127006: int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = (
127007: p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp
127008: );
127009:
127010: if( nMerge==0 ){
127011: *paPoslist = 0;
127012: return SQLITE_OK;
127013: }
127014:
127015: while( 1 ){
127016: Fts3SegReader *pSeg;
127017: pSeg = pMsr->apSegment[0];
127018:
127019: if( pSeg->pOffsetList==0 ){
127020: *paPoslist = 0;
127021: break;
127022: }else{
127023: int rc;
127024: char *pList;
127025: int nList;
127026: int j;
127027: sqlite3_int64 iDocid = apSegment[0]->iDocid;
127028:
127029: rc = fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList);
127030: j = 1;
127031: while( rc==SQLITE_OK
127032: && j<nMerge
127033: && apSegment[j]->pOffsetList
127034: && apSegment[j]->iDocid==iDocid
127035: ){
127036: rc = fts3SegReaderNextDocid(p, apSegment[j], 0, 0);
127037: j++;
127038: }
127039: if( rc!=SQLITE_OK ) return rc;
127040: fts3SegReaderSort(pMsr->apSegment, nMerge, j, xCmp);
127041:
127042: if( pMsr->iColFilter>=0 ){
127043: fts3ColumnFilter(pMsr->iColFilter, &pList, &nList);
127044: }
127045:
127046: if( nList>0 ){
127047: if( fts3SegReaderIsPending(apSegment[0]) ){
127048: rc = fts3MsrBufferData(pMsr, pList, nList+1);
127049: if( rc!=SQLITE_OK ) return rc;
127050: *paPoslist = pMsr->aBuffer;
127051: assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 );
127052: }else{
127053: *paPoslist = pList;
127054: }
127055: *piDocid = iDocid;
127056: *pnPoslist = nList;
127057: break;
127058: }
127059: }
127060: }
127061:
127062: return SQLITE_OK;
127063: }
127064:
127065: static int fts3SegReaderStart(
127066: Fts3Table *p, /* Virtual table handle */
127067: Fts3MultiSegReader *pCsr, /* Cursor object */
127068: const char *zTerm, /* Term searched for (or NULL) */
127069: int nTerm /* Length of zTerm in bytes */
127070: ){
127071: int i;
127072: int nSeg = pCsr->nSegment;
127073:
127074: /* If the Fts3SegFilter defines a specific term (or term prefix) to search
127075: ** for, then advance each segment iterator until it points to a term of
127076: ** equal or greater value than the specified term. This prevents many
127077: ** unnecessary merge/sort operations for the case where single segment
127078: ** b-tree leaf nodes contain more than one term.
127079: */
127080: for(i=0; pCsr->bRestart==0 && i<pCsr->nSegment; i++){
127081: Fts3SegReader *pSeg = pCsr->apSegment[i];
127082: do {
127083: int rc = fts3SegReaderNext(p, pSeg, 0);
127084: if( rc!=SQLITE_OK ) return rc;
127085: }while( zTerm && fts3SegReaderTermCmp(pSeg, zTerm, nTerm)<0 );
127086: }
127087: fts3SegReaderSort(pCsr->apSegment, nSeg, nSeg, fts3SegReaderCmp);
127088:
127089: return SQLITE_OK;
127090: }
127091:
127092: SQLITE_PRIVATE int sqlite3Fts3SegReaderStart(
127093: Fts3Table *p, /* Virtual table handle */
127094: Fts3MultiSegReader *pCsr, /* Cursor object */
127095: Fts3SegFilter *pFilter /* Restrictions on range of iteration */
127096: ){
127097: pCsr->pFilter = pFilter;
127098: return fts3SegReaderStart(p, pCsr, pFilter->zTerm, pFilter->nTerm);
127099: }
127100:
127101: SQLITE_PRIVATE int sqlite3Fts3MsrIncrStart(
127102: Fts3Table *p, /* Virtual table handle */
127103: Fts3MultiSegReader *pCsr, /* Cursor object */
127104: int iCol, /* Column to match on. */
127105: const char *zTerm, /* Term to iterate through a doclist for */
127106: int nTerm /* Number of bytes in zTerm */
127107: ){
127108: int i;
127109: int rc;
127110: int nSegment = pCsr->nSegment;
127111: int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = (
127112: p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp
127113: );
127114:
127115: assert( pCsr->pFilter==0 );
127116: assert( zTerm && nTerm>0 );
127117:
127118: /* Advance each segment iterator until it points to the term zTerm/nTerm. */
127119: rc = fts3SegReaderStart(p, pCsr, zTerm, nTerm);
127120: if( rc!=SQLITE_OK ) return rc;
127121:
127122: /* Determine how many of the segments actually point to zTerm/nTerm. */
127123: for(i=0; i<nSegment; i++){
127124: Fts3SegReader *pSeg = pCsr->apSegment[i];
127125: if( !pSeg->aNode || fts3SegReaderTermCmp(pSeg, zTerm, nTerm) ){
127126: break;
127127: }
127128: }
127129: pCsr->nAdvance = i;
127130:
127131: /* Advance each of the segments to point to the first docid. */
127132: for(i=0; i<pCsr->nAdvance; i++){
127133: rc = fts3SegReaderFirstDocid(p, pCsr->apSegment[i]);
127134: if( rc!=SQLITE_OK ) return rc;
127135: }
127136: fts3SegReaderSort(pCsr->apSegment, i, i, xCmp);
127137:
127138: assert( iCol<0 || iCol<p->nColumn );
127139: pCsr->iColFilter = iCol;
127140:
127141: return SQLITE_OK;
127142: }
127143:
127144: /*
127145: ** This function is called on a MultiSegReader that has been started using
127146: ** sqlite3Fts3MsrIncrStart(). One or more calls to MsrIncrNext() may also
127147: ** have been made. Calling this function puts the MultiSegReader in such
127148: ** a state that if the next two calls are:
127149: **
127150: ** sqlite3Fts3SegReaderStart()
127151: ** sqlite3Fts3SegReaderStep()
127152: **
127153: ** then the entire doclist for the term is available in
127154: ** MultiSegReader.aDoclist/nDoclist.
127155: */
127156: SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr){
127157: int i; /* Used to iterate through segment-readers */
127158:
127159: assert( pCsr->zTerm==0 );
127160: assert( pCsr->nTerm==0 );
127161: assert( pCsr->aDoclist==0 );
127162: assert( pCsr->nDoclist==0 );
127163:
127164: pCsr->nAdvance = 0;
127165: pCsr->bRestart = 1;
127166: for(i=0; i<pCsr->nSegment; i++){
127167: pCsr->apSegment[i]->pOffsetList = 0;
127168: pCsr->apSegment[i]->nOffsetList = 0;
127169: pCsr->apSegment[i]->iDocid = 0;
127170: }
127171:
127172: return SQLITE_OK;
127173: }
127174:
127175:
127176: SQLITE_PRIVATE int sqlite3Fts3SegReaderStep(
127177: Fts3Table *p, /* Virtual table handle */
127178: Fts3MultiSegReader *pCsr /* Cursor object */
127179: ){
127180: int rc = SQLITE_OK;
127181:
127182: int isIgnoreEmpty = (pCsr->pFilter->flags & FTS3_SEGMENT_IGNORE_EMPTY);
127183: int isRequirePos = (pCsr->pFilter->flags & FTS3_SEGMENT_REQUIRE_POS);
127184: int isColFilter = (pCsr->pFilter->flags & FTS3_SEGMENT_COLUMN_FILTER);
127185: int isPrefix = (pCsr->pFilter->flags & FTS3_SEGMENT_PREFIX);
127186: int isScan = (pCsr->pFilter->flags & FTS3_SEGMENT_SCAN);
127187: int isFirst = (pCsr->pFilter->flags & FTS3_SEGMENT_FIRST);
127188:
127189: Fts3SegReader **apSegment = pCsr->apSegment;
127190: int nSegment = pCsr->nSegment;
127191: Fts3SegFilter *pFilter = pCsr->pFilter;
127192: int (*xCmp)(Fts3SegReader *, Fts3SegReader *) = (
127193: p->bDescIdx ? fts3SegReaderDoclistCmpRev : fts3SegReaderDoclistCmp
127194: );
127195:
127196: if( pCsr->nSegment==0 ) return SQLITE_OK;
127197:
127198: do {
127199: int nMerge;
127200: int i;
127201:
127202: /* Advance the first pCsr->nAdvance entries in the apSegment[] array
127203: ** forward. Then sort the list in order of current term again.
127204: */
127205: for(i=0; i<pCsr->nAdvance; i++){
127206: rc = fts3SegReaderNext(p, apSegment[i], 0);
127207: if( rc!=SQLITE_OK ) return rc;
127208: }
127209: fts3SegReaderSort(apSegment, nSegment, pCsr->nAdvance, fts3SegReaderCmp);
127210: pCsr->nAdvance = 0;
127211:
127212: /* If all the seg-readers are at EOF, we're finished. return SQLITE_OK. */
127213: assert( rc==SQLITE_OK );
127214: if( apSegment[0]->aNode==0 ) break;
127215:
127216: pCsr->nTerm = apSegment[0]->nTerm;
127217: pCsr->zTerm = apSegment[0]->zTerm;
127218:
127219: /* If this is a prefix-search, and if the term that apSegment[0] points
127220: ** to does not share a suffix with pFilter->zTerm/nTerm, then all
127221: ** required callbacks have been made. In this case exit early.
127222: **
127223: ** Similarly, if this is a search for an exact match, and the first term
127224: ** of segment apSegment[0] is not a match, exit early.
127225: */
127226: if( pFilter->zTerm && !isScan ){
127227: if( pCsr->nTerm<pFilter->nTerm
127228: || (!isPrefix && pCsr->nTerm>pFilter->nTerm)
127229: || memcmp(pCsr->zTerm, pFilter->zTerm, pFilter->nTerm)
127230: ){
127231: break;
127232: }
127233: }
127234:
127235: nMerge = 1;
127236: while( nMerge<nSegment
127237: && apSegment[nMerge]->aNode
127238: && apSegment[nMerge]->nTerm==pCsr->nTerm
127239: && 0==memcmp(pCsr->zTerm, apSegment[nMerge]->zTerm, pCsr->nTerm)
127240: ){
127241: nMerge++;
127242: }
127243:
127244: assert( isIgnoreEmpty || (isRequirePos && !isColFilter) );
127245: if( nMerge==1
127246: && !isIgnoreEmpty
127247: && !isFirst
127248: && (p->bDescIdx==0 || fts3SegReaderIsPending(apSegment[0])==0)
127249: ){
127250: pCsr->nDoclist = apSegment[0]->nDoclist;
127251: if( fts3SegReaderIsPending(apSegment[0]) ){
127252: rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist, pCsr->nDoclist);
127253: pCsr->aDoclist = pCsr->aBuffer;
127254: }else{
127255: pCsr->aDoclist = apSegment[0]->aDoclist;
127256: }
127257: if( rc==SQLITE_OK ) rc = SQLITE_ROW;
127258: }else{
127259: int nDoclist = 0; /* Size of doclist */
127260: sqlite3_int64 iPrev = 0; /* Previous docid stored in doclist */
127261:
127262: /* The current term of the first nMerge entries in the array
127263: ** of Fts3SegReader objects is the same. The doclists must be merged
127264: ** and a single term returned with the merged doclist.
127265: */
127266: for(i=0; i<nMerge; i++){
127267: fts3SegReaderFirstDocid(p, apSegment[i]);
127268: }
127269: fts3SegReaderSort(apSegment, nMerge, nMerge, xCmp);
127270: while( apSegment[0]->pOffsetList ){
127271: int j; /* Number of segments that share a docid */
127272: char *pList;
127273: int nList;
127274: int nByte;
127275: sqlite3_int64 iDocid = apSegment[0]->iDocid;
127276: fts3SegReaderNextDocid(p, apSegment[0], &pList, &nList);
127277: j = 1;
127278: while( j<nMerge
127279: && apSegment[j]->pOffsetList
127280: && apSegment[j]->iDocid==iDocid
127281: ){
127282: fts3SegReaderNextDocid(p, apSegment[j], 0, 0);
127283: j++;
127284: }
127285:
127286: if( isColFilter ){
127287: fts3ColumnFilter(pFilter->iCol, &pList, &nList);
127288: }
127289:
127290: if( !isIgnoreEmpty || nList>0 ){
127291:
127292: /* Calculate the 'docid' delta value to write into the merged
127293: ** doclist. */
127294: sqlite3_int64 iDelta;
127295: if( p->bDescIdx && nDoclist>0 ){
127296: iDelta = iPrev - iDocid;
127297: }else{
127298: iDelta = iDocid - iPrev;
127299: }
127300: assert( iDelta>0 || (nDoclist==0 && iDelta==iDocid) );
127301: assert( nDoclist>0 || iDelta==iDocid );
127302:
127303: nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0);
127304: if( nDoclist+nByte>pCsr->nBuffer ){
127305: char *aNew;
127306: pCsr->nBuffer = (nDoclist+nByte)*2;
127307: aNew = sqlite3_realloc(pCsr->aBuffer, pCsr->nBuffer);
127308: if( !aNew ){
127309: return SQLITE_NOMEM;
127310: }
127311: pCsr->aBuffer = aNew;
127312: }
127313:
127314: if( isFirst ){
127315: char *a = &pCsr->aBuffer[nDoclist];
127316: int nWrite;
127317:
127318: nWrite = sqlite3Fts3FirstFilter(iDelta, pList, nList, a);
127319: if( nWrite ){
127320: iPrev = iDocid;
127321: nDoclist += nWrite;
127322: }
127323: }else{
127324: nDoclist += sqlite3Fts3PutVarint(&pCsr->aBuffer[nDoclist], iDelta);
127325: iPrev = iDocid;
127326: if( isRequirePos ){
127327: memcpy(&pCsr->aBuffer[nDoclist], pList, nList);
127328: nDoclist += nList;
127329: pCsr->aBuffer[nDoclist++] = '\0';
127330: }
127331: }
127332: }
127333:
127334: fts3SegReaderSort(apSegment, nMerge, j, xCmp);
127335: }
127336: if( nDoclist>0 ){
127337: pCsr->aDoclist = pCsr->aBuffer;
127338: pCsr->nDoclist = nDoclist;
127339: rc = SQLITE_ROW;
127340: }
127341: }
127342: pCsr->nAdvance = nMerge;
127343: }while( rc==SQLITE_OK );
127344:
127345: return rc;
127346: }
127347:
127348:
127349: SQLITE_PRIVATE void sqlite3Fts3SegReaderFinish(
127350: Fts3MultiSegReader *pCsr /* Cursor object */
127351: ){
127352: if( pCsr ){
127353: int i;
127354: for(i=0; i<pCsr->nSegment; i++){
127355: sqlite3Fts3SegReaderFree(pCsr->apSegment[i]);
127356: }
127357: sqlite3_free(pCsr->apSegment);
127358: sqlite3_free(pCsr->aBuffer);
127359:
127360: pCsr->nSegment = 0;
127361: pCsr->apSegment = 0;
127362: pCsr->aBuffer = 0;
127363: }
127364: }
127365:
127366: /*
127367: ** Merge all level iLevel segments in the database into a single
127368: ** iLevel+1 segment. Or, if iLevel<0, merge all segments into a
127369: ** single segment with a level equal to the numerically largest level
127370: ** currently present in the database.
127371: **
127372: ** If this function is called with iLevel<0, but there is only one
127373: ** segment in the database, SQLITE_DONE is returned immediately.
127374: ** Otherwise, if successful, SQLITE_OK is returned. If an error occurs,
127375: ** an SQLite error code is returned.
127376: */
127377: static int fts3SegmentMerge(Fts3Table *p, int iIndex, int iLevel){
127378: int rc; /* Return code */
127379: int iIdx = 0; /* Index of new segment */
127380: int iNewLevel = 0; /* Level/index to create new segment at */
127381: SegmentWriter *pWriter = 0; /* Used to write the new, merged, segment */
127382: Fts3SegFilter filter; /* Segment term filter condition */
127383: Fts3MultiSegReader csr; /* Cursor to iterate through level(s) */
127384: int bIgnoreEmpty = 0; /* True to ignore empty segments */
127385:
127386: assert( iLevel==FTS3_SEGCURSOR_ALL
127387: || iLevel==FTS3_SEGCURSOR_PENDING
127388: || iLevel>=0
127389: );
127390: assert( iLevel<FTS3_SEGDIR_MAXLEVEL );
127391: assert( iIndex>=0 && iIndex<p->nIndex );
127392:
127393: rc = sqlite3Fts3SegReaderCursor(p, iIndex, iLevel, 0, 0, 1, 0, &csr);
127394: if( rc!=SQLITE_OK || csr.nSegment==0 ) goto finished;
127395:
127396: if( iLevel==FTS3_SEGCURSOR_ALL ){
127397: /* This call is to merge all segments in the database to a single
127398: ** segment. The level of the new segment is equal to the the numerically
127399: ** greatest segment level currently present in the database for this
127400: ** index. The idx of the new segment is always 0. */
127401: if( csr.nSegment==1 ){
127402: rc = SQLITE_DONE;
127403: goto finished;
127404: }
127405: rc = fts3SegmentMaxLevel(p, iIndex, &iNewLevel);
127406: bIgnoreEmpty = 1;
127407:
127408: }else if( iLevel==FTS3_SEGCURSOR_PENDING ){
127409: iNewLevel = iIndex * FTS3_SEGDIR_MAXLEVEL;
127410: rc = fts3AllocateSegdirIdx(p, iIndex, 0, &iIdx);
127411: }else{
127412: /* This call is to merge all segments at level iLevel. find the next
127413: ** available segment index at level iLevel+1. The call to
127414: ** fts3AllocateSegdirIdx() will merge the segments at level iLevel+1 to
127415: ** a single iLevel+2 segment if necessary. */
127416: rc = fts3AllocateSegdirIdx(p, iIndex, iLevel+1, &iIdx);
127417: iNewLevel = iIndex * FTS3_SEGDIR_MAXLEVEL + iLevel+1;
127418: }
127419: if( rc!=SQLITE_OK ) goto finished;
127420: assert( csr.nSegment>0 );
127421: assert( iNewLevel>=(iIndex*FTS3_SEGDIR_MAXLEVEL) );
127422: assert( iNewLevel<((iIndex+1)*FTS3_SEGDIR_MAXLEVEL) );
127423:
127424: memset(&filter, 0, sizeof(Fts3SegFilter));
127425: filter.flags = FTS3_SEGMENT_REQUIRE_POS;
127426: filter.flags |= (bIgnoreEmpty ? FTS3_SEGMENT_IGNORE_EMPTY : 0);
127427:
127428: rc = sqlite3Fts3SegReaderStart(p, &csr, &filter);
127429: while( SQLITE_OK==rc ){
127430: rc = sqlite3Fts3SegReaderStep(p, &csr);
127431: if( rc!=SQLITE_ROW ) break;
127432: rc = fts3SegWriterAdd(p, &pWriter, 1,
127433: csr.zTerm, csr.nTerm, csr.aDoclist, csr.nDoclist);
127434: }
127435: if( rc!=SQLITE_OK ) goto finished;
127436: assert( pWriter );
127437:
127438: if( iLevel!=FTS3_SEGCURSOR_PENDING ){
127439: rc = fts3DeleteSegdir(p, iIndex, iLevel, csr.apSegment, csr.nSegment);
127440: if( rc!=SQLITE_OK ) goto finished;
127441: }
127442: rc = fts3SegWriterFlush(p, pWriter, iNewLevel, iIdx);
127443:
127444: finished:
127445: fts3SegWriterFree(pWriter);
127446: sqlite3Fts3SegReaderFinish(&csr);
127447: return rc;
127448: }
127449:
127450:
127451: /*
127452: ** Flush the contents of pendingTerms to level 0 segments.
127453: */
127454: SQLITE_PRIVATE int sqlite3Fts3PendingTermsFlush(Fts3Table *p){
127455: int rc = SQLITE_OK;
127456: int i;
127457: for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
127458: rc = fts3SegmentMerge(p, i, FTS3_SEGCURSOR_PENDING);
127459: if( rc==SQLITE_DONE ) rc = SQLITE_OK;
127460: }
127461: sqlite3Fts3PendingTermsClear(p);
127462: return rc;
127463: }
127464:
127465: /*
127466: ** Encode N integers as varints into a blob.
127467: */
127468: static void fts3EncodeIntArray(
127469: int N, /* The number of integers to encode */
127470: u32 *a, /* The integer values */
127471: char *zBuf, /* Write the BLOB here */
127472: int *pNBuf /* Write number of bytes if zBuf[] used here */
127473: ){
127474: int i, j;
127475: for(i=j=0; i<N; i++){
127476: j += sqlite3Fts3PutVarint(&zBuf[j], (sqlite3_int64)a[i]);
127477: }
127478: *pNBuf = j;
127479: }
127480:
127481: /*
127482: ** Decode a blob of varints into N integers
127483: */
127484: static void fts3DecodeIntArray(
127485: int N, /* The number of integers to decode */
127486: u32 *a, /* Write the integer values */
127487: const char *zBuf, /* The BLOB containing the varints */
127488: int nBuf /* size of the BLOB */
127489: ){
127490: int i, j;
127491: UNUSED_PARAMETER(nBuf);
127492: for(i=j=0; i<N; i++){
127493: sqlite3_int64 x;
127494: j += sqlite3Fts3GetVarint(&zBuf[j], &x);
127495: assert(j<=nBuf);
127496: a[i] = (u32)(x & 0xffffffff);
127497: }
127498: }
127499:
127500: /*
127501: ** Insert the sizes (in tokens) for each column of the document
127502: ** with docid equal to p->iPrevDocid. The sizes are encoded as
127503: ** a blob of varints.
127504: */
127505: static void fts3InsertDocsize(
127506: int *pRC, /* Result code */
127507: Fts3Table *p, /* Table into which to insert */
127508: u32 *aSz /* Sizes of each column, in tokens */
127509: ){
127510: char *pBlob; /* The BLOB encoding of the document size */
127511: int nBlob; /* Number of bytes in the BLOB */
127512: sqlite3_stmt *pStmt; /* Statement used to insert the encoding */
127513: int rc; /* Result code from subfunctions */
127514:
127515: if( *pRC ) return;
127516: pBlob = sqlite3_malloc( 10*p->nColumn );
127517: if( pBlob==0 ){
127518: *pRC = SQLITE_NOMEM;
127519: return;
127520: }
127521: fts3EncodeIntArray(p->nColumn, aSz, pBlob, &nBlob);
127522: rc = fts3SqlStmt(p, SQL_REPLACE_DOCSIZE, &pStmt, 0);
127523: if( rc ){
127524: sqlite3_free(pBlob);
127525: *pRC = rc;
127526: return;
127527: }
127528: sqlite3_bind_int64(pStmt, 1, p->iPrevDocid);
127529: sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, sqlite3_free);
127530: sqlite3_step(pStmt);
127531: *pRC = sqlite3_reset(pStmt);
127532: }
127533:
127534: /*
127535: ** Record 0 of the %_stat table contains a blob consisting of N varints,
127536: ** where N is the number of user defined columns in the fts3 table plus
127537: ** two. If nCol is the number of user defined columns, then values of the
127538: ** varints are set as follows:
127539: **
127540: ** Varint 0: Total number of rows in the table.
127541: **
127542: ** Varint 1..nCol: For each column, the total number of tokens stored in
127543: ** the column for all rows of the table.
127544: **
127545: ** Varint 1+nCol: The total size, in bytes, of all text values in all
127546: ** columns of all rows of the table.
127547: **
127548: */
127549: static void fts3UpdateDocTotals(
127550: int *pRC, /* The result code */
127551: Fts3Table *p, /* Table being updated */
127552: u32 *aSzIns, /* Size increases */
127553: u32 *aSzDel, /* Size decreases */
127554: int nChng /* Change in the number of documents */
127555: ){
127556: char *pBlob; /* Storage for BLOB written into %_stat */
127557: int nBlob; /* Size of BLOB written into %_stat */
127558: u32 *a; /* Array of integers that becomes the BLOB */
127559: sqlite3_stmt *pStmt; /* Statement for reading and writing */
127560: int i; /* Loop counter */
127561: int rc; /* Result code from subfunctions */
127562:
127563: const int nStat = p->nColumn+2;
127564:
127565: if( *pRC ) return;
127566: a = sqlite3_malloc( (sizeof(u32)+10)*nStat );
127567: if( a==0 ){
127568: *pRC = SQLITE_NOMEM;
127569: return;
127570: }
127571: pBlob = (char*)&a[nStat];
127572: rc = fts3SqlStmt(p, SQL_SELECT_DOCTOTAL, &pStmt, 0);
127573: if( rc ){
127574: sqlite3_free(a);
127575: *pRC = rc;
127576: return;
127577: }
127578: if( sqlite3_step(pStmt)==SQLITE_ROW ){
127579: fts3DecodeIntArray(nStat, a,
127580: sqlite3_column_blob(pStmt, 0),
127581: sqlite3_column_bytes(pStmt, 0));
127582: }else{
127583: memset(a, 0, sizeof(u32)*(nStat) );
127584: }
127585: sqlite3_reset(pStmt);
127586: if( nChng<0 && a[0]<(u32)(-nChng) ){
127587: a[0] = 0;
127588: }else{
127589: a[0] += nChng;
127590: }
127591: for(i=0; i<p->nColumn+1; i++){
127592: u32 x = a[i+1];
127593: if( x+aSzIns[i] < aSzDel[i] ){
127594: x = 0;
127595: }else{
127596: x = x + aSzIns[i] - aSzDel[i];
127597: }
127598: a[i+1] = x;
127599: }
127600: fts3EncodeIntArray(nStat, a, pBlob, &nBlob);
127601: rc = fts3SqlStmt(p, SQL_REPLACE_DOCTOTAL, &pStmt, 0);
127602: if( rc ){
127603: sqlite3_free(a);
127604: *pRC = rc;
127605: return;
127606: }
127607: sqlite3_bind_blob(pStmt, 1, pBlob, nBlob, SQLITE_STATIC);
127608: sqlite3_step(pStmt);
127609: *pRC = sqlite3_reset(pStmt);
127610: sqlite3_free(a);
127611: }
127612:
127613: static int fts3DoOptimize(Fts3Table *p, int bReturnDone){
127614: int i;
127615: int bSeenDone = 0;
127616: int rc = SQLITE_OK;
127617: for(i=0; rc==SQLITE_OK && i<p->nIndex; i++){
127618: rc = fts3SegmentMerge(p, i, FTS3_SEGCURSOR_ALL);
127619: if( rc==SQLITE_DONE ){
127620: bSeenDone = 1;
127621: rc = SQLITE_OK;
127622: }
127623: }
127624: sqlite3Fts3SegmentsClose(p);
127625: sqlite3Fts3PendingTermsClear(p);
127626:
127627: return (rc==SQLITE_OK && bReturnDone && bSeenDone) ? SQLITE_DONE : rc;
127628: }
127629:
127630: /*
127631: ** This function is called when the user executes the following statement:
127632: **
127633: ** INSERT INTO <tbl>(<tbl>) VALUES('rebuild');
127634: **
127635: ** The entire FTS index is discarded and rebuilt. If the table is one
127636: ** created using the content=xxx option, then the new index is based on
127637: ** the current contents of the xxx table. Otherwise, it is rebuilt based
127638: ** on the contents of the %_content table.
127639: */
127640: static int fts3DoRebuild(Fts3Table *p){
127641: int rc; /* Return Code */
127642:
127643: rc = fts3DeleteAll(p, 0);
127644: if( rc==SQLITE_OK ){
127645: u32 *aSz = 0;
127646: u32 *aSzIns = 0;
127647: u32 *aSzDel = 0;
127648: sqlite3_stmt *pStmt = 0;
127649: int nEntry = 0;
127650:
127651: /* Compose and prepare an SQL statement to loop through the content table */
127652: char *zSql = sqlite3_mprintf("SELECT %s" , p->zReadExprlist);
127653: if( !zSql ){
127654: rc = SQLITE_NOMEM;
127655: }else{
127656: rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
127657: sqlite3_free(zSql);
127658: }
127659:
127660: if( rc==SQLITE_OK ){
127661: int nByte = sizeof(u32) * (p->nColumn+1)*3;
127662: aSz = (u32 *)sqlite3_malloc(nByte);
127663: if( aSz==0 ){
127664: rc = SQLITE_NOMEM;
127665: }else{
127666: memset(aSz, 0, nByte);
127667: aSzIns = &aSz[p->nColumn+1];
127668: aSzDel = &aSzIns[p->nColumn+1];
127669: }
127670: }
127671:
127672: while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
127673: int iCol;
127674: rc = fts3PendingTermsDocid(p, sqlite3_column_int64(pStmt, 0));
127675: aSz[p->nColumn] = 0;
127676: for(iCol=0; rc==SQLITE_OK && iCol<p->nColumn; iCol++){
127677: const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
127678: rc = fts3PendingTermsAdd(p, z, iCol, &aSz[iCol]);
127679: aSz[p->nColumn] += sqlite3_column_bytes(pStmt, iCol+1);
127680: }
127681: if( p->bHasDocsize ){
127682: fts3InsertDocsize(&rc, p, aSz);
127683: }
127684: if( rc!=SQLITE_OK ){
127685: sqlite3_finalize(pStmt);
127686: pStmt = 0;
127687: }else{
127688: nEntry++;
127689: for(iCol=0; iCol<=p->nColumn; iCol++){
127690: aSzIns[iCol] += aSz[iCol];
127691: }
127692: }
127693: }
127694: if( p->bHasStat ){
127695: fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nEntry);
127696: }
127697: sqlite3_free(aSz);
127698:
127699: if( pStmt ){
127700: int rc2 = sqlite3_finalize(pStmt);
127701: if( rc==SQLITE_OK ){
127702: rc = rc2;
127703: }
127704: }
127705: }
127706:
127707: return rc;
127708: }
127709:
127710: /*
127711: ** Handle a 'special' INSERT of the form:
127712: **
127713: ** "INSERT INTO tbl(tbl) VALUES(<expr>)"
127714: **
127715: ** Argument pVal contains the result of <expr>. Currently the only
127716: ** meaningful value to insert is the text 'optimize'.
127717: */
127718: static int fts3SpecialInsert(Fts3Table *p, sqlite3_value *pVal){
127719: int rc; /* Return Code */
127720: const char *zVal = (const char *)sqlite3_value_text(pVal);
127721: int nVal = sqlite3_value_bytes(pVal);
127722:
127723: if( !zVal ){
127724: return SQLITE_NOMEM;
127725: }else if( nVal==8 && 0==sqlite3_strnicmp(zVal, "optimize", 8) ){
127726: rc = fts3DoOptimize(p, 0);
127727: }else if( nVal==7 && 0==sqlite3_strnicmp(zVal, "rebuild", 7) ){
127728: rc = fts3DoRebuild(p);
127729: #ifdef SQLITE_TEST
127730: }else if( nVal>9 && 0==sqlite3_strnicmp(zVal, "nodesize=", 9) ){
127731: p->nNodeSize = atoi(&zVal[9]);
127732: rc = SQLITE_OK;
127733: }else if( nVal>11 && 0==sqlite3_strnicmp(zVal, "maxpending=", 9) ){
127734: p->nMaxPendingData = atoi(&zVal[11]);
127735: rc = SQLITE_OK;
127736: #endif
127737: }else{
127738: rc = SQLITE_ERROR;
127739: }
127740:
127741: return rc;
127742: }
127743:
127744: /*
127745: ** Delete all cached deferred doclists. Deferred doclists are cached
127746: ** (allocated) by the sqlite3Fts3CacheDeferredDoclists() function.
127747: */
127748: SQLITE_PRIVATE void sqlite3Fts3FreeDeferredDoclists(Fts3Cursor *pCsr){
127749: Fts3DeferredToken *pDef;
127750: for(pDef=pCsr->pDeferred; pDef; pDef=pDef->pNext){
127751: fts3PendingListDelete(pDef->pList);
127752: pDef->pList = 0;
127753: }
127754: }
127755:
127756: /*
127757: ** Free all entries in the pCsr->pDeffered list. Entries are added to
127758: ** this list using sqlite3Fts3DeferToken().
127759: */
127760: SQLITE_PRIVATE void sqlite3Fts3FreeDeferredTokens(Fts3Cursor *pCsr){
127761: Fts3DeferredToken *pDef;
127762: Fts3DeferredToken *pNext;
127763: for(pDef=pCsr->pDeferred; pDef; pDef=pNext){
127764: pNext = pDef->pNext;
127765: fts3PendingListDelete(pDef->pList);
127766: sqlite3_free(pDef);
127767: }
127768: pCsr->pDeferred = 0;
127769: }
127770:
127771: /*
127772: ** Generate deferred-doclists for all tokens in the pCsr->pDeferred list
127773: ** based on the row that pCsr currently points to.
127774: **
127775: ** A deferred-doclist is like any other doclist with position information
127776: ** included, except that it only contains entries for a single row of the
127777: ** table, not for all rows.
127778: */
127779: SQLITE_PRIVATE int sqlite3Fts3CacheDeferredDoclists(Fts3Cursor *pCsr){
127780: int rc = SQLITE_OK; /* Return code */
127781: if( pCsr->pDeferred ){
127782: int i; /* Used to iterate through table columns */
127783: sqlite3_int64 iDocid; /* Docid of the row pCsr points to */
127784: Fts3DeferredToken *pDef; /* Used to iterate through deferred tokens */
127785:
127786: Fts3Table *p = (Fts3Table *)pCsr->base.pVtab;
127787: sqlite3_tokenizer *pT = p->pTokenizer;
127788: sqlite3_tokenizer_module const *pModule = pT->pModule;
127789:
127790: assert( pCsr->isRequireSeek==0 );
127791: iDocid = sqlite3_column_int64(pCsr->pStmt, 0);
127792:
127793: for(i=0; i<p->nColumn && rc==SQLITE_OK; i++){
127794: const char *zText = (const char *)sqlite3_column_text(pCsr->pStmt, i+1);
127795: sqlite3_tokenizer_cursor *pTC = 0;
127796:
127797: rc = pModule->xOpen(pT, zText, -1, &pTC);
127798: while( rc==SQLITE_OK ){
127799: char const *zToken; /* Buffer containing token */
127800: int nToken; /* Number of bytes in token */
127801: int iDum1, iDum2; /* Dummy variables */
127802: int iPos; /* Position of token in zText */
127803:
127804: pTC->pTokenizer = pT;
127805: rc = pModule->xNext(pTC, &zToken, &nToken, &iDum1, &iDum2, &iPos);
127806: for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
127807: Fts3PhraseToken *pPT = pDef->pToken;
127808: if( (pDef->iCol>=p->nColumn || pDef->iCol==i)
127809: && (pPT->bFirst==0 || iPos==0)
127810: && (pPT->n==nToken || (pPT->isPrefix && pPT->n<nToken))
127811: && (0==memcmp(zToken, pPT->z, pPT->n))
127812: ){
127813: fts3PendingListAppend(&pDef->pList, iDocid, i, iPos, &rc);
127814: }
127815: }
127816: }
127817: if( pTC ) pModule->xClose(pTC);
127818: if( rc==SQLITE_DONE ) rc = SQLITE_OK;
127819: }
127820:
127821: for(pDef=pCsr->pDeferred; pDef && rc==SQLITE_OK; pDef=pDef->pNext){
127822: if( pDef->pList ){
127823: rc = fts3PendingListAppendVarint(&pDef->pList, 0);
127824: }
127825: }
127826: }
127827:
127828: return rc;
127829: }
127830:
127831: SQLITE_PRIVATE int sqlite3Fts3DeferredTokenList(
127832: Fts3DeferredToken *p,
127833: char **ppData,
127834: int *pnData
127835: ){
127836: char *pRet;
127837: int nSkip;
127838: sqlite3_int64 dummy;
127839:
127840: *ppData = 0;
127841: *pnData = 0;
127842:
127843: if( p->pList==0 ){
127844: return SQLITE_OK;
127845: }
127846:
127847: pRet = (char *)sqlite3_malloc(p->pList->nData);
127848: if( !pRet ) return SQLITE_NOMEM;
127849:
127850: nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy);
127851: *pnData = p->pList->nData - nSkip;
127852: *ppData = pRet;
127853:
127854: memcpy(pRet, &p->pList->aData[nSkip], *pnData);
127855: return SQLITE_OK;
127856: }
127857:
127858: /*
127859: ** Add an entry for token pToken to the pCsr->pDeferred list.
127860: */
127861: SQLITE_PRIVATE int sqlite3Fts3DeferToken(
127862: Fts3Cursor *pCsr, /* Fts3 table cursor */
127863: Fts3PhraseToken *pToken, /* Token to defer */
127864: int iCol /* Column that token must appear in (or -1) */
127865: ){
127866: Fts3DeferredToken *pDeferred;
127867: pDeferred = sqlite3_malloc(sizeof(*pDeferred));
127868: if( !pDeferred ){
127869: return SQLITE_NOMEM;
127870: }
127871: memset(pDeferred, 0, sizeof(*pDeferred));
127872: pDeferred->pToken = pToken;
127873: pDeferred->pNext = pCsr->pDeferred;
127874: pDeferred->iCol = iCol;
127875: pCsr->pDeferred = pDeferred;
127876:
127877: assert( pToken->pDeferred==0 );
127878: pToken->pDeferred = pDeferred;
127879:
127880: return SQLITE_OK;
127881: }
127882:
127883: /*
127884: ** SQLite value pRowid contains the rowid of a row that may or may not be
127885: ** present in the FTS3 table. If it is, delete it and adjust the contents
127886: ** of subsiduary data structures accordingly.
127887: */
127888: static int fts3DeleteByRowid(
127889: Fts3Table *p,
127890: sqlite3_value *pRowid,
127891: int *pnDoc,
127892: u32 *aSzDel
127893: ){
127894: int isEmpty = 0;
127895: int rc = fts3IsEmpty(p, pRowid, &isEmpty);
127896: if( rc==SQLITE_OK ){
127897: if( isEmpty ){
127898: /* Deleting this row means the whole table is empty. In this case
127899: ** delete the contents of all three tables and throw away any
127900: ** data in the pendingTerms hash table. */
127901: rc = fts3DeleteAll(p, 1);
127902: *pnDoc = *pnDoc - 1;
127903: }else{
127904: sqlite3_int64 iRemove = sqlite3_value_int64(pRowid);
127905: rc = fts3PendingTermsDocid(p, iRemove);
127906: fts3DeleteTerms(&rc, p, pRowid, aSzDel);
127907: if( p->zContentTbl==0 ){
127908: fts3SqlExec(&rc, p, SQL_DELETE_CONTENT, &pRowid);
127909: if( sqlite3_changes(p->db) ) *pnDoc = *pnDoc - 1;
127910: }else{
127911: *pnDoc = *pnDoc - 1;
127912: }
127913: if( p->bHasDocsize ){
127914: fts3SqlExec(&rc, p, SQL_DELETE_DOCSIZE, &pRowid);
127915: }
127916: }
127917: }
127918:
127919: return rc;
127920: }
127921:
127922: /*
127923: ** This function does the work for the xUpdate method of FTS3 virtual
127924: ** tables.
127925: */
127926: SQLITE_PRIVATE int sqlite3Fts3UpdateMethod(
127927: sqlite3_vtab *pVtab, /* FTS3 vtab object */
127928: int nArg, /* Size of argument array */
127929: sqlite3_value **apVal, /* Array of arguments */
127930: sqlite_int64 *pRowid /* OUT: The affected (or effected) rowid */
127931: ){
127932: Fts3Table *p = (Fts3Table *)pVtab;
127933: int rc = SQLITE_OK; /* Return Code */
127934: int isRemove = 0; /* True for an UPDATE or DELETE */
127935: u32 *aSzIns = 0; /* Sizes of inserted documents */
127936: u32 *aSzDel; /* Sizes of deleted documents */
127937: int nChng = 0; /* Net change in number of documents */
127938: int bInsertDone = 0;
127939:
127940: assert( p->pSegments==0 );
127941:
127942: /* Check for a "special" INSERT operation. One of the form:
127943: **
127944: ** INSERT INTO xyz(xyz) VALUES('command');
127945: */
127946: if( nArg>1
127947: && sqlite3_value_type(apVal[0])==SQLITE_NULL
127948: && sqlite3_value_type(apVal[p->nColumn+2])!=SQLITE_NULL
127949: ){
127950: rc = fts3SpecialInsert(p, apVal[p->nColumn+2]);
127951: goto update_out;
127952: }
127953:
127954: /* Allocate space to hold the change in document sizes */
127955: aSzIns = sqlite3_malloc( sizeof(aSzIns[0])*(p->nColumn+1)*2 );
127956: if( aSzIns==0 ){
127957: rc = SQLITE_NOMEM;
127958: goto update_out;
127959: }
127960: aSzDel = &aSzIns[p->nColumn+1];
127961: memset(aSzIns, 0, sizeof(aSzIns[0])*(p->nColumn+1)*2);
127962:
127963: /* If this is an INSERT operation, or an UPDATE that modifies the rowid
127964: ** value, then this operation requires constraint handling.
127965: **
127966: ** If the on-conflict mode is REPLACE, this means that the existing row
127967: ** should be deleted from the database before inserting the new row. Or,
127968: ** if the on-conflict mode is other than REPLACE, then this method must
127969: ** detect the conflict and return SQLITE_CONSTRAINT before beginning to
127970: ** modify the database file.
127971: */
127972: if( nArg>1 && p->zContentTbl==0 ){
127973: /* Find the value object that holds the new rowid value. */
127974: sqlite3_value *pNewRowid = apVal[3+p->nColumn];
127975: if( sqlite3_value_type(pNewRowid)==SQLITE_NULL ){
127976: pNewRowid = apVal[1];
127977: }
127978:
127979: if( sqlite3_value_type(pNewRowid)!=SQLITE_NULL && (
127980: sqlite3_value_type(apVal[0])==SQLITE_NULL
127981: || sqlite3_value_int64(apVal[0])!=sqlite3_value_int64(pNewRowid)
127982: )){
127983: /* The new rowid is not NULL (in this case the rowid will be
127984: ** automatically assigned and there is no chance of a conflict), and
127985: ** the statement is either an INSERT or an UPDATE that modifies the
127986: ** rowid column. So if the conflict mode is REPLACE, then delete any
127987: ** existing row with rowid=pNewRowid.
127988: **
127989: ** Or, if the conflict mode is not REPLACE, insert the new record into
127990: ** the %_content table. If we hit the duplicate rowid constraint (or any
127991: ** other error) while doing so, return immediately.
127992: **
127993: ** This branch may also run if pNewRowid contains a value that cannot
127994: ** be losslessly converted to an integer. In this case, the eventual
127995: ** call to fts3InsertData() (either just below or further on in this
127996: ** function) will return SQLITE_MISMATCH. If fts3DeleteByRowid is
127997: ** invoked, it will delete zero rows (since no row will have
127998: ** docid=$pNewRowid if $pNewRowid is not an integer value).
127999: */
128000: if( sqlite3_vtab_on_conflict(p->db)==SQLITE_REPLACE ){
128001: rc = fts3DeleteByRowid(p, pNewRowid, &nChng, aSzDel);
128002: }else{
128003: rc = fts3InsertData(p, apVal, pRowid);
128004: bInsertDone = 1;
128005: }
128006: }
128007: }
128008: if( rc!=SQLITE_OK ){
128009: goto update_out;
128010: }
128011:
128012: /* If this is a DELETE or UPDATE operation, remove the old record. */
128013: if( sqlite3_value_type(apVal[0])!=SQLITE_NULL ){
128014: assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER );
128015: rc = fts3DeleteByRowid(p, apVal[0], &nChng, aSzDel);
128016: isRemove = 1;
128017: }
128018:
128019: /* If this is an INSERT or UPDATE operation, insert the new record. */
128020: if( nArg>1 && rc==SQLITE_OK ){
128021: if( bInsertDone==0 ){
128022: rc = fts3InsertData(p, apVal, pRowid);
128023: if( rc==SQLITE_CONSTRAINT && p->zContentTbl==0 ){
128024: rc = FTS_CORRUPT_VTAB;
128025: }
128026: }
128027: if( rc==SQLITE_OK && (!isRemove || *pRowid!=p->iPrevDocid ) ){
128028: rc = fts3PendingTermsDocid(p, *pRowid);
128029: }
128030: if( rc==SQLITE_OK ){
128031: assert( p->iPrevDocid==*pRowid );
128032: rc = fts3InsertTerms(p, apVal, aSzIns);
128033: }
128034: if( p->bHasDocsize ){
128035: fts3InsertDocsize(&rc, p, aSzIns);
128036: }
128037: nChng++;
128038: }
128039:
128040: if( p->bHasStat ){
128041: fts3UpdateDocTotals(&rc, p, aSzIns, aSzDel, nChng);
128042: }
128043:
128044: update_out:
128045: sqlite3_free(aSzIns);
128046: sqlite3Fts3SegmentsClose(p);
128047: return rc;
128048: }
128049:
128050: /*
128051: ** Flush any data in the pending-terms hash table to disk. If successful,
128052: ** merge all segments in the database (including the new segment, if
128053: ** there was any data to flush) into a single segment.
128054: */
128055: SQLITE_PRIVATE int sqlite3Fts3Optimize(Fts3Table *p){
128056: int rc;
128057: rc = sqlite3_exec(p->db, "SAVEPOINT fts3", 0, 0, 0);
128058: if( rc==SQLITE_OK ){
128059: rc = fts3DoOptimize(p, 1);
128060: if( rc==SQLITE_OK || rc==SQLITE_DONE ){
128061: int rc2 = sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0);
128062: if( rc2!=SQLITE_OK ) rc = rc2;
128063: }else{
128064: sqlite3_exec(p->db, "ROLLBACK TO fts3", 0, 0, 0);
128065: sqlite3_exec(p->db, "RELEASE fts3", 0, 0, 0);
128066: }
128067: }
128068: sqlite3Fts3SegmentsClose(p);
128069: return rc;
128070: }
128071:
128072: #endif
128073:
128074: /************** End of fts3_write.c ******************************************/
128075: /************** Begin file fts3_snippet.c ************************************/
128076: /*
128077: ** 2009 Oct 23
128078: **
128079: ** The author disclaims copyright to this source code. In place of
128080: ** a legal notice, here is a blessing:
128081: **
128082: ** May you do good and not evil.
128083: ** May you find forgiveness for yourself and forgive others.
128084: ** May you share freely, never taking more than you give.
128085: **
128086: ******************************************************************************
128087: */
128088:
128089: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
128090:
128091: /* #include <string.h> */
128092: /* #include <assert.h> */
128093:
128094: /*
128095: ** Characters that may appear in the second argument to matchinfo().
128096: */
128097: #define FTS3_MATCHINFO_NPHRASE 'p' /* 1 value */
128098: #define FTS3_MATCHINFO_NCOL 'c' /* 1 value */
128099: #define FTS3_MATCHINFO_NDOC 'n' /* 1 value */
128100: #define FTS3_MATCHINFO_AVGLENGTH 'a' /* nCol values */
128101: #define FTS3_MATCHINFO_LENGTH 'l' /* nCol values */
128102: #define FTS3_MATCHINFO_LCS 's' /* nCol values */
128103: #define FTS3_MATCHINFO_HITS 'x' /* 3*nCol*nPhrase values */
128104:
128105: /*
128106: ** The default value for the second argument to matchinfo().
128107: */
128108: #define FTS3_MATCHINFO_DEFAULT "pcx"
128109:
128110:
128111: /*
128112: ** Used as an fts3ExprIterate() context when loading phrase doclists to
128113: ** Fts3Expr.aDoclist[]/nDoclist.
128114: */
128115: typedef struct LoadDoclistCtx LoadDoclistCtx;
128116: struct LoadDoclistCtx {
128117: Fts3Cursor *pCsr; /* FTS3 Cursor */
128118: int nPhrase; /* Number of phrases seen so far */
128119: int nToken; /* Number of tokens seen so far */
128120: };
128121:
128122: /*
128123: ** The following types are used as part of the implementation of the
128124: ** fts3BestSnippet() routine.
128125: */
128126: typedef struct SnippetIter SnippetIter;
128127: typedef struct SnippetPhrase SnippetPhrase;
128128: typedef struct SnippetFragment SnippetFragment;
128129:
128130: struct SnippetIter {
128131: Fts3Cursor *pCsr; /* Cursor snippet is being generated from */
128132: int iCol; /* Extract snippet from this column */
128133: int nSnippet; /* Requested snippet length (in tokens) */
128134: int nPhrase; /* Number of phrases in query */
128135: SnippetPhrase *aPhrase; /* Array of size nPhrase */
128136: int iCurrent; /* First token of current snippet */
128137: };
128138:
128139: struct SnippetPhrase {
128140: int nToken; /* Number of tokens in phrase */
128141: char *pList; /* Pointer to start of phrase position list */
128142: int iHead; /* Next value in position list */
128143: char *pHead; /* Position list data following iHead */
128144: int iTail; /* Next value in trailing position list */
128145: char *pTail; /* Position list data following iTail */
128146: };
128147:
128148: struct SnippetFragment {
128149: int iCol; /* Column snippet is extracted from */
128150: int iPos; /* Index of first token in snippet */
128151: u64 covered; /* Mask of query phrases covered */
128152: u64 hlmask; /* Mask of snippet terms to highlight */
128153: };
128154:
128155: /*
128156: ** This type is used as an fts3ExprIterate() context object while
128157: ** accumulating the data returned by the matchinfo() function.
128158: */
128159: typedef struct MatchInfo MatchInfo;
128160: struct MatchInfo {
128161: Fts3Cursor *pCursor; /* FTS3 Cursor */
128162: int nCol; /* Number of columns in table */
128163: int nPhrase; /* Number of matchable phrases in query */
128164: sqlite3_int64 nDoc; /* Number of docs in database */
128165: u32 *aMatchinfo; /* Pre-allocated buffer */
128166: };
128167:
128168:
128169:
128170: /*
128171: ** The snippet() and offsets() functions both return text values. An instance
128172: ** of the following structure is used to accumulate those values while the
128173: ** functions are running. See fts3StringAppend() for details.
128174: */
128175: typedef struct StrBuffer StrBuffer;
128176: struct StrBuffer {
128177: char *z; /* Pointer to buffer containing string */
128178: int n; /* Length of z in bytes (excl. nul-term) */
128179: int nAlloc; /* Allocated size of buffer z in bytes */
128180: };
128181:
128182:
128183: /*
128184: ** This function is used to help iterate through a position-list. A position
128185: ** list is a list of unique integers, sorted from smallest to largest. Each
128186: ** element of the list is represented by an FTS3 varint that takes the value
128187: ** of the difference between the current element and the previous one plus
128188: ** two. For example, to store the position-list:
128189: **
128190: ** 4 9 113
128191: **
128192: ** the three varints:
128193: **
128194: ** 6 7 106
128195: **
128196: ** are encoded.
128197: **
128198: ** When this function is called, *pp points to the start of an element of
128199: ** the list. *piPos contains the value of the previous entry in the list.
128200: ** After it returns, *piPos contains the value of the next element of the
128201: ** list and *pp is advanced to the following varint.
128202: */
128203: static void fts3GetDeltaPosition(char **pp, int *piPos){
128204: int iVal;
128205: *pp += sqlite3Fts3GetVarint32(*pp, &iVal);
128206: *piPos += (iVal-2);
128207: }
128208:
128209: /*
128210: ** Helper function for fts3ExprIterate() (see below).
128211: */
128212: static int fts3ExprIterate2(
128213: Fts3Expr *pExpr, /* Expression to iterate phrases of */
128214: int *piPhrase, /* Pointer to phrase counter */
128215: int (*x)(Fts3Expr*,int,void*), /* Callback function to invoke for phrases */
128216: void *pCtx /* Second argument to pass to callback */
128217: ){
128218: int rc; /* Return code */
128219: int eType = pExpr->eType; /* Type of expression node pExpr */
128220:
128221: if( eType!=FTSQUERY_PHRASE ){
128222: assert( pExpr->pLeft && pExpr->pRight );
128223: rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
128224: if( rc==SQLITE_OK && eType!=FTSQUERY_NOT ){
128225: rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
128226: }
128227: }else{
128228: rc = x(pExpr, *piPhrase, pCtx);
128229: (*piPhrase)++;
128230: }
128231: return rc;
128232: }
128233:
128234: /*
128235: ** Iterate through all phrase nodes in an FTS3 query, except those that
128236: ** are part of a sub-tree that is the right-hand-side of a NOT operator.
128237: ** For each phrase node found, the supplied callback function is invoked.
128238: **
128239: ** If the callback function returns anything other than SQLITE_OK,
128240: ** the iteration is abandoned and the error code returned immediately.
128241: ** Otherwise, SQLITE_OK is returned after a callback has been made for
128242: ** all eligible phrase nodes.
128243: */
128244: static int fts3ExprIterate(
128245: Fts3Expr *pExpr, /* Expression to iterate phrases of */
128246: int (*x)(Fts3Expr*,int,void*), /* Callback function to invoke for phrases */
128247: void *pCtx /* Second argument to pass to callback */
128248: ){
128249: int iPhrase = 0; /* Variable used as the phrase counter */
128250: return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
128251: }
128252:
128253: /*
128254: ** This is an fts3ExprIterate() callback used while loading the doclists
128255: ** for each phrase into Fts3Expr.aDoclist[]/nDoclist. See also
128256: ** fts3ExprLoadDoclists().
128257: */
128258: static int fts3ExprLoadDoclistsCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
128259: int rc = SQLITE_OK;
128260: Fts3Phrase *pPhrase = pExpr->pPhrase;
128261: LoadDoclistCtx *p = (LoadDoclistCtx *)ctx;
128262:
128263: UNUSED_PARAMETER(iPhrase);
128264:
128265: p->nPhrase++;
128266: p->nToken += pPhrase->nToken;
128267:
128268: return rc;
128269: }
128270:
128271: /*
128272: ** Load the doclists for each phrase in the query associated with FTS3 cursor
128273: ** pCsr.
128274: **
128275: ** If pnPhrase is not NULL, then *pnPhrase is set to the number of matchable
128276: ** phrases in the expression (all phrases except those directly or
128277: ** indirectly descended from the right-hand-side of a NOT operator). If
128278: ** pnToken is not NULL, then it is set to the number of tokens in all
128279: ** matchable phrases of the expression.
128280: */
128281: static int fts3ExprLoadDoclists(
128282: Fts3Cursor *pCsr, /* Fts3 cursor for current query */
128283: int *pnPhrase, /* OUT: Number of phrases in query */
128284: int *pnToken /* OUT: Number of tokens in query */
128285: ){
128286: int rc; /* Return Code */
128287: LoadDoclistCtx sCtx = {0,0,0}; /* Context for fts3ExprIterate() */
128288: sCtx.pCsr = pCsr;
128289: rc = fts3ExprIterate(pCsr->pExpr, fts3ExprLoadDoclistsCb, (void *)&sCtx);
128290: if( pnPhrase ) *pnPhrase = sCtx.nPhrase;
128291: if( pnToken ) *pnToken = sCtx.nToken;
128292: return rc;
128293: }
128294:
128295: static int fts3ExprPhraseCountCb(Fts3Expr *pExpr, int iPhrase, void *ctx){
128296: (*(int *)ctx)++;
128297: UNUSED_PARAMETER(pExpr);
128298: UNUSED_PARAMETER(iPhrase);
128299: return SQLITE_OK;
128300: }
128301: static int fts3ExprPhraseCount(Fts3Expr *pExpr){
128302: int nPhrase = 0;
128303: (void)fts3ExprIterate(pExpr, fts3ExprPhraseCountCb, (void *)&nPhrase);
128304: return nPhrase;
128305: }
128306:
128307: /*
128308: ** Advance the position list iterator specified by the first two
128309: ** arguments so that it points to the first element with a value greater
128310: ** than or equal to parameter iNext.
128311: */
128312: static void fts3SnippetAdvance(char **ppIter, int *piIter, int iNext){
128313: char *pIter = *ppIter;
128314: if( pIter ){
128315: int iIter = *piIter;
128316:
128317: while( iIter<iNext ){
128318: if( 0==(*pIter & 0xFE) ){
128319: iIter = -1;
128320: pIter = 0;
128321: break;
128322: }
128323: fts3GetDeltaPosition(&pIter, &iIter);
128324: }
128325:
128326: *piIter = iIter;
128327: *ppIter = pIter;
128328: }
128329: }
128330:
128331: /*
128332: ** Advance the snippet iterator to the next candidate snippet.
128333: */
128334: static int fts3SnippetNextCandidate(SnippetIter *pIter){
128335: int i; /* Loop counter */
128336:
128337: if( pIter->iCurrent<0 ){
128338: /* The SnippetIter object has just been initialized. The first snippet
128339: ** candidate always starts at offset 0 (even if this candidate has a
128340: ** score of 0.0).
128341: */
128342: pIter->iCurrent = 0;
128343:
128344: /* Advance the 'head' iterator of each phrase to the first offset that
128345: ** is greater than or equal to (iNext+nSnippet).
128346: */
128347: for(i=0; i<pIter->nPhrase; i++){
128348: SnippetPhrase *pPhrase = &pIter->aPhrase[i];
128349: fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, pIter->nSnippet);
128350: }
128351: }else{
128352: int iStart;
128353: int iEnd = 0x7FFFFFFF;
128354:
128355: for(i=0; i<pIter->nPhrase; i++){
128356: SnippetPhrase *pPhrase = &pIter->aPhrase[i];
128357: if( pPhrase->pHead && pPhrase->iHead<iEnd ){
128358: iEnd = pPhrase->iHead;
128359: }
128360: }
128361: if( iEnd==0x7FFFFFFF ){
128362: return 1;
128363: }
128364:
128365: pIter->iCurrent = iStart = iEnd - pIter->nSnippet + 1;
128366: for(i=0; i<pIter->nPhrase; i++){
128367: SnippetPhrase *pPhrase = &pIter->aPhrase[i];
128368: fts3SnippetAdvance(&pPhrase->pHead, &pPhrase->iHead, iEnd+1);
128369: fts3SnippetAdvance(&pPhrase->pTail, &pPhrase->iTail, iStart);
128370: }
128371: }
128372:
128373: return 0;
128374: }
128375:
128376: /*
128377: ** Retrieve information about the current candidate snippet of snippet
128378: ** iterator pIter.
128379: */
128380: static void fts3SnippetDetails(
128381: SnippetIter *pIter, /* Snippet iterator */
128382: u64 mCovered, /* Bitmask of phrases already covered */
128383: int *piToken, /* OUT: First token of proposed snippet */
128384: int *piScore, /* OUT: "Score" for this snippet */
128385: u64 *pmCover, /* OUT: Bitmask of phrases covered */
128386: u64 *pmHighlight /* OUT: Bitmask of terms to highlight */
128387: ){
128388: int iStart = pIter->iCurrent; /* First token of snippet */
128389: int iScore = 0; /* Score of this snippet */
128390: int i; /* Loop counter */
128391: u64 mCover = 0; /* Mask of phrases covered by this snippet */
128392: u64 mHighlight = 0; /* Mask of tokens to highlight in snippet */
128393:
128394: for(i=0; i<pIter->nPhrase; i++){
128395: SnippetPhrase *pPhrase = &pIter->aPhrase[i];
128396: if( pPhrase->pTail ){
128397: char *pCsr = pPhrase->pTail;
128398: int iCsr = pPhrase->iTail;
128399:
128400: while( iCsr<(iStart+pIter->nSnippet) ){
128401: int j;
128402: u64 mPhrase = (u64)1 << i;
128403: u64 mPos = (u64)1 << (iCsr - iStart);
128404: assert( iCsr>=iStart );
128405: if( (mCover|mCovered)&mPhrase ){
128406: iScore++;
128407: }else{
128408: iScore += 1000;
128409: }
128410: mCover |= mPhrase;
128411:
128412: for(j=0; j<pPhrase->nToken; j++){
128413: mHighlight |= (mPos>>j);
128414: }
128415:
128416: if( 0==(*pCsr & 0x0FE) ) break;
128417: fts3GetDeltaPosition(&pCsr, &iCsr);
128418: }
128419: }
128420: }
128421:
128422: /* Set the output variables before returning. */
128423: *piToken = iStart;
128424: *piScore = iScore;
128425: *pmCover = mCover;
128426: *pmHighlight = mHighlight;
128427: }
128428:
128429: /*
128430: ** This function is an fts3ExprIterate() callback used by fts3BestSnippet().
128431: ** Each invocation populates an element of the SnippetIter.aPhrase[] array.
128432: */
128433: static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
128434: SnippetIter *p = (SnippetIter *)ctx;
128435: SnippetPhrase *pPhrase = &p->aPhrase[iPhrase];
128436: char *pCsr;
128437:
128438: pPhrase->nToken = pExpr->pPhrase->nToken;
128439:
128440: pCsr = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol);
128441: if( pCsr ){
128442: int iFirst = 0;
128443: pPhrase->pList = pCsr;
128444: fts3GetDeltaPosition(&pCsr, &iFirst);
128445: assert( iFirst>=0 );
128446: pPhrase->pHead = pCsr;
128447: pPhrase->pTail = pCsr;
128448: pPhrase->iHead = iFirst;
128449: pPhrase->iTail = iFirst;
128450: }else{
128451: assert( pPhrase->pList==0 && pPhrase->pHead==0 && pPhrase->pTail==0 );
128452: }
128453:
128454: return SQLITE_OK;
128455: }
128456:
128457: /*
128458: ** Select the fragment of text consisting of nFragment contiguous tokens
128459: ** from column iCol that represent the "best" snippet. The best snippet
128460: ** is the snippet with the highest score, where scores are calculated
128461: ** by adding:
128462: **
128463: ** (a) +1 point for each occurence of a matchable phrase in the snippet.
128464: **
128465: ** (b) +1000 points for the first occurence of each matchable phrase in
128466: ** the snippet for which the corresponding mCovered bit is not set.
128467: **
128468: ** The selected snippet parameters are stored in structure *pFragment before
128469: ** returning. The score of the selected snippet is stored in *piScore
128470: ** before returning.
128471: */
128472: static int fts3BestSnippet(
128473: int nSnippet, /* Desired snippet length */
128474: Fts3Cursor *pCsr, /* Cursor to create snippet for */
128475: int iCol, /* Index of column to create snippet from */
128476: u64 mCovered, /* Mask of phrases already covered */
128477: u64 *pmSeen, /* IN/OUT: Mask of phrases seen */
128478: SnippetFragment *pFragment, /* OUT: Best snippet found */
128479: int *piScore /* OUT: Score of snippet pFragment */
128480: ){
128481: int rc; /* Return Code */
128482: int nList; /* Number of phrases in expression */
128483: SnippetIter sIter; /* Iterates through snippet candidates */
128484: int nByte; /* Number of bytes of space to allocate */
128485: int iBestScore = -1; /* Best snippet score found so far */
128486: int i; /* Loop counter */
128487:
128488: memset(&sIter, 0, sizeof(sIter));
128489:
128490: /* Iterate through the phrases in the expression to count them. The same
128491: ** callback makes sure the doclists are loaded for each phrase.
128492: */
128493: rc = fts3ExprLoadDoclists(pCsr, &nList, 0);
128494: if( rc!=SQLITE_OK ){
128495: return rc;
128496: }
128497:
128498: /* Now that it is known how many phrases there are, allocate and zero
128499: ** the required space using malloc().
128500: */
128501: nByte = sizeof(SnippetPhrase) * nList;
128502: sIter.aPhrase = (SnippetPhrase *)sqlite3_malloc(nByte);
128503: if( !sIter.aPhrase ){
128504: return SQLITE_NOMEM;
128505: }
128506: memset(sIter.aPhrase, 0, nByte);
128507:
128508: /* Initialize the contents of the SnippetIter object. Then iterate through
128509: ** the set of phrases in the expression to populate the aPhrase[] array.
128510: */
128511: sIter.pCsr = pCsr;
128512: sIter.iCol = iCol;
128513: sIter.nSnippet = nSnippet;
128514: sIter.nPhrase = nList;
128515: sIter.iCurrent = -1;
128516: (void)fts3ExprIterate(pCsr->pExpr, fts3SnippetFindPositions, (void *)&sIter);
128517:
128518: /* Set the *pmSeen output variable. */
128519: for(i=0; i<nList; i++){
128520: if( sIter.aPhrase[i].pHead ){
128521: *pmSeen |= (u64)1 << i;
128522: }
128523: }
128524:
128525: /* Loop through all candidate snippets. Store the best snippet in
128526: ** *pFragment. Store its associated 'score' in iBestScore.
128527: */
128528: pFragment->iCol = iCol;
128529: while( !fts3SnippetNextCandidate(&sIter) ){
128530: int iPos;
128531: int iScore;
128532: u64 mCover;
128533: u64 mHighlight;
128534: fts3SnippetDetails(&sIter, mCovered, &iPos, &iScore, &mCover, &mHighlight);
128535: assert( iScore>=0 );
128536: if( iScore>iBestScore ){
128537: pFragment->iPos = iPos;
128538: pFragment->hlmask = mHighlight;
128539: pFragment->covered = mCover;
128540: iBestScore = iScore;
128541: }
128542: }
128543:
128544: sqlite3_free(sIter.aPhrase);
128545: *piScore = iBestScore;
128546: return SQLITE_OK;
128547: }
128548:
128549:
128550: /*
128551: ** Append a string to the string-buffer passed as the first argument.
128552: **
128553: ** If nAppend is negative, then the length of the string zAppend is
128554: ** determined using strlen().
128555: */
128556: static int fts3StringAppend(
128557: StrBuffer *pStr, /* Buffer to append to */
128558: const char *zAppend, /* Pointer to data to append to buffer */
128559: int nAppend /* Size of zAppend in bytes (or -1) */
128560: ){
128561: if( nAppend<0 ){
128562: nAppend = (int)strlen(zAppend);
128563: }
128564:
128565: /* If there is insufficient space allocated at StrBuffer.z, use realloc()
128566: ** to grow the buffer until so that it is big enough to accomadate the
128567: ** appended data.
128568: */
128569: if( pStr->n+nAppend+1>=pStr->nAlloc ){
128570: int nAlloc = pStr->nAlloc+nAppend+100;
128571: char *zNew = sqlite3_realloc(pStr->z, nAlloc);
128572: if( !zNew ){
128573: return SQLITE_NOMEM;
128574: }
128575: pStr->z = zNew;
128576: pStr->nAlloc = nAlloc;
128577: }
128578:
128579: /* Append the data to the string buffer. */
128580: memcpy(&pStr->z[pStr->n], zAppend, nAppend);
128581: pStr->n += nAppend;
128582: pStr->z[pStr->n] = '\0';
128583:
128584: return SQLITE_OK;
128585: }
128586:
128587: /*
128588: ** The fts3BestSnippet() function often selects snippets that end with a
128589: ** query term. That is, the final term of the snippet is always a term
128590: ** that requires highlighting. For example, if 'X' is a highlighted term
128591: ** and '.' is a non-highlighted term, BestSnippet() may select:
128592: **
128593: ** ........X.....X
128594: **
128595: ** This function "shifts" the beginning of the snippet forward in the
128596: ** document so that there are approximately the same number of
128597: ** non-highlighted terms to the right of the final highlighted term as there
128598: ** are to the left of the first highlighted term. For example, to this:
128599: **
128600: ** ....X.....X....
128601: **
128602: ** This is done as part of extracting the snippet text, not when selecting
128603: ** the snippet. Snippet selection is done based on doclists only, so there
128604: ** is no way for fts3BestSnippet() to know whether or not the document
128605: ** actually contains terms that follow the final highlighted term.
128606: */
128607: static int fts3SnippetShift(
128608: Fts3Table *pTab, /* FTS3 table snippet comes from */
128609: int nSnippet, /* Number of tokens desired for snippet */
128610: const char *zDoc, /* Document text to extract snippet from */
128611: int nDoc, /* Size of buffer zDoc in bytes */
128612: int *piPos, /* IN/OUT: First token of snippet */
128613: u64 *pHlmask /* IN/OUT: Mask of tokens to highlight */
128614: ){
128615: u64 hlmask = *pHlmask; /* Local copy of initial highlight-mask */
128616:
128617: if( hlmask ){
128618: int nLeft; /* Tokens to the left of first highlight */
128619: int nRight; /* Tokens to the right of last highlight */
128620: int nDesired; /* Ideal number of tokens to shift forward */
128621:
128622: for(nLeft=0; !(hlmask & ((u64)1 << nLeft)); nLeft++);
128623: for(nRight=0; !(hlmask & ((u64)1 << (nSnippet-1-nRight))); nRight++);
128624: nDesired = (nLeft-nRight)/2;
128625:
128626: /* Ideally, the start of the snippet should be pushed forward in the
128627: ** document nDesired tokens. This block checks if there are actually
128628: ** nDesired tokens to the right of the snippet. If so, *piPos and
128629: ** *pHlMask are updated to shift the snippet nDesired tokens to the
128630: ** right. Otherwise, the snippet is shifted by the number of tokens
128631: ** available.
128632: */
128633: if( nDesired>0 ){
128634: int nShift; /* Number of tokens to shift snippet by */
128635: int iCurrent = 0; /* Token counter */
128636: int rc; /* Return Code */
128637: sqlite3_tokenizer_module *pMod;
128638: sqlite3_tokenizer_cursor *pC;
128639: pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule;
128640:
128641: /* Open a cursor on zDoc/nDoc. Check if there are (nSnippet+nDesired)
128642: ** or more tokens in zDoc/nDoc.
128643: */
128644: rc = pMod->xOpen(pTab->pTokenizer, zDoc, nDoc, &pC);
128645: if( rc!=SQLITE_OK ){
128646: return rc;
128647: }
128648: pC->pTokenizer = pTab->pTokenizer;
128649: while( rc==SQLITE_OK && iCurrent<(nSnippet+nDesired) ){
128650: const char *ZDUMMY; int DUMMY1, DUMMY2, DUMMY3;
128651: rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
128652: }
128653: pMod->xClose(pC);
128654: if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){ return rc; }
128655:
128656: nShift = (rc==SQLITE_DONE)+iCurrent-nSnippet;
128657: assert( nShift<=nDesired );
128658: if( nShift>0 ){
128659: *piPos += nShift;
128660: *pHlmask = hlmask >> nShift;
128661: }
128662: }
128663: }
128664: return SQLITE_OK;
128665: }
128666:
128667: /*
128668: ** Extract the snippet text for fragment pFragment from cursor pCsr and
128669: ** append it to string buffer pOut.
128670: */
128671: static int fts3SnippetText(
128672: Fts3Cursor *pCsr, /* FTS3 Cursor */
128673: SnippetFragment *pFragment, /* Snippet to extract */
128674: int iFragment, /* Fragment number */
128675: int isLast, /* True for final fragment in snippet */
128676: int nSnippet, /* Number of tokens in extracted snippet */
128677: const char *zOpen, /* String inserted before highlighted term */
128678: const char *zClose, /* String inserted after highlighted term */
128679: const char *zEllipsis, /* String inserted between snippets */
128680: StrBuffer *pOut /* Write output here */
128681: ){
128682: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
128683: int rc; /* Return code */
128684: const char *zDoc; /* Document text to extract snippet from */
128685: int nDoc; /* Size of zDoc in bytes */
128686: int iCurrent = 0; /* Current token number of document */
128687: int iEnd = 0; /* Byte offset of end of current token */
128688: int isShiftDone = 0; /* True after snippet is shifted */
128689: int iPos = pFragment->iPos; /* First token of snippet */
128690: u64 hlmask = pFragment->hlmask; /* Highlight-mask for snippet */
128691: int iCol = pFragment->iCol+1; /* Query column to extract text from */
128692: sqlite3_tokenizer_module *pMod; /* Tokenizer module methods object */
128693: sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
128694: const char *ZDUMMY; /* Dummy argument used with tokenizer */
128695: int DUMMY1; /* Dummy argument used with tokenizer */
128696:
128697: zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol);
128698: if( zDoc==0 ){
128699: if( sqlite3_column_type(pCsr->pStmt, iCol)!=SQLITE_NULL ){
128700: return SQLITE_NOMEM;
128701: }
128702: return SQLITE_OK;
128703: }
128704: nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol);
128705:
128706: /* Open a token cursor on the document. */
128707: pMod = (sqlite3_tokenizer_module *)pTab->pTokenizer->pModule;
128708: rc = pMod->xOpen(pTab->pTokenizer, zDoc, nDoc, &pC);
128709: if( rc!=SQLITE_OK ){
128710: return rc;
128711: }
128712: pC->pTokenizer = pTab->pTokenizer;
128713:
128714: while( rc==SQLITE_OK ){
128715: int iBegin; /* Offset in zDoc of start of token */
128716: int iFin; /* Offset in zDoc of end of token */
128717: int isHighlight; /* True for highlighted terms */
128718:
128719: rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
128720: if( rc!=SQLITE_OK ){
128721: if( rc==SQLITE_DONE ){
128722: /* Special case - the last token of the snippet is also the last token
128723: ** of the column. Append any punctuation that occurred between the end
128724: ** of the previous token and the end of the document to the output.
128725: ** Then break out of the loop. */
128726: rc = fts3StringAppend(pOut, &zDoc[iEnd], -1);
128727: }
128728: break;
128729: }
128730: if( iCurrent<iPos ){ continue; }
128731:
128732: if( !isShiftDone ){
128733: int n = nDoc - iBegin;
128734: rc = fts3SnippetShift(pTab, nSnippet, &zDoc[iBegin], n, &iPos, &hlmask);
128735: isShiftDone = 1;
128736:
128737: /* Now that the shift has been done, check if the initial "..." are
128738: ** required. They are required if (a) this is not the first fragment,
128739: ** or (b) this fragment does not begin at position 0 of its column.
128740: */
128741: if( rc==SQLITE_OK && (iPos>0 || iFragment>0) ){
128742: rc = fts3StringAppend(pOut, zEllipsis, -1);
128743: }
128744: if( rc!=SQLITE_OK || iCurrent<iPos ) continue;
128745: }
128746:
128747: if( iCurrent>=(iPos+nSnippet) ){
128748: if( isLast ){
128749: rc = fts3StringAppend(pOut, zEllipsis, -1);
128750: }
128751: break;
128752: }
128753:
128754: /* Set isHighlight to true if this term should be highlighted. */
128755: isHighlight = (hlmask & ((u64)1 << (iCurrent-iPos)))!=0;
128756:
128757: if( iCurrent>iPos ) rc = fts3StringAppend(pOut, &zDoc[iEnd], iBegin-iEnd);
128758: if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
128759: if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
128760: if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
128761:
128762: iEnd = iFin;
128763: }
128764:
128765: pMod->xClose(pC);
128766: return rc;
128767: }
128768:
128769:
128770: /*
128771: ** This function is used to count the entries in a column-list (a
128772: ** delta-encoded list of term offsets within a single column of a single
128773: ** row). When this function is called, *ppCollist should point to the
128774: ** beginning of the first varint in the column-list (the varint that
128775: ** contains the position of the first matching term in the column data).
128776: ** Before returning, *ppCollist is set to point to the first byte after
128777: ** the last varint in the column-list (either the 0x00 signifying the end
128778: ** of the position-list, or the 0x01 that precedes the column number of
128779: ** the next column in the position-list).
128780: **
128781: ** The number of elements in the column-list is returned.
128782: */
128783: static int fts3ColumnlistCount(char **ppCollist){
128784: char *pEnd = *ppCollist;
128785: char c = 0;
128786: int nEntry = 0;
128787:
128788: /* A column-list is terminated by either a 0x01 or 0x00. */
128789: while( 0xFE & (*pEnd | c) ){
128790: c = *pEnd++ & 0x80;
128791: if( !c ) nEntry++;
128792: }
128793:
128794: *ppCollist = pEnd;
128795: return nEntry;
128796: }
128797:
128798: /*
128799: ** fts3ExprIterate() callback used to collect the "global" matchinfo stats
128800: ** for a single query.
128801: **
128802: ** fts3ExprIterate() callback to load the 'global' elements of a
128803: ** FTS3_MATCHINFO_HITS matchinfo array. The global stats are those elements
128804: ** of the matchinfo array that are constant for all rows returned by the
128805: ** current query.
128806: **
128807: ** Argument pCtx is actually a pointer to a struct of type MatchInfo. This
128808: ** function populates Matchinfo.aMatchinfo[] as follows:
128809: **
128810: ** for(iCol=0; iCol<nCol; iCol++){
128811: ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 1] = X;
128812: ** aMatchinfo[3*iPhrase*nCol + 3*iCol + 2] = Y;
128813: ** }
128814: **
128815: ** where X is the number of matches for phrase iPhrase is column iCol of all
128816: ** rows of the table. Y is the number of rows for which column iCol contains
128817: ** at least one instance of phrase iPhrase.
128818: **
128819: ** If the phrase pExpr consists entirely of deferred tokens, then all X and
128820: ** Y values are set to nDoc, where nDoc is the number of documents in the
128821: ** file system. This is done because the full-text index doclist is required
128822: ** to calculate these values properly, and the full-text index doclist is
128823: ** not available for deferred tokens.
128824: */
128825: static int fts3ExprGlobalHitsCb(
128826: Fts3Expr *pExpr, /* Phrase expression node */
128827: int iPhrase, /* Phrase number (numbered from zero) */
128828: void *pCtx /* Pointer to MatchInfo structure */
128829: ){
128830: MatchInfo *p = (MatchInfo *)pCtx;
128831: return sqlite3Fts3EvalPhraseStats(
128832: p->pCursor, pExpr, &p->aMatchinfo[3*iPhrase*p->nCol]
128833: );
128834: }
128835:
128836: /*
128837: ** fts3ExprIterate() callback used to collect the "local" part of the
128838: ** FTS3_MATCHINFO_HITS array. The local stats are those elements of the
128839: ** array that are different for each row returned by the query.
128840: */
128841: static int fts3ExprLocalHitsCb(
128842: Fts3Expr *pExpr, /* Phrase expression node */
128843: int iPhrase, /* Phrase number */
128844: void *pCtx /* Pointer to MatchInfo structure */
128845: ){
128846: MatchInfo *p = (MatchInfo *)pCtx;
128847: int iStart = iPhrase * p->nCol * 3;
128848: int i;
128849:
128850: for(i=0; i<p->nCol; i++){
128851: char *pCsr;
128852: pCsr = sqlite3Fts3EvalPhrasePoslist(p->pCursor, pExpr, i);
128853: if( pCsr ){
128854: p->aMatchinfo[iStart+i*3] = fts3ColumnlistCount(&pCsr);
128855: }else{
128856: p->aMatchinfo[iStart+i*3] = 0;
128857: }
128858: }
128859:
128860: return SQLITE_OK;
128861: }
128862:
128863: static int fts3MatchinfoCheck(
128864: Fts3Table *pTab,
128865: char cArg,
128866: char **pzErr
128867: ){
128868: if( (cArg==FTS3_MATCHINFO_NPHRASE)
128869: || (cArg==FTS3_MATCHINFO_NCOL)
128870: || (cArg==FTS3_MATCHINFO_NDOC && pTab->bHasStat)
128871: || (cArg==FTS3_MATCHINFO_AVGLENGTH && pTab->bHasStat)
128872: || (cArg==FTS3_MATCHINFO_LENGTH && pTab->bHasDocsize)
128873: || (cArg==FTS3_MATCHINFO_LCS)
128874: || (cArg==FTS3_MATCHINFO_HITS)
128875: ){
128876: return SQLITE_OK;
128877: }
128878: *pzErr = sqlite3_mprintf("unrecognized matchinfo request: %c", cArg);
128879: return SQLITE_ERROR;
128880: }
128881:
128882: static int fts3MatchinfoSize(MatchInfo *pInfo, char cArg){
128883: int nVal; /* Number of integers output by cArg */
128884:
128885: switch( cArg ){
128886: case FTS3_MATCHINFO_NDOC:
128887: case FTS3_MATCHINFO_NPHRASE:
128888: case FTS3_MATCHINFO_NCOL:
128889: nVal = 1;
128890: break;
128891:
128892: case FTS3_MATCHINFO_AVGLENGTH:
128893: case FTS3_MATCHINFO_LENGTH:
128894: case FTS3_MATCHINFO_LCS:
128895: nVal = pInfo->nCol;
128896: break;
128897:
128898: default:
128899: assert( cArg==FTS3_MATCHINFO_HITS );
128900: nVal = pInfo->nCol * pInfo->nPhrase * 3;
128901: break;
128902: }
128903:
128904: return nVal;
128905: }
128906:
128907: static int fts3MatchinfoSelectDoctotal(
128908: Fts3Table *pTab,
128909: sqlite3_stmt **ppStmt,
128910: sqlite3_int64 *pnDoc,
128911: const char **paLen
128912: ){
128913: sqlite3_stmt *pStmt;
128914: const char *a;
128915: sqlite3_int64 nDoc;
128916:
128917: if( !*ppStmt ){
128918: int rc = sqlite3Fts3SelectDoctotal(pTab, ppStmt);
128919: if( rc!=SQLITE_OK ) return rc;
128920: }
128921: pStmt = *ppStmt;
128922: assert( sqlite3_data_count(pStmt)==1 );
128923:
128924: a = sqlite3_column_blob(pStmt, 0);
128925: a += sqlite3Fts3GetVarint(a, &nDoc);
128926: if( nDoc==0 ) return FTS_CORRUPT_VTAB;
128927: *pnDoc = (u32)nDoc;
128928:
128929: if( paLen ) *paLen = a;
128930: return SQLITE_OK;
128931: }
128932:
128933: /*
128934: ** An instance of the following structure is used to store state while
128935: ** iterating through a multi-column position-list corresponding to the
128936: ** hits for a single phrase on a single row in order to calculate the
128937: ** values for a matchinfo() FTS3_MATCHINFO_LCS request.
128938: */
128939: typedef struct LcsIterator LcsIterator;
128940: struct LcsIterator {
128941: Fts3Expr *pExpr; /* Pointer to phrase expression */
128942: int iPosOffset; /* Tokens count up to end of this phrase */
128943: char *pRead; /* Cursor used to iterate through aDoclist */
128944: int iPos; /* Current position */
128945: };
128946:
128947: /*
128948: ** If LcsIterator.iCol is set to the following value, the iterator has
128949: ** finished iterating through all offsets for all columns.
128950: */
128951: #define LCS_ITERATOR_FINISHED 0x7FFFFFFF;
128952:
128953: static int fts3MatchinfoLcsCb(
128954: Fts3Expr *pExpr, /* Phrase expression node */
128955: int iPhrase, /* Phrase number (numbered from zero) */
128956: void *pCtx /* Pointer to MatchInfo structure */
128957: ){
128958: LcsIterator *aIter = (LcsIterator *)pCtx;
128959: aIter[iPhrase].pExpr = pExpr;
128960: return SQLITE_OK;
128961: }
128962:
128963: /*
128964: ** Advance the iterator passed as an argument to the next position. Return
128965: ** 1 if the iterator is at EOF or if it now points to the start of the
128966: ** position list for the next column.
128967: */
128968: static int fts3LcsIteratorAdvance(LcsIterator *pIter){
128969: char *pRead = pIter->pRead;
128970: sqlite3_int64 iRead;
128971: int rc = 0;
128972:
128973: pRead += sqlite3Fts3GetVarint(pRead, &iRead);
128974: if( iRead==0 || iRead==1 ){
128975: pRead = 0;
128976: rc = 1;
128977: }else{
128978: pIter->iPos += (int)(iRead-2);
128979: }
128980:
128981: pIter->pRead = pRead;
128982: return rc;
128983: }
128984:
128985: /*
128986: ** This function implements the FTS3_MATCHINFO_LCS matchinfo() flag.
128987: **
128988: ** If the call is successful, the longest-common-substring lengths for each
128989: ** column are written into the first nCol elements of the pInfo->aMatchinfo[]
128990: ** array before returning. SQLITE_OK is returned in this case.
128991: **
128992: ** Otherwise, if an error occurs, an SQLite error code is returned and the
128993: ** data written to the first nCol elements of pInfo->aMatchinfo[] is
128994: ** undefined.
128995: */
128996: static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
128997: LcsIterator *aIter;
128998: int i;
128999: int iCol;
129000: int nToken = 0;
129001:
129002: /* Allocate and populate the array of LcsIterator objects. The array
129003: ** contains one element for each matchable phrase in the query.
129004: **/
129005: aIter = sqlite3_malloc(sizeof(LcsIterator) * pCsr->nPhrase);
129006: if( !aIter ) return SQLITE_NOMEM;
129007: memset(aIter, 0, sizeof(LcsIterator) * pCsr->nPhrase);
129008: (void)fts3ExprIterate(pCsr->pExpr, fts3MatchinfoLcsCb, (void*)aIter);
129009:
129010: for(i=0; i<pInfo->nPhrase; i++){
129011: LcsIterator *pIter = &aIter[i];
129012: nToken -= pIter->pExpr->pPhrase->nToken;
129013: pIter->iPosOffset = nToken;
129014: }
129015:
129016: for(iCol=0; iCol<pInfo->nCol; iCol++){
129017: int nLcs = 0; /* LCS value for this column */
129018: int nLive = 0; /* Number of iterators in aIter not at EOF */
129019:
129020: for(i=0; i<pInfo->nPhrase; i++){
129021: LcsIterator *pIt = &aIter[i];
129022: pIt->pRead = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol);
129023: if( pIt->pRead ){
129024: pIt->iPos = pIt->iPosOffset;
129025: fts3LcsIteratorAdvance(&aIter[i]);
129026: nLive++;
129027: }
129028: }
129029:
129030: while( nLive>0 ){
129031: LcsIterator *pAdv = 0; /* The iterator to advance by one position */
129032: int nThisLcs = 0; /* LCS for the current iterator positions */
129033:
129034: for(i=0; i<pInfo->nPhrase; i++){
129035: LcsIterator *pIter = &aIter[i];
129036: if( pIter->pRead==0 ){
129037: /* This iterator is already at EOF for this column. */
129038: nThisLcs = 0;
129039: }else{
129040: if( pAdv==0 || pIter->iPos<pAdv->iPos ){
129041: pAdv = pIter;
129042: }
129043: if( nThisLcs==0 || pIter->iPos==pIter[-1].iPos ){
129044: nThisLcs++;
129045: }else{
129046: nThisLcs = 1;
129047: }
129048: if( nThisLcs>nLcs ) nLcs = nThisLcs;
129049: }
129050: }
129051: if( fts3LcsIteratorAdvance(pAdv) ) nLive--;
129052: }
129053:
129054: pInfo->aMatchinfo[iCol] = nLcs;
129055: }
129056:
129057: sqlite3_free(aIter);
129058: return SQLITE_OK;
129059: }
129060:
129061: /*
129062: ** Populate the buffer pInfo->aMatchinfo[] with an array of integers to
129063: ** be returned by the matchinfo() function. Argument zArg contains the
129064: ** format string passed as the second argument to matchinfo (or the
129065: ** default value "pcx" if no second argument was specified). The format
129066: ** string has already been validated and the pInfo->aMatchinfo[] array
129067: ** is guaranteed to be large enough for the output.
129068: **
129069: ** If bGlobal is true, then populate all fields of the matchinfo() output.
129070: ** If it is false, then assume that those fields that do not change between
129071: ** rows (i.e. FTS3_MATCHINFO_NPHRASE, NCOL, NDOC, AVGLENGTH and part of HITS)
129072: ** have already been populated.
129073: **
129074: ** Return SQLITE_OK if successful, or an SQLite error code if an error
129075: ** occurs. If a value other than SQLITE_OK is returned, the state the
129076: ** pInfo->aMatchinfo[] buffer is left in is undefined.
129077: */
129078: static int fts3MatchinfoValues(
129079: Fts3Cursor *pCsr, /* FTS3 cursor object */
129080: int bGlobal, /* True to grab the global stats */
129081: MatchInfo *pInfo, /* Matchinfo context object */
129082: const char *zArg /* Matchinfo format string */
129083: ){
129084: int rc = SQLITE_OK;
129085: int i;
129086: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
129087: sqlite3_stmt *pSelect = 0;
129088:
129089: for(i=0; rc==SQLITE_OK && zArg[i]; i++){
129090:
129091: switch( zArg[i] ){
129092: case FTS3_MATCHINFO_NPHRASE:
129093: if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nPhrase;
129094: break;
129095:
129096: case FTS3_MATCHINFO_NCOL:
129097: if( bGlobal ) pInfo->aMatchinfo[0] = pInfo->nCol;
129098: break;
129099:
129100: case FTS3_MATCHINFO_NDOC:
129101: if( bGlobal ){
129102: sqlite3_int64 nDoc = 0;
129103: rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, 0);
129104: pInfo->aMatchinfo[0] = (u32)nDoc;
129105: }
129106: break;
129107:
129108: case FTS3_MATCHINFO_AVGLENGTH:
129109: if( bGlobal ){
129110: sqlite3_int64 nDoc; /* Number of rows in table */
129111: const char *a; /* Aggregate column length array */
129112:
129113: rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &nDoc, &a);
129114: if( rc==SQLITE_OK ){
129115: int iCol;
129116: for(iCol=0; iCol<pInfo->nCol; iCol++){
129117: u32 iVal;
129118: sqlite3_int64 nToken;
129119: a += sqlite3Fts3GetVarint(a, &nToken);
129120: iVal = (u32)(((u32)(nToken&0xffffffff)+nDoc/2)/nDoc);
129121: pInfo->aMatchinfo[iCol] = iVal;
129122: }
129123: }
129124: }
129125: break;
129126:
129127: case FTS3_MATCHINFO_LENGTH: {
129128: sqlite3_stmt *pSelectDocsize = 0;
129129: rc = sqlite3Fts3SelectDocsize(pTab, pCsr->iPrevId, &pSelectDocsize);
129130: if( rc==SQLITE_OK ){
129131: int iCol;
129132: const char *a = sqlite3_column_blob(pSelectDocsize, 0);
129133: for(iCol=0; iCol<pInfo->nCol; iCol++){
129134: sqlite3_int64 nToken;
129135: a += sqlite3Fts3GetVarint(a, &nToken);
129136: pInfo->aMatchinfo[iCol] = (u32)nToken;
129137: }
129138: }
129139: sqlite3_reset(pSelectDocsize);
129140: break;
129141: }
129142:
129143: case FTS3_MATCHINFO_LCS:
129144: rc = fts3ExprLoadDoclists(pCsr, 0, 0);
129145: if( rc==SQLITE_OK ){
129146: rc = fts3MatchinfoLcs(pCsr, pInfo);
129147: }
129148: break;
129149:
129150: default: {
129151: Fts3Expr *pExpr;
129152: assert( zArg[i]==FTS3_MATCHINFO_HITS );
129153: pExpr = pCsr->pExpr;
129154: rc = fts3ExprLoadDoclists(pCsr, 0, 0);
129155: if( rc!=SQLITE_OK ) break;
129156: if( bGlobal ){
129157: if( pCsr->pDeferred ){
129158: rc = fts3MatchinfoSelectDoctotal(pTab, &pSelect, &pInfo->nDoc, 0);
129159: if( rc!=SQLITE_OK ) break;
129160: }
129161: rc = fts3ExprIterate(pExpr, fts3ExprGlobalHitsCb,(void*)pInfo);
129162: if( rc!=SQLITE_OK ) break;
129163: }
129164: (void)fts3ExprIterate(pExpr, fts3ExprLocalHitsCb,(void*)pInfo);
129165: break;
129166: }
129167: }
129168:
129169: pInfo->aMatchinfo += fts3MatchinfoSize(pInfo, zArg[i]);
129170: }
129171:
129172: sqlite3_reset(pSelect);
129173: return rc;
129174: }
129175:
129176:
129177: /*
129178: ** Populate pCsr->aMatchinfo[] with data for the current row. The
129179: ** 'matchinfo' data is an array of 32-bit unsigned integers (C type u32).
129180: */
129181: static int fts3GetMatchinfo(
129182: Fts3Cursor *pCsr, /* FTS3 Cursor object */
129183: const char *zArg /* Second argument to matchinfo() function */
129184: ){
129185: MatchInfo sInfo;
129186: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
129187: int rc = SQLITE_OK;
129188: int bGlobal = 0; /* Collect 'global' stats as well as local */
129189:
129190: memset(&sInfo, 0, sizeof(MatchInfo));
129191: sInfo.pCursor = pCsr;
129192: sInfo.nCol = pTab->nColumn;
129193:
129194: /* If there is cached matchinfo() data, but the format string for the
129195: ** cache does not match the format string for this request, discard
129196: ** the cached data. */
129197: if( pCsr->zMatchinfo && strcmp(pCsr->zMatchinfo, zArg) ){
129198: assert( pCsr->aMatchinfo );
129199: sqlite3_free(pCsr->aMatchinfo);
129200: pCsr->zMatchinfo = 0;
129201: pCsr->aMatchinfo = 0;
129202: }
129203:
129204: /* If Fts3Cursor.aMatchinfo[] is NULL, then this is the first time the
129205: ** matchinfo function has been called for this query. In this case
129206: ** allocate the array used to accumulate the matchinfo data and
129207: ** initialize those elements that are constant for every row.
129208: */
129209: if( pCsr->aMatchinfo==0 ){
129210: int nMatchinfo = 0; /* Number of u32 elements in match-info */
129211: int nArg; /* Bytes in zArg */
129212: int i; /* Used to iterate through zArg */
129213:
129214: /* Determine the number of phrases in the query */
129215: pCsr->nPhrase = fts3ExprPhraseCount(pCsr->pExpr);
129216: sInfo.nPhrase = pCsr->nPhrase;
129217:
129218: /* Determine the number of integers in the buffer returned by this call. */
129219: for(i=0; zArg[i]; i++){
129220: nMatchinfo += fts3MatchinfoSize(&sInfo, zArg[i]);
129221: }
129222:
129223: /* Allocate space for Fts3Cursor.aMatchinfo[] and Fts3Cursor.zMatchinfo. */
129224: nArg = (int)strlen(zArg);
129225: pCsr->aMatchinfo = (u32 *)sqlite3_malloc(sizeof(u32)*nMatchinfo + nArg + 1);
129226: if( !pCsr->aMatchinfo ) return SQLITE_NOMEM;
129227:
129228: pCsr->zMatchinfo = (char *)&pCsr->aMatchinfo[nMatchinfo];
129229: pCsr->nMatchinfo = nMatchinfo;
129230: memcpy(pCsr->zMatchinfo, zArg, nArg+1);
129231: memset(pCsr->aMatchinfo, 0, sizeof(u32)*nMatchinfo);
129232: pCsr->isMatchinfoNeeded = 1;
129233: bGlobal = 1;
129234: }
129235:
129236: sInfo.aMatchinfo = pCsr->aMatchinfo;
129237: sInfo.nPhrase = pCsr->nPhrase;
129238: if( pCsr->isMatchinfoNeeded ){
129239: rc = fts3MatchinfoValues(pCsr, bGlobal, &sInfo, zArg);
129240: pCsr->isMatchinfoNeeded = 0;
129241: }
129242:
129243: return rc;
129244: }
129245:
129246: /*
129247: ** Implementation of snippet() function.
129248: */
129249: SQLITE_PRIVATE void sqlite3Fts3Snippet(
129250: sqlite3_context *pCtx, /* SQLite function call context */
129251: Fts3Cursor *pCsr, /* Cursor object */
129252: const char *zStart, /* Snippet start text - "<b>" */
129253: const char *zEnd, /* Snippet end text - "</b>" */
129254: const char *zEllipsis, /* Snippet ellipsis text - "<b>...</b>" */
129255: int iCol, /* Extract snippet from this column */
129256: int nToken /* Approximate number of tokens in snippet */
129257: ){
129258: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
129259: int rc = SQLITE_OK;
129260: int i;
129261: StrBuffer res = {0, 0, 0};
129262:
129263: /* The returned text includes up to four fragments of text extracted from
129264: ** the data in the current row. The first iteration of the for(...) loop
129265: ** below attempts to locate a single fragment of text nToken tokens in
129266: ** size that contains at least one instance of all phrases in the query
129267: ** expression that appear in the current row. If such a fragment of text
129268: ** cannot be found, the second iteration of the loop attempts to locate
129269: ** a pair of fragments, and so on.
129270: */
129271: int nSnippet = 0; /* Number of fragments in this snippet */
129272: SnippetFragment aSnippet[4]; /* Maximum of 4 fragments per snippet */
129273: int nFToken = -1; /* Number of tokens in each fragment */
129274:
129275: if( !pCsr->pExpr ){
129276: sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
129277: return;
129278: }
129279:
129280: for(nSnippet=1; 1; nSnippet++){
129281:
129282: int iSnip; /* Loop counter 0..nSnippet-1 */
129283: u64 mCovered = 0; /* Bitmask of phrases covered by snippet */
129284: u64 mSeen = 0; /* Bitmask of phrases seen by BestSnippet() */
129285:
129286: if( nToken>=0 ){
129287: nFToken = (nToken+nSnippet-1) / nSnippet;
129288: }else{
129289: nFToken = -1 * nToken;
129290: }
129291:
129292: for(iSnip=0; iSnip<nSnippet; iSnip++){
129293: int iBestScore = -1; /* Best score of columns checked so far */
129294: int iRead; /* Used to iterate through columns */
129295: SnippetFragment *pFragment = &aSnippet[iSnip];
129296:
129297: memset(pFragment, 0, sizeof(*pFragment));
129298:
129299: /* Loop through all columns of the table being considered for snippets.
129300: ** If the iCol argument to this function was negative, this means all
129301: ** columns of the FTS3 table. Otherwise, only column iCol is considered.
129302: */
129303: for(iRead=0; iRead<pTab->nColumn; iRead++){
129304: SnippetFragment sF = {0, 0, 0, 0};
129305: int iS;
129306: if( iCol>=0 && iRead!=iCol ) continue;
129307:
129308: /* Find the best snippet of nFToken tokens in column iRead. */
129309: rc = fts3BestSnippet(nFToken, pCsr, iRead, mCovered, &mSeen, &sF, &iS);
129310: if( rc!=SQLITE_OK ){
129311: goto snippet_out;
129312: }
129313: if( iS>iBestScore ){
129314: *pFragment = sF;
129315: iBestScore = iS;
129316: }
129317: }
129318:
129319: mCovered |= pFragment->covered;
129320: }
129321:
129322: /* If all query phrases seen by fts3BestSnippet() are present in at least
129323: ** one of the nSnippet snippet fragments, break out of the loop.
129324: */
129325: assert( (mCovered&mSeen)==mCovered );
129326: if( mSeen==mCovered || nSnippet==SizeofArray(aSnippet) ) break;
129327: }
129328:
129329: assert( nFToken>0 );
129330:
129331: for(i=0; i<nSnippet && rc==SQLITE_OK; i++){
129332: rc = fts3SnippetText(pCsr, &aSnippet[i],
129333: i, (i==nSnippet-1), nFToken, zStart, zEnd, zEllipsis, &res
129334: );
129335: }
129336:
129337: snippet_out:
129338: sqlite3Fts3SegmentsClose(pTab);
129339: if( rc!=SQLITE_OK ){
129340: sqlite3_result_error_code(pCtx, rc);
129341: sqlite3_free(res.z);
129342: }else{
129343: sqlite3_result_text(pCtx, res.z, -1, sqlite3_free);
129344: }
129345: }
129346:
129347:
129348: typedef struct TermOffset TermOffset;
129349: typedef struct TermOffsetCtx TermOffsetCtx;
129350:
129351: struct TermOffset {
129352: char *pList; /* Position-list */
129353: int iPos; /* Position just read from pList */
129354: int iOff; /* Offset of this term from read positions */
129355: };
129356:
129357: struct TermOffsetCtx {
129358: Fts3Cursor *pCsr;
129359: int iCol; /* Column of table to populate aTerm for */
129360: int iTerm;
129361: sqlite3_int64 iDocid;
129362: TermOffset *aTerm;
129363: };
129364:
129365: /*
129366: ** This function is an fts3ExprIterate() callback used by sqlite3Fts3Offsets().
129367: */
129368: static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
129369: TermOffsetCtx *p = (TermOffsetCtx *)ctx;
129370: int nTerm; /* Number of tokens in phrase */
129371: int iTerm; /* For looping through nTerm phrase terms */
129372: char *pList; /* Pointer to position list for phrase */
129373: int iPos = 0; /* First position in position-list */
129374:
129375: UNUSED_PARAMETER(iPhrase);
129376: pList = sqlite3Fts3EvalPhrasePoslist(p->pCsr, pExpr, p->iCol);
129377: nTerm = pExpr->pPhrase->nToken;
129378: if( pList ){
129379: fts3GetDeltaPosition(&pList, &iPos);
129380: assert( iPos>=0 );
129381: }
129382:
129383: for(iTerm=0; iTerm<nTerm; iTerm++){
129384: TermOffset *pT = &p->aTerm[p->iTerm++];
129385: pT->iOff = nTerm-iTerm-1;
129386: pT->pList = pList;
129387: pT->iPos = iPos;
129388: }
129389:
129390: return SQLITE_OK;
129391: }
129392:
129393: /*
129394: ** Implementation of offsets() function.
129395: */
129396: SQLITE_PRIVATE void sqlite3Fts3Offsets(
129397: sqlite3_context *pCtx, /* SQLite function call context */
129398: Fts3Cursor *pCsr /* Cursor object */
129399: ){
129400: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
129401: sqlite3_tokenizer_module const *pMod = pTab->pTokenizer->pModule;
129402: const char *ZDUMMY; /* Dummy argument used with xNext() */
129403: int NDUMMY; /* Dummy argument used with xNext() */
129404: int rc; /* Return Code */
129405: int nToken; /* Number of tokens in query */
129406: int iCol; /* Column currently being processed */
129407: StrBuffer res = {0, 0, 0}; /* Result string */
129408: TermOffsetCtx sCtx; /* Context for fts3ExprTermOffsetInit() */
129409:
129410: if( !pCsr->pExpr ){
129411: sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
129412: return;
129413: }
129414:
129415: memset(&sCtx, 0, sizeof(sCtx));
129416: assert( pCsr->isRequireSeek==0 );
129417:
129418: /* Count the number of terms in the query */
129419: rc = fts3ExprLoadDoclists(pCsr, 0, &nToken);
129420: if( rc!=SQLITE_OK ) goto offsets_out;
129421:
129422: /* Allocate the array of TermOffset iterators. */
129423: sCtx.aTerm = (TermOffset *)sqlite3_malloc(sizeof(TermOffset)*nToken);
129424: if( 0==sCtx.aTerm ){
129425: rc = SQLITE_NOMEM;
129426: goto offsets_out;
129427: }
129428: sCtx.iDocid = pCsr->iPrevId;
129429: sCtx.pCsr = pCsr;
129430:
129431: /* Loop through the table columns, appending offset information to
129432: ** string-buffer res for each column.
129433: */
129434: for(iCol=0; iCol<pTab->nColumn; iCol++){
129435: sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
129436: int iStart;
129437: int iEnd;
129438: int iCurrent;
129439: const char *zDoc;
129440: int nDoc;
129441:
129442: /* Initialize the contents of sCtx.aTerm[] for column iCol. There is
129443: ** no way that this operation can fail, so the return code from
129444: ** fts3ExprIterate() can be discarded.
129445: */
129446: sCtx.iCol = iCol;
129447: sCtx.iTerm = 0;
129448: (void)fts3ExprIterate(pCsr->pExpr, fts3ExprTermOffsetInit, (void *)&sCtx);
129449:
129450: /* Retreive the text stored in column iCol. If an SQL NULL is stored
129451: ** in column iCol, jump immediately to the next iteration of the loop.
129452: ** If an OOM occurs while retrieving the data (this can happen if SQLite
129453: ** needs to transform the data from utf-16 to utf-8), return SQLITE_NOMEM
129454: ** to the caller.
129455: */
129456: zDoc = (const char *)sqlite3_column_text(pCsr->pStmt, iCol+1);
129457: nDoc = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
129458: if( zDoc==0 ){
129459: if( sqlite3_column_type(pCsr->pStmt, iCol+1)==SQLITE_NULL ){
129460: continue;
129461: }
129462: rc = SQLITE_NOMEM;
129463: goto offsets_out;
129464: }
129465:
129466: /* Initialize a tokenizer iterator to iterate through column iCol. */
129467: rc = pMod->xOpen(pTab->pTokenizer, zDoc, nDoc, &pC);
129468: if( rc!=SQLITE_OK ) goto offsets_out;
129469: pC->pTokenizer = pTab->pTokenizer;
129470:
129471: rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
129472: while( rc==SQLITE_OK ){
129473: int i; /* Used to loop through terms */
129474: int iMinPos = 0x7FFFFFFF; /* Position of next token */
129475: TermOffset *pTerm = 0; /* TermOffset associated with next token */
129476:
129477: for(i=0; i<nToken; i++){
129478: TermOffset *pT = &sCtx.aTerm[i];
129479: if( pT->pList && (pT->iPos-pT->iOff)<iMinPos ){
129480: iMinPos = pT->iPos-pT->iOff;
129481: pTerm = pT;
129482: }
129483: }
129484:
129485: if( !pTerm ){
129486: /* All offsets for this column have been gathered. */
129487: rc = SQLITE_DONE;
129488: }else{
129489: assert( iCurrent<=iMinPos );
129490: if( 0==(0xFE&*pTerm->pList) ){
129491: pTerm->pList = 0;
129492: }else{
129493: fts3GetDeltaPosition(&pTerm->pList, &pTerm->iPos);
129494: }
129495: while( rc==SQLITE_OK && iCurrent<iMinPos ){
129496: rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
129497: }
129498: if( rc==SQLITE_OK ){
129499: char aBuffer[64];
129500: sqlite3_snprintf(sizeof(aBuffer), aBuffer,
129501: "%d %d %d %d ", iCol, pTerm-sCtx.aTerm, iStart, iEnd-iStart
129502: );
129503: rc = fts3StringAppend(&res, aBuffer, -1);
129504: }else if( rc==SQLITE_DONE && pTab->zContentTbl==0 ){
129505: rc = FTS_CORRUPT_VTAB;
129506: }
129507: }
129508: }
129509: if( rc==SQLITE_DONE ){
129510: rc = SQLITE_OK;
129511: }
129512:
129513: pMod->xClose(pC);
129514: if( rc!=SQLITE_OK ) goto offsets_out;
129515: }
129516:
129517: offsets_out:
129518: sqlite3_free(sCtx.aTerm);
129519: assert( rc!=SQLITE_DONE );
129520: sqlite3Fts3SegmentsClose(pTab);
129521: if( rc!=SQLITE_OK ){
129522: sqlite3_result_error_code(pCtx, rc);
129523: sqlite3_free(res.z);
129524: }else{
129525: sqlite3_result_text(pCtx, res.z, res.n-1, sqlite3_free);
129526: }
129527: return;
129528: }
129529:
129530: /*
129531: ** Implementation of matchinfo() function.
129532: */
129533: SQLITE_PRIVATE void sqlite3Fts3Matchinfo(
129534: sqlite3_context *pContext, /* Function call context */
129535: Fts3Cursor *pCsr, /* FTS3 table cursor */
129536: const char *zArg /* Second arg to matchinfo() function */
129537: ){
129538: Fts3Table *pTab = (Fts3Table *)pCsr->base.pVtab;
129539: int rc;
129540: int i;
129541: const char *zFormat;
129542:
129543: if( zArg ){
129544: for(i=0; zArg[i]; i++){
129545: char *zErr = 0;
129546: if( fts3MatchinfoCheck(pTab, zArg[i], &zErr) ){
129547: sqlite3_result_error(pContext, zErr, -1);
129548: sqlite3_free(zErr);
129549: return;
129550: }
129551: }
129552: zFormat = zArg;
129553: }else{
129554: zFormat = FTS3_MATCHINFO_DEFAULT;
129555: }
129556:
129557: if( !pCsr->pExpr ){
129558: sqlite3_result_blob(pContext, "", 0, SQLITE_STATIC);
129559: return;
129560: }
129561:
129562: /* Retrieve matchinfo() data. */
129563: rc = fts3GetMatchinfo(pCsr, zFormat);
129564: sqlite3Fts3SegmentsClose(pTab);
129565:
129566: if( rc!=SQLITE_OK ){
129567: sqlite3_result_error_code(pContext, rc);
129568: }else{
129569: int n = pCsr->nMatchinfo * sizeof(u32);
129570: sqlite3_result_blob(pContext, pCsr->aMatchinfo, n, SQLITE_TRANSIENT);
129571: }
129572: }
129573:
129574: #endif
129575:
129576: /************** End of fts3_snippet.c ****************************************/
129577: /************** Begin file rtree.c *******************************************/
129578: /*
129579: ** 2001 September 15
129580: **
129581: ** The author disclaims copyright to this source code. In place of
129582: ** a legal notice, here is a blessing:
129583: **
129584: ** May you do good and not evil.
129585: ** May you find forgiveness for yourself and forgive others.
129586: ** May you share freely, never taking more than you give.
129587: **
129588: *************************************************************************
129589: ** This file contains code for implementations of the r-tree and r*-tree
129590: ** algorithms packaged as an SQLite virtual table module.
129591: */
129592:
129593: /*
129594: ** Database Format of R-Tree Tables
129595: ** --------------------------------
129596: **
129597: ** The data structure for a single virtual r-tree table is stored in three
129598: ** native SQLite tables declared as follows. In each case, the '%' character
129599: ** in the table name is replaced with the user-supplied name of the r-tree
129600: ** table.
129601: **
129602: ** CREATE TABLE %_node(nodeno INTEGER PRIMARY KEY, data BLOB)
129603: ** CREATE TABLE %_parent(nodeno INTEGER PRIMARY KEY, parentnode INTEGER)
129604: ** CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER)
129605: **
129606: ** The data for each node of the r-tree structure is stored in the %_node
129607: ** table. For each node that is not the root node of the r-tree, there is
129608: ** an entry in the %_parent table associating the node with its parent.
129609: ** And for each row of data in the table, there is an entry in the %_rowid
129610: ** table that maps from the entries rowid to the id of the node that it
129611: ** is stored on.
129612: **
129613: ** The root node of an r-tree always exists, even if the r-tree table is
129614: ** empty. The nodeno of the root node is always 1. All other nodes in the
129615: ** table must be the same size as the root node. The content of each node
129616: ** is formatted as follows:
129617: **
129618: ** 1. If the node is the root node (node 1), then the first 2 bytes
129619: ** of the node contain the tree depth as a big-endian integer.
129620: ** For non-root nodes, the first 2 bytes are left unused.
129621: **
129622: ** 2. The next 2 bytes contain the number of entries currently
129623: ** stored in the node.
129624: **
129625: ** 3. The remainder of the node contains the node entries. Each entry
129626: ** consists of a single 8-byte integer followed by an even number
129627: ** of 4-byte coordinates. For leaf nodes the integer is the rowid
129628: ** of a record. For internal nodes it is the node number of a
129629: ** child page.
129630: */
129631:
129632: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RTREE)
129633:
129634: /*
129635: ** This file contains an implementation of a couple of different variants
129636: ** of the r-tree algorithm. See the README file for further details. The
129637: ** same data-structure is used for all, but the algorithms for insert and
129638: ** delete operations vary. The variants used are selected at compile time
129639: ** by defining the following symbols:
129640: */
129641:
129642: /* Either, both or none of the following may be set to activate
129643: ** r*tree variant algorithms.
129644: */
129645: #define VARIANT_RSTARTREE_CHOOSESUBTREE 0
129646: #define VARIANT_RSTARTREE_REINSERT 1
129647:
129648: /*
129649: ** Exactly one of the following must be set to 1.
129650: */
129651: #define VARIANT_GUTTMAN_QUADRATIC_SPLIT 0
129652: #define VARIANT_GUTTMAN_LINEAR_SPLIT 0
129653: #define VARIANT_RSTARTREE_SPLIT 1
129654:
129655: #define VARIANT_GUTTMAN_SPLIT \
129656: (VARIANT_GUTTMAN_LINEAR_SPLIT||VARIANT_GUTTMAN_QUADRATIC_SPLIT)
129657:
129658: #if VARIANT_GUTTMAN_QUADRATIC_SPLIT
129659: #define PickNext QuadraticPickNext
129660: #define PickSeeds QuadraticPickSeeds
129661: #define AssignCells splitNodeGuttman
129662: #endif
129663: #if VARIANT_GUTTMAN_LINEAR_SPLIT
129664: #define PickNext LinearPickNext
129665: #define PickSeeds LinearPickSeeds
129666: #define AssignCells splitNodeGuttman
129667: #endif
129668: #if VARIANT_RSTARTREE_SPLIT
129669: #define AssignCells splitNodeStartree
129670: #endif
129671:
129672: #if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
129673: # define NDEBUG 1
129674: #endif
129675:
129676: #ifndef SQLITE_CORE
129677: SQLITE_EXTENSION_INIT1
129678: #else
129679: #endif
129680:
129681: /* #include <string.h> */
129682: /* #include <assert.h> */
129683:
129684: #ifndef SQLITE_AMALGAMATION
129685: #include "sqlite3rtree.h"
129686: typedef sqlite3_int64 i64;
129687: typedef unsigned char u8;
129688: typedef unsigned int u32;
129689: #endif
129690:
129691: /* The following macro is used to suppress compiler warnings.
129692: */
129693: #ifndef UNUSED_PARAMETER
129694: # define UNUSED_PARAMETER(x) (void)(x)
129695: #endif
129696:
129697: typedef struct Rtree Rtree;
129698: typedef struct RtreeCursor RtreeCursor;
129699: typedef struct RtreeNode RtreeNode;
129700: typedef struct RtreeCell RtreeCell;
129701: typedef struct RtreeConstraint RtreeConstraint;
129702: typedef struct RtreeMatchArg RtreeMatchArg;
129703: typedef struct RtreeGeomCallback RtreeGeomCallback;
129704: typedef union RtreeCoord RtreeCoord;
129705:
129706: /* The rtree may have between 1 and RTREE_MAX_DIMENSIONS dimensions. */
129707: #define RTREE_MAX_DIMENSIONS 5
129708:
129709: /* Size of hash table Rtree.aHash. This hash table is not expected to
129710: ** ever contain very many entries, so a fixed number of buckets is
129711: ** used.
129712: */
129713: #define HASHSIZE 128
129714:
129715: /*
129716: ** An rtree virtual-table object.
129717: */
129718: struct Rtree {
129719: sqlite3_vtab base;
129720: sqlite3 *db; /* Host database connection */
129721: int iNodeSize; /* Size in bytes of each node in the node table */
129722: int nDim; /* Number of dimensions */
129723: int nBytesPerCell; /* Bytes consumed per cell */
129724: int iDepth; /* Current depth of the r-tree structure */
129725: char *zDb; /* Name of database containing r-tree table */
129726: char *zName; /* Name of r-tree table */
129727: RtreeNode *aHash[HASHSIZE]; /* Hash table of in-memory nodes. */
129728: int nBusy; /* Current number of users of this structure */
129729:
129730: /* List of nodes removed during a CondenseTree operation. List is
129731: ** linked together via the pointer normally used for hash chains -
129732: ** RtreeNode.pNext. RtreeNode.iNode stores the depth of the sub-tree
129733: ** headed by the node (leaf nodes have RtreeNode.iNode==0).
129734: */
129735: RtreeNode *pDeleted;
129736: int iReinsertHeight; /* Height of sub-trees Reinsert() has run on */
129737:
129738: /* Statements to read/write/delete a record from xxx_node */
129739: sqlite3_stmt *pReadNode;
129740: sqlite3_stmt *pWriteNode;
129741: sqlite3_stmt *pDeleteNode;
129742:
129743: /* Statements to read/write/delete a record from xxx_rowid */
129744: sqlite3_stmt *pReadRowid;
129745: sqlite3_stmt *pWriteRowid;
129746: sqlite3_stmt *pDeleteRowid;
129747:
129748: /* Statements to read/write/delete a record from xxx_parent */
129749: sqlite3_stmt *pReadParent;
129750: sqlite3_stmt *pWriteParent;
129751: sqlite3_stmt *pDeleteParent;
129752:
129753: int eCoordType;
129754: };
129755:
129756: /* Possible values for eCoordType: */
129757: #define RTREE_COORD_REAL32 0
129758: #define RTREE_COORD_INT32 1
129759:
129760: /*
129761: ** The minimum number of cells allowed for a node is a third of the
129762: ** maximum. In Gutman's notation:
129763: **
129764: ** m = M/3
129765: **
129766: ** If an R*-tree "Reinsert" operation is required, the same number of
129767: ** cells are removed from the overfull node and reinserted into the tree.
129768: */
129769: #define RTREE_MINCELLS(p) ((((p)->iNodeSize-4)/(p)->nBytesPerCell)/3)
129770: #define RTREE_REINSERT(p) RTREE_MINCELLS(p)
129771: #define RTREE_MAXCELLS 51
129772:
129773: /*
129774: ** The smallest possible node-size is (512-64)==448 bytes. And the largest
129775: ** supported cell size is 48 bytes (8 byte rowid + ten 4 byte coordinates).
129776: ** Therefore all non-root nodes must contain at least 3 entries. Since
129777: ** 2^40 is greater than 2^64, an r-tree structure always has a depth of
129778: ** 40 or less.
129779: */
129780: #define RTREE_MAX_DEPTH 40
129781:
129782: /*
129783: ** An rtree cursor object.
129784: */
129785: struct RtreeCursor {
129786: sqlite3_vtab_cursor base;
129787: RtreeNode *pNode; /* Node cursor is currently pointing at */
129788: int iCell; /* Index of current cell in pNode */
129789: int iStrategy; /* Copy of idxNum search parameter */
129790: int nConstraint; /* Number of entries in aConstraint */
129791: RtreeConstraint *aConstraint; /* Search constraints. */
129792: };
129793:
129794: union RtreeCoord {
129795: float f;
129796: int i;
129797: };
129798:
129799: /*
129800: ** The argument is an RtreeCoord. Return the value stored within the RtreeCoord
129801: ** formatted as a double. This macro assumes that local variable pRtree points
129802: ** to the Rtree structure associated with the RtreeCoord.
129803: */
129804: #define DCOORD(coord) ( \
129805: (pRtree->eCoordType==RTREE_COORD_REAL32) ? \
129806: ((double)coord.f) : \
129807: ((double)coord.i) \
129808: )
129809:
129810: /*
129811: ** A search constraint.
129812: */
129813: struct RtreeConstraint {
129814: int iCoord; /* Index of constrained coordinate */
129815: int op; /* Constraining operation */
129816: double rValue; /* Constraint value. */
129817: int (*xGeom)(sqlite3_rtree_geometry *, int, double *, int *);
129818: sqlite3_rtree_geometry *pGeom; /* Constraint callback argument for a MATCH */
129819: };
129820:
129821: /* Possible values for RtreeConstraint.op */
129822: #define RTREE_EQ 0x41
129823: #define RTREE_LE 0x42
129824: #define RTREE_LT 0x43
129825: #define RTREE_GE 0x44
129826: #define RTREE_GT 0x45
129827: #define RTREE_MATCH 0x46
129828:
129829: /*
129830: ** An rtree structure node.
129831: */
129832: struct RtreeNode {
129833: RtreeNode *pParent; /* Parent node */
129834: i64 iNode;
129835: int nRef;
129836: int isDirty;
129837: u8 *zData;
129838: RtreeNode *pNext; /* Next node in this hash chain */
129839: };
129840: #define NCELL(pNode) readInt16(&(pNode)->zData[2])
129841:
129842: /*
129843: ** Structure to store a deserialized rtree record.
129844: */
129845: struct RtreeCell {
129846: i64 iRowid;
129847: RtreeCoord aCoord[RTREE_MAX_DIMENSIONS*2];
129848: };
129849:
129850:
129851: /*
129852: ** Value for the first field of every RtreeMatchArg object. The MATCH
129853: ** operator tests that the first field of a blob operand matches this
129854: ** value to avoid operating on invalid blobs (which could cause a segfault).
129855: */
129856: #define RTREE_GEOMETRY_MAGIC 0x891245AB
129857:
129858: /*
129859: ** An instance of this structure must be supplied as a blob argument to
129860: ** the right-hand-side of an SQL MATCH operator used to constrain an
129861: ** r-tree query.
129862: */
129863: struct RtreeMatchArg {
129864: u32 magic; /* Always RTREE_GEOMETRY_MAGIC */
129865: int (*xGeom)(sqlite3_rtree_geometry *, int, double *, int *);
129866: void *pContext;
129867: int nParam;
129868: double aParam[1];
129869: };
129870:
129871: /*
129872: ** When a geometry callback is created (see sqlite3_rtree_geometry_callback),
129873: ** a single instance of the following structure is allocated. It is used
129874: ** as the context for the user-function created by by s_r_g_c(). The object
129875: ** is eventually deleted by the destructor mechanism provided by
129876: ** sqlite3_create_function_v2() (which is called by s_r_g_c() to create
129877: ** the geometry callback function).
129878: */
129879: struct RtreeGeomCallback {
129880: int (*xGeom)(sqlite3_rtree_geometry *, int, double *, int *);
129881: void *pContext;
129882: };
129883:
129884: #ifndef MAX
129885: # define MAX(x,y) ((x) < (y) ? (y) : (x))
129886: #endif
129887: #ifndef MIN
129888: # define MIN(x,y) ((x) > (y) ? (y) : (x))
129889: #endif
129890:
129891: /*
129892: ** Functions to deserialize a 16 bit integer, 32 bit real number and
129893: ** 64 bit integer. The deserialized value is returned.
129894: */
129895: static int readInt16(u8 *p){
129896: return (p[0]<<8) + p[1];
129897: }
129898: static void readCoord(u8 *p, RtreeCoord *pCoord){
129899: u32 i = (
129900: (((u32)p[0]) << 24) +
129901: (((u32)p[1]) << 16) +
129902: (((u32)p[2]) << 8) +
129903: (((u32)p[3]) << 0)
129904: );
129905: *(u32 *)pCoord = i;
129906: }
129907: static i64 readInt64(u8 *p){
129908: return (
129909: (((i64)p[0]) << 56) +
129910: (((i64)p[1]) << 48) +
129911: (((i64)p[2]) << 40) +
129912: (((i64)p[3]) << 32) +
129913: (((i64)p[4]) << 24) +
129914: (((i64)p[5]) << 16) +
129915: (((i64)p[6]) << 8) +
129916: (((i64)p[7]) << 0)
129917: );
129918: }
129919:
129920: /*
129921: ** Functions to serialize a 16 bit integer, 32 bit real number and
129922: ** 64 bit integer. The value returned is the number of bytes written
129923: ** to the argument buffer (always 2, 4 and 8 respectively).
129924: */
129925: static int writeInt16(u8 *p, int i){
129926: p[0] = (i>> 8)&0xFF;
129927: p[1] = (i>> 0)&0xFF;
129928: return 2;
129929: }
129930: static int writeCoord(u8 *p, RtreeCoord *pCoord){
129931: u32 i;
129932: assert( sizeof(RtreeCoord)==4 );
129933: assert( sizeof(u32)==4 );
129934: i = *(u32 *)pCoord;
129935: p[0] = (i>>24)&0xFF;
129936: p[1] = (i>>16)&0xFF;
129937: p[2] = (i>> 8)&0xFF;
129938: p[3] = (i>> 0)&0xFF;
129939: return 4;
129940: }
129941: static int writeInt64(u8 *p, i64 i){
129942: p[0] = (i>>56)&0xFF;
129943: p[1] = (i>>48)&0xFF;
129944: p[2] = (i>>40)&0xFF;
129945: p[3] = (i>>32)&0xFF;
129946: p[4] = (i>>24)&0xFF;
129947: p[5] = (i>>16)&0xFF;
129948: p[6] = (i>> 8)&0xFF;
129949: p[7] = (i>> 0)&0xFF;
129950: return 8;
129951: }
129952:
129953: /*
129954: ** Increment the reference count of node p.
129955: */
129956: static void nodeReference(RtreeNode *p){
129957: if( p ){
129958: p->nRef++;
129959: }
129960: }
129961:
129962: /*
129963: ** Clear the content of node p (set all bytes to 0x00).
129964: */
129965: static void nodeZero(Rtree *pRtree, RtreeNode *p){
129966: memset(&p->zData[2], 0, pRtree->iNodeSize-2);
129967: p->isDirty = 1;
129968: }
129969:
129970: /*
129971: ** Given a node number iNode, return the corresponding key to use
129972: ** in the Rtree.aHash table.
129973: */
129974: static int nodeHash(i64 iNode){
129975: return (
129976: (iNode>>56) ^ (iNode>>48) ^ (iNode>>40) ^ (iNode>>32) ^
129977: (iNode>>24) ^ (iNode>>16) ^ (iNode>> 8) ^ (iNode>> 0)
129978: ) % HASHSIZE;
129979: }
129980:
129981: /*
129982: ** Search the node hash table for node iNode. If found, return a pointer
129983: ** to it. Otherwise, return 0.
129984: */
129985: static RtreeNode *nodeHashLookup(Rtree *pRtree, i64 iNode){
129986: RtreeNode *p;
129987: for(p=pRtree->aHash[nodeHash(iNode)]; p && p->iNode!=iNode; p=p->pNext);
129988: return p;
129989: }
129990:
129991: /*
129992: ** Add node pNode to the node hash table.
129993: */
129994: static void nodeHashInsert(Rtree *pRtree, RtreeNode *pNode){
129995: int iHash;
129996: assert( pNode->pNext==0 );
129997: iHash = nodeHash(pNode->iNode);
129998: pNode->pNext = pRtree->aHash[iHash];
129999: pRtree->aHash[iHash] = pNode;
130000: }
130001:
130002: /*
130003: ** Remove node pNode from the node hash table.
130004: */
130005: static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){
130006: RtreeNode **pp;
130007: if( pNode->iNode!=0 ){
130008: pp = &pRtree->aHash[nodeHash(pNode->iNode)];
130009: for( ; (*pp)!=pNode; pp = &(*pp)->pNext){ assert(*pp); }
130010: *pp = pNode->pNext;
130011: pNode->pNext = 0;
130012: }
130013: }
130014:
130015: /*
130016: ** Allocate and return new r-tree node. Initially, (RtreeNode.iNode==0),
130017: ** indicating that node has not yet been assigned a node number. It is
130018: ** assigned a node number when nodeWrite() is called to write the
130019: ** node contents out to the database.
130020: */
130021: static RtreeNode *nodeNew(Rtree *pRtree, RtreeNode *pParent){
130022: RtreeNode *pNode;
130023: pNode = (RtreeNode *)sqlite3_malloc(sizeof(RtreeNode) + pRtree->iNodeSize);
130024: if( pNode ){
130025: memset(pNode, 0, sizeof(RtreeNode) + pRtree->iNodeSize);
130026: pNode->zData = (u8 *)&pNode[1];
130027: pNode->nRef = 1;
130028: pNode->pParent = pParent;
130029: pNode->isDirty = 1;
130030: nodeReference(pParent);
130031: }
130032: return pNode;
130033: }
130034:
130035: /*
130036: ** Obtain a reference to an r-tree node.
130037: */
130038: static int
130039: nodeAcquire(
130040: Rtree *pRtree, /* R-tree structure */
130041: i64 iNode, /* Node number to load */
130042: RtreeNode *pParent, /* Either the parent node or NULL */
130043: RtreeNode **ppNode /* OUT: Acquired node */
130044: ){
130045: int rc;
130046: int rc2 = SQLITE_OK;
130047: RtreeNode *pNode;
130048:
130049: /* Check if the requested node is already in the hash table. If so,
130050: ** increase its reference count and return it.
130051: */
130052: if( (pNode = nodeHashLookup(pRtree, iNode)) ){
130053: assert( !pParent || !pNode->pParent || pNode->pParent==pParent );
130054: if( pParent && !pNode->pParent ){
130055: nodeReference(pParent);
130056: pNode->pParent = pParent;
130057: }
130058: pNode->nRef++;
130059: *ppNode = pNode;
130060: return SQLITE_OK;
130061: }
130062:
130063: sqlite3_bind_int64(pRtree->pReadNode, 1, iNode);
130064: rc = sqlite3_step(pRtree->pReadNode);
130065: if( rc==SQLITE_ROW ){
130066: const u8 *zBlob = sqlite3_column_blob(pRtree->pReadNode, 0);
130067: if( pRtree->iNodeSize==sqlite3_column_bytes(pRtree->pReadNode, 0) ){
130068: pNode = (RtreeNode *)sqlite3_malloc(sizeof(RtreeNode)+pRtree->iNodeSize);
130069: if( !pNode ){
130070: rc2 = SQLITE_NOMEM;
130071: }else{
130072: pNode->pParent = pParent;
130073: pNode->zData = (u8 *)&pNode[1];
130074: pNode->nRef = 1;
130075: pNode->iNode = iNode;
130076: pNode->isDirty = 0;
130077: pNode->pNext = 0;
130078: memcpy(pNode->zData, zBlob, pRtree->iNodeSize);
130079: nodeReference(pParent);
130080: }
130081: }
130082: }
130083: rc = sqlite3_reset(pRtree->pReadNode);
130084: if( rc==SQLITE_OK ) rc = rc2;
130085:
130086: /* If the root node was just loaded, set pRtree->iDepth to the height
130087: ** of the r-tree structure. A height of zero means all data is stored on
130088: ** the root node. A height of one means the children of the root node
130089: ** are the leaves, and so on. If the depth as specified on the root node
130090: ** is greater than RTREE_MAX_DEPTH, the r-tree structure must be corrupt.
130091: */
130092: if( pNode && iNode==1 ){
130093: pRtree->iDepth = readInt16(pNode->zData);
130094: if( pRtree->iDepth>RTREE_MAX_DEPTH ){
130095: rc = SQLITE_CORRUPT_VTAB;
130096: }
130097: }
130098:
130099: /* If no error has occurred so far, check if the "number of entries"
130100: ** field on the node is too large. If so, set the return code to
130101: ** SQLITE_CORRUPT_VTAB.
130102: */
130103: if( pNode && rc==SQLITE_OK ){
130104: if( NCELL(pNode)>((pRtree->iNodeSize-4)/pRtree->nBytesPerCell) ){
130105: rc = SQLITE_CORRUPT_VTAB;
130106: }
130107: }
130108:
130109: if( rc==SQLITE_OK ){
130110: if( pNode!=0 ){
130111: nodeHashInsert(pRtree, pNode);
130112: }else{
130113: rc = SQLITE_CORRUPT_VTAB;
130114: }
130115: *ppNode = pNode;
130116: }else{
130117: sqlite3_free(pNode);
130118: *ppNode = 0;
130119: }
130120:
130121: return rc;
130122: }
130123:
130124: /*
130125: ** Overwrite cell iCell of node pNode with the contents of pCell.
130126: */
130127: static void nodeOverwriteCell(
130128: Rtree *pRtree,
130129: RtreeNode *pNode,
130130: RtreeCell *pCell,
130131: int iCell
130132: ){
130133: int ii;
130134: u8 *p = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
130135: p += writeInt64(p, pCell->iRowid);
130136: for(ii=0; ii<(pRtree->nDim*2); ii++){
130137: p += writeCoord(p, &pCell->aCoord[ii]);
130138: }
130139: pNode->isDirty = 1;
130140: }
130141:
130142: /*
130143: ** Remove cell the cell with index iCell from node pNode.
130144: */
130145: static void nodeDeleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell){
130146: u8 *pDst = &pNode->zData[4 + pRtree->nBytesPerCell*iCell];
130147: u8 *pSrc = &pDst[pRtree->nBytesPerCell];
130148: int nByte = (NCELL(pNode) - iCell - 1) * pRtree->nBytesPerCell;
130149: memmove(pDst, pSrc, nByte);
130150: writeInt16(&pNode->zData[2], NCELL(pNode)-1);
130151: pNode->isDirty = 1;
130152: }
130153:
130154: /*
130155: ** Insert the contents of cell pCell into node pNode. If the insert
130156: ** is successful, return SQLITE_OK.
130157: **
130158: ** If there is not enough free space in pNode, return SQLITE_FULL.
130159: */
130160: static int
130161: nodeInsertCell(
130162: Rtree *pRtree,
130163: RtreeNode *pNode,
130164: RtreeCell *pCell
130165: ){
130166: int nCell; /* Current number of cells in pNode */
130167: int nMaxCell; /* Maximum number of cells for pNode */
130168:
130169: nMaxCell = (pRtree->iNodeSize-4)/pRtree->nBytesPerCell;
130170: nCell = NCELL(pNode);
130171:
130172: assert( nCell<=nMaxCell );
130173: if( nCell<nMaxCell ){
130174: nodeOverwriteCell(pRtree, pNode, pCell, nCell);
130175: writeInt16(&pNode->zData[2], nCell+1);
130176: pNode->isDirty = 1;
130177: }
130178:
130179: return (nCell==nMaxCell);
130180: }
130181:
130182: /*
130183: ** If the node is dirty, write it out to the database.
130184: */
130185: static int
130186: nodeWrite(Rtree *pRtree, RtreeNode *pNode){
130187: int rc = SQLITE_OK;
130188: if( pNode->isDirty ){
130189: sqlite3_stmt *p = pRtree->pWriteNode;
130190: if( pNode->iNode ){
130191: sqlite3_bind_int64(p, 1, pNode->iNode);
130192: }else{
130193: sqlite3_bind_null(p, 1);
130194: }
130195: sqlite3_bind_blob(p, 2, pNode->zData, pRtree->iNodeSize, SQLITE_STATIC);
130196: sqlite3_step(p);
130197: pNode->isDirty = 0;
130198: rc = sqlite3_reset(p);
130199: if( pNode->iNode==0 && rc==SQLITE_OK ){
130200: pNode->iNode = sqlite3_last_insert_rowid(pRtree->db);
130201: nodeHashInsert(pRtree, pNode);
130202: }
130203: }
130204: return rc;
130205: }
130206:
130207: /*
130208: ** Release a reference to a node. If the node is dirty and the reference
130209: ** count drops to zero, the node data is written to the database.
130210: */
130211: static int
130212: nodeRelease(Rtree *pRtree, RtreeNode *pNode){
130213: int rc = SQLITE_OK;
130214: if( pNode ){
130215: assert( pNode->nRef>0 );
130216: pNode->nRef--;
130217: if( pNode->nRef==0 ){
130218: if( pNode->iNode==1 ){
130219: pRtree->iDepth = -1;
130220: }
130221: if( pNode->pParent ){
130222: rc = nodeRelease(pRtree, pNode->pParent);
130223: }
130224: if( rc==SQLITE_OK ){
130225: rc = nodeWrite(pRtree, pNode);
130226: }
130227: nodeHashDelete(pRtree, pNode);
130228: sqlite3_free(pNode);
130229: }
130230: }
130231: return rc;
130232: }
130233:
130234: /*
130235: ** Return the 64-bit integer value associated with cell iCell of
130236: ** node pNode. If pNode is a leaf node, this is a rowid. If it is
130237: ** an internal node, then the 64-bit integer is a child page number.
130238: */
130239: static i64 nodeGetRowid(
130240: Rtree *pRtree,
130241: RtreeNode *pNode,
130242: int iCell
130243: ){
130244: assert( iCell<NCELL(pNode) );
130245: return readInt64(&pNode->zData[4 + pRtree->nBytesPerCell*iCell]);
130246: }
130247:
130248: /*
130249: ** Return coordinate iCoord from cell iCell in node pNode.
130250: */
130251: static void nodeGetCoord(
130252: Rtree *pRtree,
130253: RtreeNode *pNode,
130254: int iCell,
130255: int iCoord,
130256: RtreeCoord *pCoord /* Space to write result to */
130257: ){
130258: readCoord(&pNode->zData[12 + pRtree->nBytesPerCell*iCell + 4*iCoord], pCoord);
130259: }
130260:
130261: /*
130262: ** Deserialize cell iCell of node pNode. Populate the structure pointed
130263: ** to by pCell with the results.
130264: */
130265: static void nodeGetCell(
130266: Rtree *pRtree,
130267: RtreeNode *pNode,
130268: int iCell,
130269: RtreeCell *pCell
130270: ){
130271: int ii;
130272: pCell->iRowid = nodeGetRowid(pRtree, pNode, iCell);
130273: for(ii=0; ii<pRtree->nDim*2; ii++){
130274: nodeGetCoord(pRtree, pNode, iCell, ii, &pCell->aCoord[ii]);
130275: }
130276: }
130277:
130278:
130279: /* Forward declaration for the function that does the work of
130280: ** the virtual table module xCreate() and xConnect() methods.
130281: */
130282: static int rtreeInit(
130283: sqlite3 *, void *, int, const char *const*, sqlite3_vtab **, char **, int
130284: );
130285:
130286: /*
130287: ** Rtree virtual table module xCreate method.
130288: */
130289: static int rtreeCreate(
130290: sqlite3 *db,
130291: void *pAux,
130292: int argc, const char *const*argv,
130293: sqlite3_vtab **ppVtab,
130294: char **pzErr
130295: ){
130296: return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 1);
130297: }
130298:
130299: /*
130300: ** Rtree virtual table module xConnect method.
130301: */
130302: static int rtreeConnect(
130303: sqlite3 *db,
130304: void *pAux,
130305: int argc, const char *const*argv,
130306: sqlite3_vtab **ppVtab,
130307: char **pzErr
130308: ){
130309: return rtreeInit(db, pAux, argc, argv, ppVtab, pzErr, 0);
130310: }
130311:
130312: /*
130313: ** Increment the r-tree reference count.
130314: */
130315: static void rtreeReference(Rtree *pRtree){
130316: pRtree->nBusy++;
130317: }
130318:
130319: /*
130320: ** Decrement the r-tree reference count. When the reference count reaches
130321: ** zero the structure is deleted.
130322: */
130323: static void rtreeRelease(Rtree *pRtree){
130324: pRtree->nBusy--;
130325: if( pRtree->nBusy==0 ){
130326: sqlite3_finalize(pRtree->pReadNode);
130327: sqlite3_finalize(pRtree->pWriteNode);
130328: sqlite3_finalize(pRtree->pDeleteNode);
130329: sqlite3_finalize(pRtree->pReadRowid);
130330: sqlite3_finalize(pRtree->pWriteRowid);
130331: sqlite3_finalize(pRtree->pDeleteRowid);
130332: sqlite3_finalize(pRtree->pReadParent);
130333: sqlite3_finalize(pRtree->pWriteParent);
130334: sqlite3_finalize(pRtree->pDeleteParent);
130335: sqlite3_free(pRtree);
130336: }
130337: }
130338:
130339: /*
130340: ** Rtree virtual table module xDisconnect method.
130341: */
130342: static int rtreeDisconnect(sqlite3_vtab *pVtab){
130343: rtreeRelease((Rtree *)pVtab);
130344: return SQLITE_OK;
130345: }
130346:
130347: /*
130348: ** Rtree virtual table module xDestroy method.
130349: */
130350: static int rtreeDestroy(sqlite3_vtab *pVtab){
130351: Rtree *pRtree = (Rtree *)pVtab;
130352: int rc;
130353: char *zCreate = sqlite3_mprintf(
130354: "DROP TABLE '%q'.'%q_node';"
130355: "DROP TABLE '%q'.'%q_rowid';"
130356: "DROP TABLE '%q'.'%q_parent';",
130357: pRtree->zDb, pRtree->zName,
130358: pRtree->zDb, pRtree->zName,
130359: pRtree->zDb, pRtree->zName
130360: );
130361: if( !zCreate ){
130362: rc = SQLITE_NOMEM;
130363: }else{
130364: rc = sqlite3_exec(pRtree->db, zCreate, 0, 0, 0);
130365: sqlite3_free(zCreate);
130366: }
130367: if( rc==SQLITE_OK ){
130368: rtreeRelease(pRtree);
130369: }
130370:
130371: return rc;
130372: }
130373:
130374: /*
130375: ** Rtree virtual table module xOpen method.
130376: */
130377: static int rtreeOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
130378: int rc = SQLITE_NOMEM;
130379: RtreeCursor *pCsr;
130380:
130381: pCsr = (RtreeCursor *)sqlite3_malloc(sizeof(RtreeCursor));
130382: if( pCsr ){
130383: memset(pCsr, 0, sizeof(RtreeCursor));
130384: pCsr->base.pVtab = pVTab;
130385: rc = SQLITE_OK;
130386: }
130387: *ppCursor = (sqlite3_vtab_cursor *)pCsr;
130388:
130389: return rc;
130390: }
130391:
130392:
130393: /*
130394: ** Free the RtreeCursor.aConstraint[] array and its contents.
130395: */
130396: static void freeCursorConstraints(RtreeCursor *pCsr){
130397: if( pCsr->aConstraint ){
130398: int i; /* Used to iterate through constraint array */
130399: for(i=0; i<pCsr->nConstraint; i++){
130400: sqlite3_rtree_geometry *pGeom = pCsr->aConstraint[i].pGeom;
130401: if( pGeom ){
130402: if( pGeom->xDelUser ) pGeom->xDelUser(pGeom->pUser);
130403: sqlite3_free(pGeom);
130404: }
130405: }
130406: sqlite3_free(pCsr->aConstraint);
130407: pCsr->aConstraint = 0;
130408: }
130409: }
130410:
130411: /*
130412: ** Rtree virtual table module xClose method.
130413: */
130414: static int rtreeClose(sqlite3_vtab_cursor *cur){
130415: Rtree *pRtree = (Rtree *)(cur->pVtab);
130416: int rc;
130417: RtreeCursor *pCsr = (RtreeCursor *)cur;
130418: freeCursorConstraints(pCsr);
130419: rc = nodeRelease(pRtree, pCsr->pNode);
130420: sqlite3_free(pCsr);
130421: return rc;
130422: }
130423:
130424: /*
130425: ** Rtree virtual table module xEof method.
130426: **
130427: ** Return non-zero if the cursor does not currently point to a valid
130428: ** record (i.e if the scan has finished), or zero otherwise.
130429: */
130430: static int rtreeEof(sqlite3_vtab_cursor *cur){
130431: RtreeCursor *pCsr = (RtreeCursor *)cur;
130432: return (pCsr->pNode==0);
130433: }
130434:
130435: /*
130436: ** The r-tree constraint passed as the second argument to this function is
130437: ** guaranteed to be a MATCH constraint.
130438: */
130439: static int testRtreeGeom(
130440: Rtree *pRtree, /* R-Tree object */
130441: RtreeConstraint *pConstraint, /* MATCH constraint to test */
130442: RtreeCell *pCell, /* Cell to test */
130443: int *pbRes /* OUT: Test result */
130444: ){
130445: int i;
130446: double aCoord[RTREE_MAX_DIMENSIONS*2];
130447: int nCoord = pRtree->nDim*2;
130448:
130449: assert( pConstraint->op==RTREE_MATCH );
130450: assert( pConstraint->pGeom );
130451:
130452: for(i=0; i<nCoord; i++){
130453: aCoord[i] = DCOORD(pCell->aCoord[i]);
130454: }
130455: return pConstraint->xGeom(pConstraint->pGeom, nCoord, aCoord, pbRes);
130456: }
130457:
130458: /*
130459: ** Cursor pCursor currently points to a cell in a non-leaf page.
130460: ** Set *pbEof to true if the sub-tree headed by the cell is filtered
130461: ** (excluded) by the constraints in the pCursor->aConstraint[]
130462: ** array, or false otherwise.
130463: **
130464: ** Return SQLITE_OK if successful or an SQLite error code if an error
130465: ** occurs within a geometry callback.
130466: */
130467: static int testRtreeCell(Rtree *pRtree, RtreeCursor *pCursor, int *pbEof){
130468: RtreeCell cell;
130469: int ii;
130470: int bRes = 0;
130471: int rc = SQLITE_OK;
130472:
130473: nodeGetCell(pRtree, pCursor->pNode, pCursor->iCell, &cell);
130474: for(ii=0; bRes==0 && ii<pCursor->nConstraint; ii++){
130475: RtreeConstraint *p = &pCursor->aConstraint[ii];
130476: double cell_min = DCOORD(cell.aCoord[(p->iCoord>>1)*2]);
130477: double cell_max = DCOORD(cell.aCoord[(p->iCoord>>1)*2+1]);
130478:
130479: assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
130480: || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_MATCH
130481: );
130482:
130483: switch( p->op ){
130484: case RTREE_LE: case RTREE_LT:
130485: bRes = p->rValue<cell_min;
130486: break;
130487:
130488: case RTREE_GE: case RTREE_GT:
130489: bRes = p->rValue>cell_max;
130490: break;
130491:
130492: case RTREE_EQ:
130493: bRes = (p->rValue>cell_max || p->rValue<cell_min);
130494: break;
130495:
130496: default: {
130497: assert( p->op==RTREE_MATCH );
130498: rc = testRtreeGeom(pRtree, p, &cell, &bRes);
130499: bRes = !bRes;
130500: break;
130501: }
130502: }
130503: }
130504:
130505: *pbEof = bRes;
130506: return rc;
130507: }
130508:
130509: /*
130510: ** Test if the cell that cursor pCursor currently points to
130511: ** would be filtered (excluded) by the constraints in the
130512: ** pCursor->aConstraint[] array. If so, set *pbEof to true before
130513: ** returning. If the cell is not filtered (excluded) by the constraints,
130514: ** set pbEof to zero.
130515: **
130516: ** Return SQLITE_OK if successful or an SQLite error code if an error
130517: ** occurs within a geometry callback.
130518: **
130519: ** This function assumes that the cell is part of a leaf node.
130520: */
130521: static int testRtreeEntry(Rtree *pRtree, RtreeCursor *pCursor, int *pbEof){
130522: RtreeCell cell;
130523: int ii;
130524: *pbEof = 0;
130525:
130526: nodeGetCell(pRtree, pCursor->pNode, pCursor->iCell, &cell);
130527: for(ii=0; ii<pCursor->nConstraint; ii++){
130528: RtreeConstraint *p = &pCursor->aConstraint[ii];
130529: double coord = DCOORD(cell.aCoord[p->iCoord]);
130530: int res;
130531: assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
130532: || p->op==RTREE_GT || p->op==RTREE_EQ || p->op==RTREE_MATCH
130533: );
130534: switch( p->op ){
130535: case RTREE_LE: res = (coord<=p->rValue); break;
130536: case RTREE_LT: res = (coord<p->rValue); break;
130537: case RTREE_GE: res = (coord>=p->rValue); break;
130538: case RTREE_GT: res = (coord>p->rValue); break;
130539: case RTREE_EQ: res = (coord==p->rValue); break;
130540: default: {
130541: int rc;
130542: assert( p->op==RTREE_MATCH );
130543: rc = testRtreeGeom(pRtree, p, &cell, &res);
130544: if( rc!=SQLITE_OK ){
130545: return rc;
130546: }
130547: break;
130548: }
130549: }
130550:
130551: if( !res ){
130552: *pbEof = 1;
130553: return SQLITE_OK;
130554: }
130555: }
130556:
130557: return SQLITE_OK;
130558: }
130559:
130560: /*
130561: ** Cursor pCursor currently points at a node that heads a sub-tree of
130562: ** height iHeight (if iHeight==0, then the node is a leaf). Descend
130563: ** to point to the left-most cell of the sub-tree that matches the
130564: ** configured constraints.
130565: */
130566: static int descendToCell(
130567: Rtree *pRtree,
130568: RtreeCursor *pCursor,
130569: int iHeight,
130570: int *pEof /* OUT: Set to true if cannot descend */
130571: ){
130572: int isEof;
130573: int rc;
130574: int ii;
130575: RtreeNode *pChild;
130576: sqlite3_int64 iRowid;
130577:
130578: RtreeNode *pSavedNode = pCursor->pNode;
130579: int iSavedCell = pCursor->iCell;
130580:
130581: assert( iHeight>=0 );
130582:
130583: if( iHeight==0 ){
130584: rc = testRtreeEntry(pRtree, pCursor, &isEof);
130585: }else{
130586: rc = testRtreeCell(pRtree, pCursor, &isEof);
130587: }
130588: if( rc!=SQLITE_OK || isEof || iHeight==0 ){
130589: goto descend_to_cell_out;
130590: }
130591:
130592: iRowid = nodeGetRowid(pRtree, pCursor->pNode, pCursor->iCell);
130593: rc = nodeAcquire(pRtree, iRowid, pCursor->pNode, &pChild);
130594: if( rc!=SQLITE_OK ){
130595: goto descend_to_cell_out;
130596: }
130597:
130598: nodeRelease(pRtree, pCursor->pNode);
130599: pCursor->pNode = pChild;
130600: isEof = 1;
130601: for(ii=0; isEof && ii<NCELL(pChild); ii++){
130602: pCursor->iCell = ii;
130603: rc = descendToCell(pRtree, pCursor, iHeight-1, &isEof);
130604: if( rc!=SQLITE_OK ){
130605: goto descend_to_cell_out;
130606: }
130607: }
130608:
130609: if( isEof ){
130610: assert( pCursor->pNode==pChild );
130611: nodeReference(pSavedNode);
130612: nodeRelease(pRtree, pChild);
130613: pCursor->pNode = pSavedNode;
130614: pCursor->iCell = iSavedCell;
130615: }
130616:
130617: descend_to_cell_out:
130618: *pEof = isEof;
130619: return rc;
130620: }
130621:
130622: /*
130623: ** One of the cells in node pNode is guaranteed to have a 64-bit
130624: ** integer value equal to iRowid. Return the index of this cell.
130625: */
130626: static int nodeRowidIndex(
130627: Rtree *pRtree,
130628: RtreeNode *pNode,
130629: i64 iRowid,
130630: int *piIndex
130631: ){
130632: int ii;
130633: int nCell = NCELL(pNode);
130634: for(ii=0; ii<nCell; ii++){
130635: if( nodeGetRowid(pRtree, pNode, ii)==iRowid ){
130636: *piIndex = ii;
130637: return SQLITE_OK;
130638: }
130639: }
130640: return SQLITE_CORRUPT_VTAB;
130641: }
130642:
130643: /*
130644: ** Return the index of the cell containing a pointer to node pNode
130645: ** in its parent. If pNode is the root node, return -1.
130646: */
130647: static int nodeParentIndex(Rtree *pRtree, RtreeNode *pNode, int *piIndex){
130648: RtreeNode *pParent = pNode->pParent;
130649: if( pParent ){
130650: return nodeRowidIndex(pRtree, pParent, pNode->iNode, piIndex);
130651: }
130652: *piIndex = -1;
130653: return SQLITE_OK;
130654: }
130655:
130656: /*
130657: ** Rtree virtual table module xNext method.
130658: */
130659: static int rtreeNext(sqlite3_vtab_cursor *pVtabCursor){
130660: Rtree *pRtree = (Rtree *)(pVtabCursor->pVtab);
130661: RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
130662: int rc = SQLITE_OK;
130663:
130664: /* RtreeCursor.pNode must not be NULL. If is is NULL, then this cursor is
130665: ** already at EOF. It is against the rules to call the xNext() method of
130666: ** a cursor that has already reached EOF.
130667: */
130668: assert( pCsr->pNode );
130669:
130670: if( pCsr->iStrategy==1 ){
130671: /* This "scan" is a direct lookup by rowid. There is no next entry. */
130672: nodeRelease(pRtree, pCsr->pNode);
130673: pCsr->pNode = 0;
130674: }else{
130675: /* Move to the next entry that matches the configured constraints. */
130676: int iHeight = 0;
130677: while( pCsr->pNode ){
130678: RtreeNode *pNode = pCsr->pNode;
130679: int nCell = NCELL(pNode);
130680: for(pCsr->iCell++; pCsr->iCell<nCell; pCsr->iCell++){
130681: int isEof;
130682: rc = descendToCell(pRtree, pCsr, iHeight, &isEof);
130683: if( rc!=SQLITE_OK || !isEof ){
130684: return rc;
130685: }
130686: }
130687: pCsr->pNode = pNode->pParent;
130688: rc = nodeParentIndex(pRtree, pNode, &pCsr->iCell);
130689: if( rc!=SQLITE_OK ){
130690: return rc;
130691: }
130692: nodeReference(pCsr->pNode);
130693: nodeRelease(pRtree, pNode);
130694: iHeight++;
130695: }
130696: }
130697:
130698: return rc;
130699: }
130700:
130701: /*
130702: ** Rtree virtual table module xRowid method.
130703: */
130704: static int rtreeRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){
130705: Rtree *pRtree = (Rtree *)pVtabCursor->pVtab;
130706: RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
130707:
130708: assert(pCsr->pNode);
130709: *pRowid = nodeGetRowid(pRtree, pCsr->pNode, pCsr->iCell);
130710:
130711: return SQLITE_OK;
130712: }
130713:
130714: /*
130715: ** Rtree virtual table module xColumn method.
130716: */
130717: static int rtreeColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
130718: Rtree *pRtree = (Rtree *)cur->pVtab;
130719: RtreeCursor *pCsr = (RtreeCursor *)cur;
130720:
130721: if( i==0 ){
130722: i64 iRowid = nodeGetRowid(pRtree, pCsr->pNode, pCsr->iCell);
130723: sqlite3_result_int64(ctx, iRowid);
130724: }else{
130725: RtreeCoord c;
130726: nodeGetCoord(pRtree, pCsr->pNode, pCsr->iCell, i-1, &c);
130727: if( pRtree->eCoordType==RTREE_COORD_REAL32 ){
130728: sqlite3_result_double(ctx, c.f);
130729: }else{
130730: assert( pRtree->eCoordType==RTREE_COORD_INT32 );
130731: sqlite3_result_int(ctx, c.i);
130732: }
130733: }
130734:
130735: return SQLITE_OK;
130736: }
130737:
130738: /*
130739: ** Use nodeAcquire() to obtain the leaf node containing the record with
130740: ** rowid iRowid. If successful, set *ppLeaf to point to the node and
130741: ** return SQLITE_OK. If there is no such record in the table, set
130742: ** *ppLeaf to 0 and return SQLITE_OK. If an error occurs, set *ppLeaf
130743: ** to zero and return an SQLite error code.
130744: */
130745: static int findLeafNode(Rtree *pRtree, i64 iRowid, RtreeNode **ppLeaf){
130746: int rc;
130747: *ppLeaf = 0;
130748: sqlite3_bind_int64(pRtree->pReadRowid, 1, iRowid);
130749: if( sqlite3_step(pRtree->pReadRowid)==SQLITE_ROW ){
130750: i64 iNode = sqlite3_column_int64(pRtree->pReadRowid, 0);
130751: rc = nodeAcquire(pRtree, iNode, 0, ppLeaf);
130752: sqlite3_reset(pRtree->pReadRowid);
130753: }else{
130754: rc = sqlite3_reset(pRtree->pReadRowid);
130755: }
130756: return rc;
130757: }
130758:
130759: /*
130760: ** This function is called to configure the RtreeConstraint object passed
130761: ** as the second argument for a MATCH constraint. The value passed as the
130762: ** first argument to this function is the right-hand operand to the MATCH
130763: ** operator.
130764: */
130765: static int deserializeGeometry(sqlite3_value *pValue, RtreeConstraint *pCons){
130766: RtreeMatchArg *p;
130767: sqlite3_rtree_geometry *pGeom;
130768: int nBlob;
130769:
130770: /* Check that value is actually a blob. */
130771: if( sqlite3_value_type(pValue)!=SQLITE_BLOB ) return SQLITE_ERROR;
130772:
130773: /* Check that the blob is roughly the right size. */
130774: nBlob = sqlite3_value_bytes(pValue);
130775: if( nBlob<(int)sizeof(RtreeMatchArg)
130776: || ((nBlob-sizeof(RtreeMatchArg))%sizeof(double))!=0
130777: ){
130778: return SQLITE_ERROR;
130779: }
130780:
130781: pGeom = (sqlite3_rtree_geometry *)sqlite3_malloc(
130782: sizeof(sqlite3_rtree_geometry) + nBlob
130783: );
130784: if( !pGeom ) return SQLITE_NOMEM;
130785: memset(pGeom, 0, sizeof(sqlite3_rtree_geometry));
130786: p = (RtreeMatchArg *)&pGeom[1];
130787:
130788: memcpy(p, sqlite3_value_blob(pValue), nBlob);
130789: if( p->magic!=RTREE_GEOMETRY_MAGIC
130790: || nBlob!=(int)(sizeof(RtreeMatchArg) + (p->nParam-1)*sizeof(double))
130791: ){
130792: sqlite3_free(pGeom);
130793: return SQLITE_ERROR;
130794: }
130795:
130796: pGeom->pContext = p->pContext;
130797: pGeom->nParam = p->nParam;
130798: pGeom->aParam = p->aParam;
130799:
130800: pCons->xGeom = p->xGeom;
130801: pCons->pGeom = pGeom;
130802: return SQLITE_OK;
130803: }
130804:
130805: /*
130806: ** Rtree virtual table module xFilter method.
130807: */
130808: static int rtreeFilter(
130809: sqlite3_vtab_cursor *pVtabCursor,
130810: int idxNum, const char *idxStr,
130811: int argc, sqlite3_value **argv
130812: ){
130813: Rtree *pRtree = (Rtree *)pVtabCursor->pVtab;
130814: RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
130815:
130816: RtreeNode *pRoot = 0;
130817: int ii;
130818: int rc = SQLITE_OK;
130819:
130820: rtreeReference(pRtree);
130821:
130822: freeCursorConstraints(pCsr);
130823: pCsr->iStrategy = idxNum;
130824:
130825: if( idxNum==1 ){
130826: /* Special case - lookup by rowid. */
130827: RtreeNode *pLeaf; /* Leaf on which the required cell resides */
130828: i64 iRowid = sqlite3_value_int64(argv[0]);
130829: rc = findLeafNode(pRtree, iRowid, &pLeaf);
130830: pCsr->pNode = pLeaf;
130831: if( pLeaf ){
130832: assert( rc==SQLITE_OK );
130833: rc = nodeRowidIndex(pRtree, pLeaf, iRowid, &pCsr->iCell);
130834: }
130835: }else{
130836: /* Normal case - r-tree scan. Set up the RtreeCursor.aConstraint array
130837: ** with the configured constraints.
130838: */
130839: if( argc>0 ){
130840: pCsr->aConstraint = sqlite3_malloc(sizeof(RtreeConstraint)*argc);
130841: pCsr->nConstraint = argc;
130842: if( !pCsr->aConstraint ){
130843: rc = SQLITE_NOMEM;
130844: }else{
130845: memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*argc);
130846: assert( (idxStr==0 && argc==0)
130847: || (idxStr && (int)strlen(idxStr)==argc*2) );
130848: for(ii=0; ii<argc; ii++){
130849: RtreeConstraint *p = &pCsr->aConstraint[ii];
130850: p->op = idxStr[ii*2];
130851: p->iCoord = idxStr[ii*2+1]-'a';
130852: if( p->op==RTREE_MATCH ){
130853: /* A MATCH operator. The right-hand-side must be a blob that
130854: ** can be cast into an RtreeMatchArg object. One created using
130855: ** an sqlite3_rtree_geometry_callback() SQL user function.
130856: */
130857: rc = deserializeGeometry(argv[ii], p);
130858: if( rc!=SQLITE_OK ){
130859: break;
130860: }
130861: }else{
130862: p->rValue = sqlite3_value_double(argv[ii]);
130863: }
130864: }
130865: }
130866: }
130867:
130868: if( rc==SQLITE_OK ){
130869: pCsr->pNode = 0;
130870: rc = nodeAcquire(pRtree, 1, 0, &pRoot);
130871: }
130872: if( rc==SQLITE_OK ){
130873: int isEof = 1;
130874: int nCell = NCELL(pRoot);
130875: pCsr->pNode = pRoot;
130876: for(pCsr->iCell=0; rc==SQLITE_OK && pCsr->iCell<nCell; pCsr->iCell++){
130877: assert( pCsr->pNode==pRoot );
130878: rc = descendToCell(pRtree, pCsr, pRtree->iDepth, &isEof);
130879: if( !isEof ){
130880: break;
130881: }
130882: }
130883: if( rc==SQLITE_OK && isEof ){
130884: assert( pCsr->pNode==pRoot );
130885: nodeRelease(pRtree, pRoot);
130886: pCsr->pNode = 0;
130887: }
130888: assert( rc!=SQLITE_OK || !pCsr->pNode || pCsr->iCell<NCELL(pCsr->pNode) );
130889: }
130890: }
130891:
130892: rtreeRelease(pRtree);
130893: return rc;
130894: }
130895:
130896: /*
130897: ** Rtree virtual table module xBestIndex method. There are three
130898: ** table scan strategies to choose from (in order from most to
130899: ** least desirable):
130900: **
130901: ** idxNum idxStr Strategy
130902: ** ------------------------------------------------
130903: ** 1 Unused Direct lookup by rowid.
130904: ** 2 See below R-tree query or full-table scan.
130905: ** ------------------------------------------------
130906: **
130907: ** If strategy 1 is used, then idxStr is not meaningful. If strategy
130908: ** 2 is used, idxStr is formatted to contain 2 bytes for each
130909: ** constraint used. The first two bytes of idxStr correspond to
130910: ** the constraint in sqlite3_index_info.aConstraintUsage[] with
130911: ** (argvIndex==1) etc.
130912: **
130913: ** The first of each pair of bytes in idxStr identifies the constraint
130914: ** operator as follows:
130915: **
130916: ** Operator Byte Value
130917: ** ----------------------
130918: ** = 0x41 ('A')
130919: ** <= 0x42 ('B')
130920: ** < 0x43 ('C')
130921: ** >= 0x44 ('D')
130922: ** > 0x45 ('E')
130923: ** MATCH 0x46 ('F')
130924: ** ----------------------
130925: **
130926: ** The second of each pair of bytes identifies the coordinate column
130927: ** to which the constraint applies. The leftmost coordinate column
130928: ** is 'a', the second from the left 'b' etc.
130929: */
130930: static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
130931: int rc = SQLITE_OK;
130932: int ii;
130933:
130934: int iIdx = 0;
130935: char zIdxStr[RTREE_MAX_DIMENSIONS*8+1];
130936: memset(zIdxStr, 0, sizeof(zIdxStr));
130937: UNUSED_PARAMETER(tab);
130938:
130939: assert( pIdxInfo->idxStr==0 );
130940: for(ii=0; ii<pIdxInfo->nConstraint && iIdx<(int)(sizeof(zIdxStr)-1); ii++){
130941: struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii];
130942:
130943: if( p->usable && p->iColumn==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ ){
130944: /* We have an equality constraint on the rowid. Use strategy 1. */
130945: int jj;
130946: for(jj=0; jj<ii; jj++){
130947: pIdxInfo->aConstraintUsage[jj].argvIndex = 0;
130948: pIdxInfo->aConstraintUsage[jj].omit = 0;
130949: }
130950: pIdxInfo->idxNum = 1;
130951: pIdxInfo->aConstraintUsage[ii].argvIndex = 1;
130952: pIdxInfo->aConstraintUsage[jj].omit = 1;
130953:
130954: /* This strategy involves a two rowid lookups on an B-Tree structures
130955: ** and then a linear search of an R-Tree node. This should be
130956: ** considered almost as quick as a direct rowid lookup (for which
130957: ** sqlite uses an internal cost of 0.0).
130958: */
130959: pIdxInfo->estimatedCost = 10.0;
130960: return SQLITE_OK;
130961: }
130962:
130963: if( p->usable && (p->iColumn>0 || p->op==SQLITE_INDEX_CONSTRAINT_MATCH) ){
130964: u8 op;
130965: switch( p->op ){
130966: case SQLITE_INDEX_CONSTRAINT_EQ: op = RTREE_EQ; break;
130967: case SQLITE_INDEX_CONSTRAINT_GT: op = RTREE_GT; break;
130968: case SQLITE_INDEX_CONSTRAINT_LE: op = RTREE_LE; break;
130969: case SQLITE_INDEX_CONSTRAINT_LT: op = RTREE_LT; break;
130970: case SQLITE_INDEX_CONSTRAINT_GE: op = RTREE_GE; break;
130971: default:
130972: assert( p->op==SQLITE_INDEX_CONSTRAINT_MATCH );
130973: op = RTREE_MATCH;
130974: break;
130975: }
130976: zIdxStr[iIdx++] = op;
130977: zIdxStr[iIdx++] = p->iColumn - 1 + 'a';
130978: pIdxInfo->aConstraintUsage[ii].argvIndex = (iIdx/2);
130979: pIdxInfo->aConstraintUsage[ii].omit = 1;
130980: }
130981: }
130982:
130983: pIdxInfo->idxNum = 2;
130984: pIdxInfo->needToFreeIdxStr = 1;
130985: if( iIdx>0 && 0==(pIdxInfo->idxStr = sqlite3_mprintf("%s", zIdxStr)) ){
130986: return SQLITE_NOMEM;
130987: }
130988: assert( iIdx>=0 );
130989: pIdxInfo->estimatedCost = (2000000.0 / (double)(iIdx + 1));
130990: return rc;
130991: }
130992:
130993: /*
130994: ** Return the N-dimensional volumn of the cell stored in *p.
130995: */
130996: static float cellArea(Rtree *pRtree, RtreeCell *p){
130997: float area = 1.0;
130998: int ii;
130999: for(ii=0; ii<(pRtree->nDim*2); ii+=2){
131000: area = (float)(area * (DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii])));
131001: }
131002: return area;
131003: }
131004:
131005: /*
131006: ** Return the margin length of cell p. The margin length is the sum
131007: ** of the objects size in each dimension.
131008: */
131009: static float cellMargin(Rtree *pRtree, RtreeCell *p){
131010: float margin = 0.0;
131011: int ii;
131012: for(ii=0; ii<(pRtree->nDim*2); ii+=2){
131013: margin += (float)(DCOORD(p->aCoord[ii+1]) - DCOORD(p->aCoord[ii]));
131014: }
131015: return margin;
131016: }
131017:
131018: /*
131019: ** Store the union of cells p1 and p2 in p1.
131020: */
131021: static void cellUnion(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
131022: int ii;
131023: if( pRtree->eCoordType==RTREE_COORD_REAL32 ){
131024: for(ii=0; ii<(pRtree->nDim*2); ii+=2){
131025: p1->aCoord[ii].f = MIN(p1->aCoord[ii].f, p2->aCoord[ii].f);
131026: p1->aCoord[ii+1].f = MAX(p1->aCoord[ii+1].f, p2->aCoord[ii+1].f);
131027: }
131028: }else{
131029: for(ii=0; ii<(pRtree->nDim*2); ii+=2){
131030: p1->aCoord[ii].i = MIN(p1->aCoord[ii].i, p2->aCoord[ii].i);
131031: p1->aCoord[ii+1].i = MAX(p1->aCoord[ii+1].i, p2->aCoord[ii+1].i);
131032: }
131033: }
131034: }
131035:
131036: /*
131037: ** Return true if the area covered by p2 is a subset of the area covered
131038: ** by p1. False otherwise.
131039: */
131040: static int cellContains(Rtree *pRtree, RtreeCell *p1, RtreeCell *p2){
131041: int ii;
131042: int isInt = (pRtree->eCoordType==RTREE_COORD_INT32);
131043: for(ii=0; ii<(pRtree->nDim*2); ii+=2){
131044: RtreeCoord *a1 = &p1->aCoord[ii];
131045: RtreeCoord *a2 = &p2->aCoord[ii];
131046: if( (!isInt && (a2[0].f<a1[0].f || a2[1].f>a1[1].f))
131047: || ( isInt && (a2[0].i<a1[0].i || a2[1].i>a1[1].i))
131048: ){
131049: return 0;
131050: }
131051: }
131052: return 1;
131053: }
131054:
131055: /*
131056: ** Return the amount cell p would grow by if it were unioned with pCell.
131057: */
131058: static float cellGrowth(Rtree *pRtree, RtreeCell *p, RtreeCell *pCell){
131059: float area;
131060: RtreeCell cell;
131061: memcpy(&cell, p, sizeof(RtreeCell));
131062: area = cellArea(pRtree, &cell);
131063: cellUnion(pRtree, &cell, pCell);
131064: return (cellArea(pRtree, &cell)-area);
131065: }
131066:
131067: #if VARIANT_RSTARTREE_CHOOSESUBTREE || VARIANT_RSTARTREE_SPLIT
131068: static float cellOverlap(
131069: Rtree *pRtree,
131070: RtreeCell *p,
131071: RtreeCell *aCell,
131072: int nCell,
131073: int iExclude
131074: ){
131075: int ii;
131076: float overlap = 0.0;
131077: for(ii=0; ii<nCell; ii++){
131078: #if VARIANT_RSTARTREE_CHOOSESUBTREE
131079: if( ii!=iExclude )
131080: #else
131081: assert( iExclude==-1 );
131082: UNUSED_PARAMETER(iExclude);
131083: #endif
131084: {
131085: int jj;
131086: float o = 1.0;
131087: for(jj=0; jj<(pRtree->nDim*2); jj+=2){
131088: double x1;
131089: double x2;
131090:
131091: x1 = MAX(DCOORD(p->aCoord[jj]), DCOORD(aCell[ii].aCoord[jj]));
131092: x2 = MIN(DCOORD(p->aCoord[jj+1]), DCOORD(aCell[ii].aCoord[jj+1]));
131093:
131094: if( x2<x1 ){
131095: o = 0.0;
131096: break;
131097: }else{
131098: o = o * (float)(x2-x1);
131099: }
131100: }
131101: overlap += o;
131102: }
131103: }
131104: return overlap;
131105: }
131106: #endif
131107:
131108: #if VARIANT_RSTARTREE_CHOOSESUBTREE
131109: static float cellOverlapEnlargement(
131110: Rtree *pRtree,
131111: RtreeCell *p,
131112: RtreeCell *pInsert,
131113: RtreeCell *aCell,
131114: int nCell,
131115: int iExclude
131116: ){
131117: double before;
131118: double after;
131119: before = cellOverlap(pRtree, p, aCell, nCell, iExclude);
131120: cellUnion(pRtree, p, pInsert);
131121: after = cellOverlap(pRtree, p, aCell, nCell, iExclude);
131122: return (float)(after-before);
131123: }
131124: #endif
131125:
131126:
131127: /*
131128: ** This function implements the ChooseLeaf algorithm from Gutman[84].
131129: ** ChooseSubTree in r*tree terminology.
131130: */
131131: static int ChooseLeaf(
131132: Rtree *pRtree, /* Rtree table */
131133: RtreeCell *pCell, /* Cell to insert into rtree */
131134: int iHeight, /* Height of sub-tree rooted at pCell */
131135: RtreeNode **ppLeaf /* OUT: Selected leaf page */
131136: ){
131137: int rc;
131138: int ii;
131139: RtreeNode *pNode;
131140: rc = nodeAcquire(pRtree, 1, 0, &pNode);
131141:
131142: for(ii=0; rc==SQLITE_OK && ii<(pRtree->iDepth-iHeight); ii++){
131143: int iCell;
131144: sqlite3_int64 iBest = 0;
131145:
131146: float fMinGrowth = 0.0;
131147: float fMinArea = 0.0;
131148: #if VARIANT_RSTARTREE_CHOOSESUBTREE
131149: float fMinOverlap = 0.0;
131150: float overlap;
131151: #endif
131152:
131153: int nCell = NCELL(pNode);
131154: RtreeCell cell;
131155: RtreeNode *pChild;
131156:
131157: RtreeCell *aCell = 0;
131158:
131159: #if VARIANT_RSTARTREE_CHOOSESUBTREE
131160: if( ii==(pRtree->iDepth-1) ){
131161: int jj;
131162: aCell = sqlite3_malloc(sizeof(RtreeCell)*nCell);
131163: if( !aCell ){
131164: rc = SQLITE_NOMEM;
131165: nodeRelease(pRtree, pNode);
131166: pNode = 0;
131167: continue;
131168: }
131169: for(jj=0; jj<nCell; jj++){
131170: nodeGetCell(pRtree, pNode, jj, &aCell[jj]);
131171: }
131172: }
131173: #endif
131174:
131175: /* Select the child node which will be enlarged the least if pCell
131176: ** is inserted into it. Resolve ties by choosing the entry with
131177: ** the smallest area.
131178: */
131179: for(iCell=0; iCell<nCell; iCell++){
131180: int bBest = 0;
131181: float growth;
131182: float area;
131183: nodeGetCell(pRtree, pNode, iCell, &cell);
131184: growth = cellGrowth(pRtree, &cell, pCell);
131185: area = cellArea(pRtree, &cell);
131186:
131187: #if VARIANT_RSTARTREE_CHOOSESUBTREE
131188: if( ii==(pRtree->iDepth-1) ){
131189: overlap = cellOverlapEnlargement(pRtree,&cell,pCell,aCell,nCell,iCell);
131190: }else{
131191: overlap = 0.0;
131192: }
131193: if( (iCell==0)
131194: || (overlap<fMinOverlap)
131195: || (overlap==fMinOverlap && growth<fMinGrowth)
131196: || (overlap==fMinOverlap && growth==fMinGrowth && area<fMinArea)
131197: ){
131198: bBest = 1;
131199: fMinOverlap = overlap;
131200: }
131201: #else
131202: if( iCell==0||growth<fMinGrowth||(growth==fMinGrowth && area<fMinArea) ){
131203: bBest = 1;
131204: }
131205: #endif
131206: if( bBest ){
131207: fMinGrowth = growth;
131208: fMinArea = area;
131209: iBest = cell.iRowid;
131210: }
131211: }
131212:
131213: sqlite3_free(aCell);
131214: rc = nodeAcquire(pRtree, iBest, pNode, &pChild);
131215: nodeRelease(pRtree, pNode);
131216: pNode = pChild;
131217: }
131218:
131219: *ppLeaf = pNode;
131220: return rc;
131221: }
131222:
131223: /*
131224: ** A cell with the same content as pCell has just been inserted into
131225: ** the node pNode. This function updates the bounding box cells in
131226: ** all ancestor elements.
131227: */
131228: static int AdjustTree(
131229: Rtree *pRtree, /* Rtree table */
131230: RtreeNode *pNode, /* Adjust ancestry of this node. */
131231: RtreeCell *pCell /* This cell was just inserted */
131232: ){
131233: RtreeNode *p = pNode;
131234: while( p->pParent ){
131235: RtreeNode *pParent = p->pParent;
131236: RtreeCell cell;
131237: int iCell;
131238:
131239: if( nodeParentIndex(pRtree, p, &iCell) ){
131240: return SQLITE_CORRUPT_VTAB;
131241: }
131242:
131243: nodeGetCell(pRtree, pParent, iCell, &cell);
131244: if( !cellContains(pRtree, &cell, pCell) ){
131245: cellUnion(pRtree, &cell, pCell);
131246: nodeOverwriteCell(pRtree, pParent, &cell, iCell);
131247: }
131248:
131249: p = pParent;
131250: }
131251: return SQLITE_OK;
131252: }
131253:
131254: /*
131255: ** Write mapping (iRowid->iNode) to the <rtree>_rowid table.
131256: */
131257: static int rowidWrite(Rtree *pRtree, sqlite3_int64 iRowid, sqlite3_int64 iNode){
131258: sqlite3_bind_int64(pRtree->pWriteRowid, 1, iRowid);
131259: sqlite3_bind_int64(pRtree->pWriteRowid, 2, iNode);
131260: sqlite3_step(pRtree->pWriteRowid);
131261: return sqlite3_reset(pRtree->pWriteRowid);
131262: }
131263:
131264: /*
131265: ** Write mapping (iNode->iPar) to the <rtree>_parent table.
131266: */
131267: static int parentWrite(Rtree *pRtree, sqlite3_int64 iNode, sqlite3_int64 iPar){
131268: sqlite3_bind_int64(pRtree->pWriteParent, 1, iNode);
131269: sqlite3_bind_int64(pRtree->pWriteParent, 2, iPar);
131270: sqlite3_step(pRtree->pWriteParent);
131271: return sqlite3_reset(pRtree->pWriteParent);
131272: }
131273:
131274: static int rtreeInsertCell(Rtree *, RtreeNode *, RtreeCell *, int);
131275:
131276: #if VARIANT_GUTTMAN_LINEAR_SPLIT
131277: /*
131278: ** Implementation of the linear variant of the PickNext() function from
131279: ** Guttman[84].
131280: */
131281: static RtreeCell *LinearPickNext(
131282: Rtree *pRtree,
131283: RtreeCell *aCell,
131284: int nCell,
131285: RtreeCell *pLeftBox,
131286: RtreeCell *pRightBox,
131287: int *aiUsed
131288: ){
131289: int ii;
131290: for(ii=0; aiUsed[ii]; ii++);
131291: aiUsed[ii] = 1;
131292: return &aCell[ii];
131293: }
131294:
131295: /*
131296: ** Implementation of the linear variant of the PickSeeds() function from
131297: ** Guttman[84].
131298: */
131299: static void LinearPickSeeds(
131300: Rtree *pRtree,
131301: RtreeCell *aCell,
131302: int nCell,
131303: int *piLeftSeed,
131304: int *piRightSeed
131305: ){
131306: int i;
131307: int iLeftSeed = 0;
131308: int iRightSeed = 1;
131309: float maxNormalInnerWidth = 0.0;
131310:
131311: /* Pick two "seed" cells from the array of cells. The algorithm used
131312: ** here is the LinearPickSeeds algorithm from Gutman[1984]. The
131313: ** indices of the two seed cells in the array are stored in local
131314: ** variables iLeftSeek and iRightSeed.
131315: */
131316: for(i=0; i<pRtree->nDim; i++){
131317: float x1 = DCOORD(aCell[0].aCoord[i*2]);
131318: float x2 = DCOORD(aCell[0].aCoord[i*2+1]);
131319: float x3 = x1;
131320: float x4 = x2;
131321: int jj;
131322:
131323: int iCellLeft = 0;
131324: int iCellRight = 0;
131325:
131326: for(jj=1; jj<nCell; jj++){
131327: float left = DCOORD(aCell[jj].aCoord[i*2]);
131328: float right = DCOORD(aCell[jj].aCoord[i*2+1]);
131329:
131330: if( left<x1 ) x1 = left;
131331: if( right>x4 ) x4 = right;
131332: if( left>x3 ){
131333: x3 = left;
131334: iCellRight = jj;
131335: }
131336: if( right<x2 ){
131337: x2 = right;
131338: iCellLeft = jj;
131339: }
131340: }
131341:
131342: if( x4!=x1 ){
131343: float normalwidth = (x3 - x2) / (x4 - x1);
131344: if( normalwidth>maxNormalInnerWidth ){
131345: iLeftSeed = iCellLeft;
131346: iRightSeed = iCellRight;
131347: }
131348: }
131349: }
131350:
131351: *piLeftSeed = iLeftSeed;
131352: *piRightSeed = iRightSeed;
131353: }
131354: #endif /* VARIANT_GUTTMAN_LINEAR_SPLIT */
131355:
131356: #if VARIANT_GUTTMAN_QUADRATIC_SPLIT
131357: /*
131358: ** Implementation of the quadratic variant of the PickNext() function from
131359: ** Guttman[84].
131360: */
131361: static RtreeCell *QuadraticPickNext(
131362: Rtree *pRtree,
131363: RtreeCell *aCell,
131364: int nCell,
131365: RtreeCell *pLeftBox,
131366: RtreeCell *pRightBox,
131367: int *aiUsed
131368: ){
131369: #define FABS(a) ((a)<0.0?-1.0*(a):(a))
131370:
131371: int iSelect = -1;
131372: float fDiff;
131373: int ii;
131374: for(ii=0; ii<nCell; ii++){
131375: if( aiUsed[ii]==0 ){
131376: float left = cellGrowth(pRtree, pLeftBox, &aCell[ii]);
131377: float right = cellGrowth(pRtree, pLeftBox, &aCell[ii]);
131378: float diff = FABS(right-left);
131379: if( iSelect<0 || diff>fDiff ){
131380: fDiff = diff;
131381: iSelect = ii;
131382: }
131383: }
131384: }
131385: aiUsed[iSelect] = 1;
131386: return &aCell[iSelect];
131387: }
131388:
131389: /*
131390: ** Implementation of the quadratic variant of the PickSeeds() function from
131391: ** Guttman[84].
131392: */
131393: static void QuadraticPickSeeds(
131394: Rtree *pRtree,
131395: RtreeCell *aCell,
131396: int nCell,
131397: int *piLeftSeed,
131398: int *piRightSeed
131399: ){
131400: int ii;
131401: int jj;
131402:
131403: int iLeftSeed = 0;
131404: int iRightSeed = 1;
131405: float fWaste = 0.0;
131406:
131407: for(ii=0; ii<nCell; ii++){
131408: for(jj=ii+1; jj<nCell; jj++){
131409: float right = cellArea(pRtree, &aCell[jj]);
131410: float growth = cellGrowth(pRtree, &aCell[ii], &aCell[jj]);
131411: float waste = growth - right;
131412:
131413: if( waste>fWaste ){
131414: iLeftSeed = ii;
131415: iRightSeed = jj;
131416: fWaste = waste;
131417: }
131418: }
131419: }
131420:
131421: *piLeftSeed = iLeftSeed;
131422: *piRightSeed = iRightSeed;
131423: }
131424: #endif /* VARIANT_GUTTMAN_QUADRATIC_SPLIT */
131425:
131426: /*
131427: ** Arguments aIdx, aDistance and aSpare all point to arrays of size
131428: ** nIdx. The aIdx array contains the set of integers from 0 to
131429: ** (nIdx-1) in no particular order. This function sorts the values
131430: ** in aIdx according to the indexed values in aDistance. For
131431: ** example, assuming the inputs:
131432: **
131433: ** aIdx = { 0, 1, 2, 3 }
131434: ** aDistance = { 5.0, 2.0, 7.0, 6.0 }
131435: **
131436: ** this function sets the aIdx array to contain:
131437: **
131438: ** aIdx = { 0, 1, 2, 3 }
131439: **
131440: ** The aSpare array is used as temporary working space by the
131441: ** sorting algorithm.
131442: */
131443: static void SortByDistance(
131444: int *aIdx,
131445: int nIdx,
131446: float *aDistance,
131447: int *aSpare
131448: ){
131449: if( nIdx>1 ){
131450: int iLeft = 0;
131451: int iRight = 0;
131452:
131453: int nLeft = nIdx/2;
131454: int nRight = nIdx-nLeft;
131455: int *aLeft = aIdx;
131456: int *aRight = &aIdx[nLeft];
131457:
131458: SortByDistance(aLeft, nLeft, aDistance, aSpare);
131459: SortByDistance(aRight, nRight, aDistance, aSpare);
131460:
131461: memcpy(aSpare, aLeft, sizeof(int)*nLeft);
131462: aLeft = aSpare;
131463:
131464: while( iLeft<nLeft || iRight<nRight ){
131465: if( iLeft==nLeft ){
131466: aIdx[iLeft+iRight] = aRight[iRight];
131467: iRight++;
131468: }else if( iRight==nRight ){
131469: aIdx[iLeft+iRight] = aLeft[iLeft];
131470: iLeft++;
131471: }else{
131472: float fLeft = aDistance[aLeft[iLeft]];
131473: float fRight = aDistance[aRight[iRight]];
131474: if( fLeft<fRight ){
131475: aIdx[iLeft+iRight] = aLeft[iLeft];
131476: iLeft++;
131477: }else{
131478: aIdx[iLeft+iRight] = aRight[iRight];
131479: iRight++;
131480: }
131481: }
131482: }
131483:
131484: #if 0
131485: /* Check that the sort worked */
131486: {
131487: int jj;
131488: for(jj=1; jj<nIdx; jj++){
131489: float left = aDistance[aIdx[jj-1]];
131490: float right = aDistance[aIdx[jj]];
131491: assert( left<=right );
131492: }
131493: }
131494: #endif
131495: }
131496: }
131497:
131498: /*
131499: ** Arguments aIdx, aCell and aSpare all point to arrays of size
131500: ** nIdx. The aIdx array contains the set of integers from 0 to
131501: ** (nIdx-1) in no particular order. This function sorts the values
131502: ** in aIdx according to dimension iDim of the cells in aCell. The
131503: ** minimum value of dimension iDim is considered first, the
131504: ** maximum used to break ties.
131505: **
131506: ** The aSpare array is used as temporary working space by the
131507: ** sorting algorithm.
131508: */
131509: static void SortByDimension(
131510: Rtree *pRtree,
131511: int *aIdx,
131512: int nIdx,
131513: int iDim,
131514: RtreeCell *aCell,
131515: int *aSpare
131516: ){
131517: if( nIdx>1 ){
131518:
131519: int iLeft = 0;
131520: int iRight = 0;
131521:
131522: int nLeft = nIdx/2;
131523: int nRight = nIdx-nLeft;
131524: int *aLeft = aIdx;
131525: int *aRight = &aIdx[nLeft];
131526:
131527: SortByDimension(pRtree, aLeft, nLeft, iDim, aCell, aSpare);
131528: SortByDimension(pRtree, aRight, nRight, iDim, aCell, aSpare);
131529:
131530: memcpy(aSpare, aLeft, sizeof(int)*nLeft);
131531: aLeft = aSpare;
131532: while( iLeft<nLeft || iRight<nRight ){
131533: double xleft1 = DCOORD(aCell[aLeft[iLeft]].aCoord[iDim*2]);
131534: double xleft2 = DCOORD(aCell[aLeft[iLeft]].aCoord[iDim*2+1]);
131535: double xright1 = DCOORD(aCell[aRight[iRight]].aCoord[iDim*2]);
131536: double xright2 = DCOORD(aCell[aRight[iRight]].aCoord[iDim*2+1]);
131537: if( (iLeft!=nLeft) && ((iRight==nRight)
131538: || (xleft1<xright1)
131539: || (xleft1==xright1 && xleft2<xright2)
131540: )){
131541: aIdx[iLeft+iRight] = aLeft[iLeft];
131542: iLeft++;
131543: }else{
131544: aIdx[iLeft+iRight] = aRight[iRight];
131545: iRight++;
131546: }
131547: }
131548:
131549: #if 0
131550: /* Check that the sort worked */
131551: {
131552: int jj;
131553: for(jj=1; jj<nIdx; jj++){
131554: float xleft1 = aCell[aIdx[jj-1]].aCoord[iDim*2];
131555: float xleft2 = aCell[aIdx[jj-1]].aCoord[iDim*2+1];
131556: float xright1 = aCell[aIdx[jj]].aCoord[iDim*2];
131557: float xright2 = aCell[aIdx[jj]].aCoord[iDim*2+1];
131558: assert( xleft1<=xright1 && (xleft1<xright1 || xleft2<=xright2) );
131559: }
131560: }
131561: #endif
131562: }
131563: }
131564:
131565: #if VARIANT_RSTARTREE_SPLIT
131566: /*
131567: ** Implementation of the R*-tree variant of SplitNode from Beckman[1990].
131568: */
131569: static int splitNodeStartree(
131570: Rtree *pRtree,
131571: RtreeCell *aCell,
131572: int nCell,
131573: RtreeNode *pLeft,
131574: RtreeNode *pRight,
131575: RtreeCell *pBboxLeft,
131576: RtreeCell *pBboxRight
131577: ){
131578: int **aaSorted;
131579: int *aSpare;
131580: int ii;
131581:
131582: int iBestDim = 0;
131583: int iBestSplit = 0;
131584: float fBestMargin = 0.0;
131585:
131586: int nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
131587:
131588: aaSorted = (int **)sqlite3_malloc(nByte);
131589: if( !aaSorted ){
131590: return SQLITE_NOMEM;
131591: }
131592:
131593: aSpare = &((int *)&aaSorted[pRtree->nDim])[pRtree->nDim*nCell];
131594: memset(aaSorted, 0, nByte);
131595: for(ii=0; ii<pRtree->nDim; ii++){
131596: int jj;
131597: aaSorted[ii] = &((int *)&aaSorted[pRtree->nDim])[ii*nCell];
131598: for(jj=0; jj<nCell; jj++){
131599: aaSorted[ii][jj] = jj;
131600: }
131601: SortByDimension(pRtree, aaSorted[ii], nCell, ii, aCell, aSpare);
131602: }
131603:
131604: for(ii=0; ii<pRtree->nDim; ii++){
131605: float margin = 0.0;
131606: float fBestOverlap = 0.0;
131607: float fBestArea = 0.0;
131608: int iBestLeft = 0;
131609: int nLeft;
131610:
131611: for(
131612: nLeft=RTREE_MINCELLS(pRtree);
131613: nLeft<=(nCell-RTREE_MINCELLS(pRtree));
131614: nLeft++
131615: ){
131616: RtreeCell left;
131617: RtreeCell right;
131618: int kk;
131619: float overlap;
131620: float area;
131621:
131622: memcpy(&left, &aCell[aaSorted[ii][0]], sizeof(RtreeCell));
131623: memcpy(&right, &aCell[aaSorted[ii][nCell-1]], sizeof(RtreeCell));
131624: for(kk=1; kk<(nCell-1); kk++){
131625: if( kk<nLeft ){
131626: cellUnion(pRtree, &left, &aCell[aaSorted[ii][kk]]);
131627: }else{
131628: cellUnion(pRtree, &right, &aCell[aaSorted[ii][kk]]);
131629: }
131630: }
131631: margin += cellMargin(pRtree, &left);
131632: margin += cellMargin(pRtree, &right);
131633: overlap = cellOverlap(pRtree, &left, &right, 1, -1);
131634: area = cellArea(pRtree, &left) + cellArea(pRtree, &right);
131635: if( (nLeft==RTREE_MINCELLS(pRtree))
131636: || (overlap<fBestOverlap)
131637: || (overlap==fBestOverlap && area<fBestArea)
131638: ){
131639: iBestLeft = nLeft;
131640: fBestOverlap = overlap;
131641: fBestArea = area;
131642: }
131643: }
131644:
131645: if( ii==0 || margin<fBestMargin ){
131646: iBestDim = ii;
131647: fBestMargin = margin;
131648: iBestSplit = iBestLeft;
131649: }
131650: }
131651:
131652: memcpy(pBboxLeft, &aCell[aaSorted[iBestDim][0]], sizeof(RtreeCell));
131653: memcpy(pBboxRight, &aCell[aaSorted[iBestDim][iBestSplit]], sizeof(RtreeCell));
131654: for(ii=0; ii<nCell; ii++){
131655: RtreeNode *pTarget = (ii<iBestSplit)?pLeft:pRight;
131656: RtreeCell *pBbox = (ii<iBestSplit)?pBboxLeft:pBboxRight;
131657: RtreeCell *pCell = &aCell[aaSorted[iBestDim][ii]];
131658: nodeInsertCell(pRtree, pTarget, pCell);
131659: cellUnion(pRtree, pBbox, pCell);
131660: }
131661:
131662: sqlite3_free(aaSorted);
131663: return SQLITE_OK;
131664: }
131665: #endif
131666:
131667: #if VARIANT_GUTTMAN_SPLIT
131668: /*
131669: ** Implementation of the regular R-tree SplitNode from Guttman[1984].
131670: */
131671: static int splitNodeGuttman(
131672: Rtree *pRtree,
131673: RtreeCell *aCell,
131674: int nCell,
131675: RtreeNode *pLeft,
131676: RtreeNode *pRight,
131677: RtreeCell *pBboxLeft,
131678: RtreeCell *pBboxRight
131679: ){
131680: int iLeftSeed = 0;
131681: int iRightSeed = 1;
131682: int *aiUsed;
131683: int i;
131684:
131685: aiUsed = sqlite3_malloc(sizeof(int)*nCell);
131686: if( !aiUsed ){
131687: return SQLITE_NOMEM;
131688: }
131689: memset(aiUsed, 0, sizeof(int)*nCell);
131690:
131691: PickSeeds(pRtree, aCell, nCell, &iLeftSeed, &iRightSeed);
131692:
131693: memcpy(pBboxLeft, &aCell[iLeftSeed], sizeof(RtreeCell));
131694: memcpy(pBboxRight, &aCell[iRightSeed], sizeof(RtreeCell));
131695: nodeInsertCell(pRtree, pLeft, &aCell[iLeftSeed]);
131696: nodeInsertCell(pRtree, pRight, &aCell[iRightSeed]);
131697: aiUsed[iLeftSeed] = 1;
131698: aiUsed[iRightSeed] = 1;
131699:
131700: for(i=nCell-2; i>0; i--){
131701: RtreeCell *pNext;
131702: pNext = PickNext(pRtree, aCell, nCell, pBboxLeft, pBboxRight, aiUsed);
131703: float diff =
131704: cellGrowth(pRtree, pBboxLeft, pNext) -
131705: cellGrowth(pRtree, pBboxRight, pNext)
131706: ;
131707: if( (RTREE_MINCELLS(pRtree)-NCELL(pRight)==i)
131708: || (diff>0.0 && (RTREE_MINCELLS(pRtree)-NCELL(pLeft)!=i))
131709: ){
131710: nodeInsertCell(pRtree, pRight, pNext);
131711: cellUnion(pRtree, pBboxRight, pNext);
131712: }else{
131713: nodeInsertCell(pRtree, pLeft, pNext);
131714: cellUnion(pRtree, pBboxLeft, pNext);
131715: }
131716: }
131717:
131718: sqlite3_free(aiUsed);
131719: return SQLITE_OK;
131720: }
131721: #endif
131722:
131723: static int updateMapping(
131724: Rtree *pRtree,
131725: i64 iRowid,
131726: RtreeNode *pNode,
131727: int iHeight
131728: ){
131729: int (*xSetMapping)(Rtree *, sqlite3_int64, sqlite3_int64);
131730: xSetMapping = ((iHeight==0)?rowidWrite:parentWrite);
131731: if( iHeight>0 ){
131732: RtreeNode *pChild = nodeHashLookup(pRtree, iRowid);
131733: if( pChild ){
131734: nodeRelease(pRtree, pChild->pParent);
131735: nodeReference(pNode);
131736: pChild->pParent = pNode;
131737: }
131738: }
131739: return xSetMapping(pRtree, iRowid, pNode->iNode);
131740: }
131741:
131742: static int SplitNode(
131743: Rtree *pRtree,
131744: RtreeNode *pNode,
131745: RtreeCell *pCell,
131746: int iHeight
131747: ){
131748: int i;
131749: int newCellIsRight = 0;
131750:
131751: int rc = SQLITE_OK;
131752: int nCell = NCELL(pNode);
131753: RtreeCell *aCell;
131754: int *aiUsed;
131755:
131756: RtreeNode *pLeft = 0;
131757: RtreeNode *pRight = 0;
131758:
131759: RtreeCell leftbbox;
131760: RtreeCell rightbbox;
131761:
131762: /* Allocate an array and populate it with a copy of pCell and
131763: ** all cells from node pLeft. Then zero the original node.
131764: */
131765: aCell = sqlite3_malloc((sizeof(RtreeCell)+sizeof(int))*(nCell+1));
131766: if( !aCell ){
131767: rc = SQLITE_NOMEM;
131768: goto splitnode_out;
131769: }
131770: aiUsed = (int *)&aCell[nCell+1];
131771: memset(aiUsed, 0, sizeof(int)*(nCell+1));
131772: for(i=0; i<nCell; i++){
131773: nodeGetCell(pRtree, pNode, i, &aCell[i]);
131774: }
131775: nodeZero(pRtree, pNode);
131776: memcpy(&aCell[nCell], pCell, sizeof(RtreeCell));
131777: nCell++;
131778:
131779: if( pNode->iNode==1 ){
131780: pRight = nodeNew(pRtree, pNode);
131781: pLeft = nodeNew(pRtree, pNode);
131782: pRtree->iDepth++;
131783: pNode->isDirty = 1;
131784: writeInt16(pNode->zData, pRtree->iDepth);
131785: }else{
131786: pLeft = pNode;
131787: pRight = nodeNew(pRtree, pLeft->pParent);
131788: nodeReference(pLeft);
131789: }
131790:
131791: if( !pLeft || !pRight ){
131792: rc = SQLITE_NOMEM;
131793: goto splitnode_out;
131794: }
131795:
131796: memset(pLeft->zData, 0, pRtree->iNodeSize);
131797: memset(pRight->zData, 0, pRtree->iNodeSize);
131798:
131799: rc = AssignCells(pRtree, aCell, nCell, pLeft, pRight, &leftbbox, &rightbbox);
131800: if( rc!=SQLITE_OK ){
131801: goto splitnode_out;
131802: }
131803:
131804: /* Ensure both child nodes have node numbers assigned to them by calling
131805: ** nodeWrite(). Node pRight always needs a node number, as it was created
131806: ** by nodeNew() above. But node pLeft sometimes already has a node number.
131807: ** In this case avoid the all to nodeWrite().
131808: */
131809: if( SQLITE_OK!=(rc = nodeWrite(pRtree, pRight))
131810: || (0==pLeft->iNode && SQLITE_OK!=(rc = nodeWrite(pRtree, pLeft)))
131811: ){
131812: goto splitnode_out;
131813: }
131814:
131815: rightbbox.iRowid = pRight->iNode;
131816: leftbbox.iRowid = pLeft->iNode;
131817:
131818: if( pNode->iNode==1 ){
131819: rc = rtreeInsertCell(pRtree, pLeft->pParent, &leftbbox, iHeight+1);
131820: if( rc!=SQLITE_OK ){
131821: goto splitnode_out;
131822: }
131823: }else{
131824: RtreeNode *pParent = pLeft->pParent;
131825: int iCell;
131826: rc = nodeParentIndex(pRtree, pLeft, &iCell);
131827: if( rc==SQLITE_OK ){
131828: nodeOverwriteCell(pRtree, pParent, &leftbbox, iCell);
131829: rc = AdjustTree(pRtree, pParent, &leftbbox);
131830: }
131831: if( rc!=SQLITE_OK ){
131832: goto splitnode_out;
131833: }
131834: }
131835: if( (rc = rtreeInsertCell(pRtree, pRight->pParent, &rightbbox, iHeight+1)) ){
131836: goto splitnode_out;
131837: }
131838:
131839: for(i=0; i<NCELL(pRight); i++){
131840: i64 iRowid = nodeGetRowid(pRtree, pRight, i);
131841: rc = updateMapping(pRtree, iRowid, pRight, iHeight);
131842: if( iRowid==pCell->iRowid ){
131843: newCellIsRight = 1;
131844: }
131845: if( rc!=SQLITE_OK ){
131846: goto splitnode_out;
131847: }
131848: }
131849: if( pNode->iNode==1 ){
131850: for(i=0; i<NCELL(pLeft); i++){
131851: i64 iRowid = nodeGetRowid(pRtree, pLeft, i);
131852: rc = updateMapping(pRtree, iRowid, pLeft, iHeight);
131853: if( rc!=SQLITE_OK ){
131854: goto splitnode_out;
131855: }
131856: }
131857: }else if( newCellIsRight==0 ){
131858: rc = updateMapping(pRtree, pCell->iRowid, pLeft, iHeight);
131859: }
131860:
131861: if( rc==SQLITE_OK ){
131862: rc = nodeRelease(pRtree, pRight);
131863: pRight = 0;
131864: }
131865: if( rc==SQLITE_OK ){
131866: rc = nodeRelease(pRtree, pLeft);
131867: pLeft = 0;
131868: }
131869:
131870: splitnode_out:
131871: nodeRelease(pRtree, pRight);
131872: nodeRelease(pRtree, pLeft);
131873: sqlite3_free(aCell);
131874: return rc;
131875: }
131876:
131877: /*
131878: ** If node pLeaf is not the root of the r-tree and its pParent pointer is
131879: ** still NULL, load all ancestor nodes of pLeaf into memory and populate
131880: ** the pLeaf->pParent chain all the way up to the root node.
131881: **
131882: ** This operation is required when a row is deleted (or updated - an update
131883: ** is implemented as a delete followed by an insert). SQLite provides the
131884: ** rowid of the row to delete, which can be used to find the leaf on which
131885: ** the entry resides (argument pLeaf). Once the leaf is located, this
131886: ** function is called to determine its ancestry.
131887: */
131888: static int fixLeafParent(Rtree *pRtree, RtreeNode *pLeaf){
131889: int rc = SQLITE_OK;
131890: RtreeNode *pChild = pLeaf;
131891: while( rc==SQLITE_OK && pChild->iNode!=1 && pChild->pParent==0 ){
131892: int rc2 = SQLITE_OK; /* sqlite3_reset() return code */
131893: sqlite3_bind_int64(pRtree->pReadParent, 1, pChild->iNode);
131894: rc = sqlite3_step(pRtree->pReadParent);
131895: if( rc==SQLITE_ROW ){
131896: RtreeNode *pTest; /* Used to test for reference loops */
131897: i64 iNode; /* Node number of parent node */
131898:
131899: /* Before setting pChild->pParent, test that we are not creating a
131900: ** loop of references (as we would if, say, pChild==pParent). We don't
131901: ** want to do this as it leads to a memory leak when trying to delete
131902: ** the referenced counted node structures.
131903: */
131904: iNode = sqlite3_column_int64(pRtree->pReadParent, 0);
131905: for(pTest=pLeaf; pTest && pTest->iNode!=iNode; pTest=pTest->pParent);
131906: if( !pTest ){
131907: rc2 = nodeAcquire(pRtree, iNode, 0, &pChild->pParent);
131908: }
131909: }
131910: rc = sqlite3_reset(pRtree->pReadParent);
131911: if( rc==SQLITE_OK ) rc = rc2;
131912: if( rc==SQLITE_OK && !pChild->pParent ) rc = SQLITE_CORRUPT_VTAB;
131913: pChild = pChild->pParent;
131914: }
131915: return rc;
131916: }
131917:
131918: static int deleteCell(Rtree *, RtreeNode *, int, int);
131919:
131920: static int removeNode(Rtree *pRtree, RtreeNode *pNode, int iHeight){
131921: int rc;
131922: int rc2;
131923: RtreeNode *pParent = 0;
131924: int iCell;
131925:
131926: assert( pNode->nRef==1 );
131927:
131928: /* Remove the entry in the parent cell. */
131929: rc = nodeParentIndex(pRtree, pNode, &iCell);
131930: if( rc==SQLITE_OK ){
131931: pParent = pNode->pParent;
131932: pNode->pParent = 0;
131933: rc = deleteCell(pRtree, pParent, iCell, iHeight+1);
131934: }
131935: rc2 = nodeRelease(pRtree, pParent);
131936: if( rc==SQLITE_OK ){
131937: rc = rc2;
131938: }
131939: if( rc!=SQLITE_OK ){
131940: return rc;
131941: }
131942:
131943: /* Remove the xxx_node entry. */
131944: sqlite3_bind_int64(pRtree->pDeleteNode, 1, pNode->iNode);
131945: sqlite3_step(pRtree->pDeleteNode);
131946: if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteNode)) ){
131947: return rc;
131948: }
131949:
131950: /* Remove the xxx_parent entry. */
131951: sqlite3_bind_int64(pRtree->pDeleteParent, 1, pNode->iNode);
131952: sqlite3_step(pRtree->pDeleteParent);
131953: if( SQLITE_OK!=(rc = sqlite3_reset(pRtree->pDeleteParent)) ){
131954: return rc;
131955: }
131956:
131957: /* Remove the node from the in-memory hash table and link it into
131958: ** the Rtree.pDeleted list. Its contents will be re-inserted later on.
131959: */
131960: nodeHashDelete(pRtree, pNode);
131961: pNode->iNode = iHeight;
131962: pNode->pNext = pRtree->pDeleted;
131963: pNode->nRef++;
131964: pRtree->pDeleted = pNode;
131965:
131966: return SQLITE_OK;
131967: }
131968:
131969: static int fixBoundingBox(Rtree *pRtree, RtreeNode *pNode){
131970: RtreeNode *pParent = pNode->pParent;
131971: int rc = SQLITE_OK;
131972: if( pParent ){
131973: int ii;
131974: int nCell = NCELL(pNode);
131975: RtreeCell box; /* Bounding box for pNode */
131976: nodeGetCell(pRtree, pNode, 0, &box);
131977: for(ii=1; ii<nCell; ii++){
131978: RtreeCell cell;
131979: nodeGetCell(pRtree, pNode, ii, &cell);
131980: cellUnion(pRtree, &box, &cell);
131981: }
131982: box.iRowid = pNode->iNode;
131983: rc = nodeParentIndex(pRtree, pNode, &ii);
131984: if( rc==SQLITE_OK ){
131985: nodeOverwriteCell(pRtree, pParent, &box, ii);
131986: rc = fixBoundingBox(pRtree, pParent);
131987: }
131988: }
131989: return rc;
131990: }
131991:
131992: /*
131993: ** Delete the cell at index iCell of node pNode. After removing the
131994: ** cell, adjust the r-tree data structure if required.
131995: */
131996: static int deleteCell(Rtree *pRtree, RtreeNode *pNode, int iCell, int iHeight){
131997: RtreeNode *pParent;
131998: int rc;
131999:
132000: if( SQLITE_OK!=(rc = fixLeafParent(pRtree, pNode)) ){
132001: return rc;
132002: }
132003:
132004: /* Remove the cell from the node. This call just moves bytes around
132005: ** the in-memory node image, so it cannot fail.
132006: */
132007: nodeDeleteCell(pRtree, pNode, iCell);
132008:
132009: /* If the node is not the tree root and now has less than the minimum
132010: ** number of cells, remove it from the tree. Otherwise, update the
132011: ** cell in the parent node so that it tightly contains the updated
132012: ** node.
132013: */
132014: pParent = pNode->pParent;
132015: assert( pParent || pNode->iNode==1 );
132016: if( pParent ){
132017: if( NCELL(pNode)<RTREE_MINCELLS(pRtree) ){
132018: rc = removeNode(pRtree, pNode, iHeight);
132019: }else{
132020: rc = fixBoundingBox(pRtree, pNode);
132021: }
132022: }
132023:
132024: return rc;
132025: }
132026:
132027: static int Reinsert(
132028: Rtree *pRtree,
132029: RtreeNode *pNode,
132030: RtreeCell *pCell,
132031: int iHeight
132032: ){
132033: int *aOrder;
132034: int *aSpare;
132035: RtreeCell *aCell;
132036: float *aDistance;
132037: int nCell;
132038: float aCenterCoord[RTREE_MAX_DIMENSIONS];
132039: int iDim;
132040: int ii;
132041: int rc = SQLITE_OK;
132042:
132043: memset(aCenterCoord, 0, sizeof(float)*RTREE_MAX_DIMENSIONS);
132044:
132045: nCell = NCELL(pNode)+1;
132046:
132047: /* Allocate the buffers used by this operation. The allocation is
132048: ** relinquished before this function returns.
132049: */
132050: aCell = (RtreeCell *)sqlite3_malloc(nCell * (
132051: sizeof(RtreeCell) + /* aCell array */
132052: sizeof(int) + /* aOrder array */
132053: sizeof(int) + /* aSpare array */
132054: sizeof(float) /* aDistance array */
132055: ));
132056: if( !aCell ){
132057: return SQLITE_NOMEM;
132058: }
132059: aOrder = (int *)&aCell[nCell];
132060: aSpare = (int *)&aOrder[nCell];
132061: aDistance = (float *)&aSpare[nCell];
132062:
132063: for(ii=0; ii<nCell; ii++){
132064: if( ii==(nCell-1) ){
132065: memcpy(&aCell[ii], pCell, sizeof(RtreeCell));
132066: }else{
132067: nodeGetCell(pRtree, pNode, ii, &aCell[ii]);
132068: }
132069: aOrder[ii] = ii;
132070: for(iDim=0; iDim<pRtree->nDim; iDim++){
132071: aCenterCoord[iDim] += (float)DCOORD(aCell[ii].aCoord[iDim*2]);
132072: aCenterCoord[iDim] += (float)DCOORD(aCell[ii].aCoord[iDim*2+1]);
132073: }
132074: }
132075: for(iDim=0; iDim<pRtree->nDim; iDim++){
132076: aCenterCoord[iDim] = (float)(aCenterCoord[iDim]/((float)nCell*2.0));
132077: }
132078:
132079: for(ii=0; ii<nCell; ii++){
132080: aDistance[ii] = 0.0;
132081: for(iDim=0; iDim<pRtree->nDim; iDim++){
132082: float coord = (float)(DCOORD(aCell[ii].aCoord[iDim*2+1]) -
132083: DCOORD(aCell[ii].aCoord[iDim*2]));
132084: aDistance[ii] += (coord-aCenterCoord[iDim])*(coord-aCenterCoord[iDim]);
132085: }
132086: }
132087:
132088: SortByDistance(aOrder, nCell, aDistance, aSpare);
132089: nodeZero(pRtree, pNode);
132090:
132091: for(ii=0; rc==SQLITE_OK && ii<(nCell-(RTREE_MINCELLS(pRtree)+1)); ii++){
132092: RtreeCell *p = &aCell[aOrder[ii]];
132093: nodeInsertCell(pRtree, pNode, p);
132094: if( p->iRowid==pCell->iRowid ){
132095: if( iHeight==0 ){
132096: rc = rowidWrite(pRtree, p->iRowid, pNode->iNode);
132097: }else{
132098: rc = parentWrite(pRtree, p->iRowid, pNode->iNode);
132099: }
132100: }
132101: }
132102: if( rc==SQLITE_OK ){
132103: rc = fixBoundingBox(pRtree, pNode);
132104: }
132105: for(; rc==SQLITE_OK && ii<nCell; ii++){
132106: /* Find a node to store this cell in. pNode->iNode currently contains
132107: ** the height of the sub-tree headed by the cell.
132108: */
132109: RtreeNode *pInsert;
132110: RtreeCell *p = &aCell[aOrder[ii]];
132111: rc = ChooseLeaf(pRtree, p, iHeight, &pInsert);
132112: if( rc==SQLITE_OK ){
132113: int rc2;
132114: rc = rtreeInsertCell(pRtree, pInsert, p, iHeight);
132115: rc2 = nodeRelease(pRtree, pInsert);
132116: if( rc==SQLITE_OK ){
132117: rc = rc2;
132118: }
132119: }
132120: }
132121:
132122: sqlite3_free(aCell);
132123: return rc;
132124: }
132125:
132126: /*
132127: ** Insert cell pCell into node pNode. Node pNode is the head of a
132128: ** subtree iHeight high (leaf nodes have iHeight==0).
132129: */
132130: static int rtreeInsertCell(
132131: Rtree *pRtree,
132132: RtreeNode *pNode,
132133: RtreeCell *pCell,
132134: int iHeight
132135: ){
132136: int rc = SQLITE_OK;
132137: if( iHeight>0 ){
132138: RtreeNode *pChild = nodeHashLookup(pRtree, pCell->iRowid);
132139: if( pChild ){
132140: nodeRelease(pRtree, pChild->pParent);
132141: nodeReference(pNode);
132142: pChild->pParent = pNode;
132143: }
132144: }
132145: if( nodeInsertCell(pRtree, pNode, pCell) ){
132146: #if VARIANT_RSTARTREE_REINSERT
132147: if( iHeight<=pRtree->iReinsertHeight || pNode->iNode==1){
132148: rc = SplitNode(pRtree, pNode, pCell, iHeight);
132149: }else{
132150: pRtree->iReinsertHeight = iHeight;
132151: rc = Reinsert(pRtree, pNode, pCell, iHeight);
132152: }
132153: #else
132154: rc = SplitNode(pRtree, pNode, pCell, iHeight);
132155: #endif
132156: }else{
132157: rc = AdjustTree(pRtree, pNode, pCell);
132158: if( rc==SQLITE_OK ){
132159: if( iHeight==0 ){
132160: rc = rowidWrite(pRtree, pCell->iRowid, pNode->iNode);
132161: }else{
132162: rc = parentWrite(pRtree, pCell->iRowid, pNode->iNode);
132163: }
132164: }
132165: }
132166: return rc;
132167: }
132168:
132169: static int reinsertNodeContent(Rtree *pRtree, RtreeNode *pNode){
132170: int ii;
132171: int rc = SQLITE_OK;
132172: int nCell = NCELL(pNode);
132173:
132174: for(ii=0; rc==SQLITE_OK && ii<nCell; ii++){
132175: RtreeNode *pInsert;
132176: RtreeCell cell;
132177: nodeGetCell(pRtree, pNode, ii, &cell);
132178:
132179: /* Find a node to store this cell in. pNode->iNode currently contains
132180: ** the height of the sub-tree headed by the cell.
132181: */
132182: rc = ChooseLeaf(pRtree, &cell, (int)pNode->iNode, &pInsert);
132183: if( rc==SQLITE_OK ){
132184: int rc2;
132185: rc = rtreeInsertCell(pRtree, pInsert, &cell, (int)pNode->iNode);
132186: rc2 = nodeRelease(pRtree, pInsert);
132187: if( rc==SQLITE_OK ){
132188: rc = rc2;
132189: }
132190: }
132191: }
132192: return rc;
132193: }
132194:
132195: /*
132196: ** Select a currently unused rowid for a new r-tree record.
132197: */
132198: static int newRowid(Rtree *pRtree, i64 *piRowid){
132199: int rc;
132200: sqlite3_bind_null(pRtree->pWriteRowid, 1);
132201: sqlite3_bind_null(pRtree->pWriteRowid, 2);
132202: sqlite3_step(pRtree->pWriteRowid);
132203: rc = sqlite3_reset(pRtree->pWriteRowid);
132204: *piRowid = sqlite3_last_insert_rowid(pRtree->db);
132205: return rc;
132206: }
132207:
132208: /*
132209: ** Remove the entry with rowid=iDelete from the r-tree structure.
132210: */
132211: static int rtreeDeleteRowid(Rtree *pRtree, sqlite3_int64 iDelete){
132212: int rc; /* Return code */
132213: RtreeNode *pLeaf; /* Leaf node containing record iDelete */
132214: int iCell; /* Index of iDelete cell in pLeaf */
132215: RtreeNode *pRoot; /* Root node of rtree structure */
132216:
132217:
132218: /* Obtain a reference to the root node to initialise Rtree.iDepth */
132219: rc = nodeAcquire(pRtree, 1, 0, &pRoot);
132220:
132221: /* Obtain a reference to the leaf node that contains the entry
132222: ** about to be deleted.
132223: */
132224: if( rc==SQLITE_OK ){
132225: rc = findLeafNode(pRtree, iDelete, &pLeaf);
132226: }
132227:
132228: /* Delete the cell in question from the leaf node. */
132229: if( rc==SQLITE_OK ){
132230: int rc2;
132231: rc = nodeRowidIndex(pRtree, pLeaf, iDelete, &iCell);
132232: if( rc==SQLITE_OK ){
132233: rc = deleteCell(pRtree, pLeaf, iCell, 0);
132234: }
132235: rc2 = nodeRelease(pRtree, pLeaf);
132236: if( rc==SQLITE_OK ){
132237: rc = rc2;
132238: }
132239: }
132240:
132241: /* Delete the corresponding entry in the <rtree>_rowid table. */
132242: if( rc==SQLITE_OK ){
132243: sqlite3_bind_int64(pRtree->pDeleteRowid, 1, iDelete);
132244: sqlite3_step(pRtree->pDeleteRowid);
132245: rc = sqlite3_reset(pRtree->pDeleteRowid);
132246: }
132247:
132248: /* Check if the root node now has exactly one child. If so, remove
132249: ** it, schedule the contents of the child for reinsertion and
132250: ** reduce the tree height by one.
132251: **
132252: ** This is equivalent to copying the contents of the child into
132253: ** the root node (the operation that Gutman's paper says to perform
132254: ** in this scenario).
132255: */
132256: if( rc==SQLITE_OK && pRtree->iDepth>0 && NCELL(pRoot)==1 ){
132257: int rc2;
132258: RtreeNode *pChild;
132259: i64 iChild = nodeGetRowid(pRtree, pRoot, 0);
132260: rc = nodeAcquire(pRtree, iChild, pRoot, &pChild);
132261: if( rc==SQLITE_OK ){
132262: rc = removeNode(pRtree, pChild, pRtree->iDepth-1);
132263: }
132264: rc2 = nodeRelease(pRtree, pChild);
132265: if( rc==SQLITE_OK ) rc = rc2;
132266: if( rc==SQLITE_OK ){
132267: pRtree->iDepth--;
132268: writeInt16(pRoot->zData, pRtree->iDepth);
132269: pRoot->isDirty = 1;
132270: }
132271: }
132272:
132273: /* Re-insert the contents of any underfull nodes removed from the tree. */
132274: for(pLeaf=pRtree->pDeleted; pLeaf; pLeaf=pRtree->pDeleted){
132275: if( rc==SQLITE_OK ){
132276: rc = reinsertNodeContent(pRtree, pLeaf);
132277: }
132278: pRtree->pDeleted = pLeaf->pNext;
132279: sqlite3_free(pLeaf);
132280: }
132281:
132282: /* Release the reference to the root node. */
132283: if( rc==SQLITE_OK ){
132284: rc = nodeRelease(pRtree, pRoot);
132285: }else{
132286: nodeRelease(pRtree, pRoot);
132287: }
132288:
132289: return rc;
132290: }
132291:
132292: /*
132293: ** The xUpdate method for rtree module virtual tables.
132294: */
132295: static int rtreeUpdate(
132296: sqlite3_vtab *pVtab,
132297: int nData,
132298: sqlite3_value **azData,
132299: sqlite_int64 *pRowid
132300: ){
132301: Rtree *pRtree = (Rtree *)pVtab;
132302: int rc = SQLITE_OK;
132303: RtreeCell cell; /* New cell to insert if nData>1 */
132304: int bHaveRowid = 0; /* Set to 1 after new rowid is determined */
132305:
132306: rtreeReference(pRtree);
132307: assert(nData>=1);
132308:
132309: /* Constraint handling. A write operation on an r-tree table may return
132310: ** SQLITE_CONSTRAINT for two reasons:
132311: **
132312: ** 1. A duplicate rowid value, or
132313: ** 2. The supplied data violates the "x2>=x1" constraint.
132314: **
132315: ** In the first case, if the conflict-handling mode is REPLACE, then
132316: ** the conflicting row can be removed before proceeding. In the second
132317: ** case, SQLITE_CONSTRAINT must be returned regardless of the
132318: ** conflict-handling mode specified by the user.
132319: */
132320: if( nData>1 ){
132321: int ii;
132322:
132323: /* Populate the cell.aCoord[] array. The first coordinate is azData[3]. */
132324: assert( nData==(pRtree->nDim*2 + 3) );
132325: if( pRtree->eCoordType==RTREE_COORD_REAL32 ){
132326: for(ii=0; ii<(pRtree->nDim*2); ii+=2){
132327: cell.aCoord[ii].f = (float)sqlite3_value_double(azData[ii+3]);
132328: cell.aCoord[ii+1].f = (float)sqlite3_value_double(azData[ii+4]);
132329: if( cell.aCoord[ii].f>cell.aCoord[ii+1].f ){
132330: rc = SQLITE_CONSTRAINT;
132331: goto constraint;
132332: }
132333: }
132334: }else{
132335: for(ii=0; ii<(pRtree->nDim*2); ii+=2){
132336: cell.aCoord[ii].i = sqlite3_value_int(azData[ii+3]);
132337: cell.aCoord[ii+1].i = sqlite3_value_int(azData[ii+4]);
132338: if( cell.aCoord[ii].i>cell.aCoord[ii+1].i ){
132339: rc = SQLITE_CONSTRAINT;
132340: goto constraint;
132341: }
132342: }
132343: }
132344:
132345: /* If a rowid value was supplied, check if it is already present in
132346: ** the table. If so, the constraint has failed. */
132347: if( sqlite3_value_type(azData[2])!=SQLITE_NULL ){
132348: cell.iRowid = sqlite3_value_int64(azData[2]);
132349: if( sqlite3_value_type(azData[0])==SQLITE_NULL
132350: || sqlite3_value_int64(azData[0])!=cell.iRowid
132351: ){
132352: int steprc;
132353: sqlite3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid);
132354: steprc = sqlite3_step(pRtree->pReadRowid);
132355: rc = sqlite3_reset(pRtree->pReadRowid);
132356: if( SQLITE_ROW==steprc ){
132357: if( sqlite3_vtab_on_conflict(pRtree->db)==SQLITE_REPLACE ){
132358: rc = rtreeDeleteRowid(pRtree, cell.iRowid);
132359: }else{
132360: rc = SQLITE_CONSTRAINT;
132361: goto constraint;
132362: }
132363: }
132364: }
132365: bHaveRowid = 1;
132366: }
132367: }
132368:
132369: /* If azData[0] is not an SQL NULL value, it is the rowid of a
132370: ** record to delete from the r-tree table. The following block does
132371: ** just that.
132372: */
132373: if( sqlite3_value_type(azData[0])!=SQLITE_NULL ){
132374: rc = rtreeDeleteRowid(pRtree, sqlite3_value_int64(azData[0]));
132375: }
132376:
132377: /* If the azData[] array contains more than one element, elements
132378: ** (azData[2]..azData[argc-1]) contain a new record to insert into
132379: ** the r-tree structure.
132380: */
132381: if( rc==SQLITE_OK && nData>1 ){
132382: /* Insert the new record into the r-tree */
132383: RtreeNode *pLeaf;
132384:
132385: /* Figure out the rowid of the new row. */
132386: if( bHaveRowid==0 ){
132387: rc = newRowid(pRtree, &cell.iRowid);
132388: }
132389: *pRowid = cell.iRowid;
132390:
132391: if( rc==SQLITE_OK ){
132392: rc = ChooseLeaf(pRtree, &cell, 0, &pLeaf);
132393: }
132394: if( rc==SQLITE_OK ){
132395: int rc2;
132396: pRtree->iReinsertHeight = -1;
132397: rc = rtreeInsertCell(pRtree, pLeaf, &cell, 0);
132398: rc2 = nodeRelease(pRtree, pLeaf);
132399: if( rc==SQLITE_OK ){
132400: rc = rc2;
132401: }
132402: }
132403: }
132404:
132405: constraint:
132406: rtreeRelease(pRtree);
132407: return rc;
132408: }
132409:
132410: /*
132411: ** The xRename method for rtree module virtual tables.
132412: */
132413: static int rtreeRename(sqlite3_vtab *pVtab, const char *zNewName){
132414: Rtree *pRtree = (Rtree *)pVtab;
132415: int rc = SQLITE_NOMEM;
132416: char *zSql = sqlite3_mprintf(
132417: "ALTER TABLE %Q.'%q_node' RENAME TO \"%w_node\";"
132418: "ALTER TABLE %Q.'%q_parent' RENAME TO \"%w_parent\";"
132419: "ALTER TABLE %Q.'%q_rowid' RENAME TO \"%w_rowid\";"
132420: , pRtree->zDb, pRtree->zName, zNewName
132421: , pRtree->zDb, pRtree->zName, zNewName
132422: , pRtree->zDb, pRtree->zName, zNewName
132423: );
132424: if( zSql ){
132425: rc = sqlite3_exec(pRtree->db, zSql, 0, 0, 0);
132426: sqlite3_free(zSql);
132427: }
132428: return rc;
132429: }
132430:
132431: static sqlite3_module rtreeModule = {
132432: 0, /* iVersion */
132433: rtreeCreate, /* xCreate - create a table */
132434: rtreeConnect, /* xConnect - connect to an existing table */
132435: rtreeBestIndex, /* xBestIndex - Determine search strategy */
132436: rtreeDisconnect, /* xDisconnect - Disconnect from a table */
132437: rtreeDestroy, /* xDestroy - Drop a table */
132438: rtreeOpen, /* xOpen - open a cursor */
132439: rtreeClose, /* xClose - close a cursor */
132440: rtreeFilter, /* xFilter - configure scan constraints */
132441: rtreeNext, /* xNext - advance a cursor */
132442: rtreeEof, /* xEof */
132443: rtreeColumn, /* xColumn - read data */
132444: rtreeRowid, /* xRowid - read data */
132445: rtreeUpdate, /* xUpdate - write data */
132446: 0, /* xBegin - begin transaction */
132447: 0, /* xSync - sync transaction */
132448: 0, /* xCommit - commit transaction */
132449: 0, /* xRollback - rollback transaction */
132450: 0, /* xFindFunction - function overloading */
132451: rtreeRename, /* xRename - rename the table */
132452: 0, /* xSavepoint */
132453: 0, /* xRelease */
132454: 0 /* xRollbackTo */
132455: };
132456:
132457: static int rtreeSqlInit(
132458: Rtree *pRtree,
132459: sqlite3 *db,
132460: const char *zDb,
132461: const char *zPrefix,
132462: int isCreate
132463: ){
132464: int rc = SQLITE_OK;
132465:
132466: #define N_STATEMENT 9
132467: static const char *azSql[N_STATEMENT] = {
132468: /* Read and write the xxx_node table */
132469: "SELECT data FROM '%q'.'%q_node' WHERE nodeno = :1",
132470: "INSERT OR REPLACE INTO '%q'.'%q_node' VALUES(:1, :2)",
132471: "DELETE FROM '%q'.'%q_node' WHERE nodeno = :1",
132472:
132473: /* Read and write the xxx_rowid table */
132474: "SELECT nodeno FROM '%q'.'%q_rowid' WHERE rowid = :1",
132475: "INSERT OR REPLACE INTO '%q'.'%q_rowid' VALUES(:1, :2)",
132476: "DELETE FROM '%q'.'%q_rowid' WHERE rowid = :1",
132477:
132478: /* Read and write the xxx_parent table */
132479: "SELECT parentnode FROM '%q'.'%q_parent' WHERE nodeno = :1",
132480: "INSERT OR REPLACE INTO '%q'.'%q_parent' VALUES(:1, :2)",
132481: "DELETE FROM '%q'.'%q_parent' WHERE nodeno = :1"
132482: };
132483: sqlite3_stmt **appStmt[N_STATEMENT];
132484: int i;
132485:
132486: pRtree->db = db;
132487:
132488: if( isCreate ){
132489: char *zCreate = sqlite3_mprintf(
132490: "CREATE TABLE \"%w\".\"%w_node\"(nodeno INTEGER PRIMARY KEY, data BLOB);"
132491: "CREATE TABLE \"%w\".\"%w_rowid\"(rowid INTEGER PRIMARY KEY, nodeno INTEGER);"
132492: "CREATE TABLE \"%w\".\"%w_parent\"(nodeno INTEGER PRIMARY KEY, parentnode INTEGER);"
132493: "INSERT INTO '%q'.'%q_node' VALUES(1, zeroblob(%d))",
132494: zDb, zPrefix, zDb, zPrefix, zDb, zPrefix, zDb, zPrefix, pRtree->iNodeSize
132495: );
132496: if( !zCreate ){
132497: return SQLITE_NOMEM;
132498: }
132499: rc = sqlite3_exec(db, zCreate, 0, 0, 0);
132500: sqlite3_free(zCreate);
132501: if( rc!=SQLITE_OK ){
132502: return rc;
132503: }
132504: }
132505:
132506: appStmt[0] = &pRtree->pReadNode;
132507: appStmt[1] = &pRtree->pWriteNode;
132508: appStmt[2] = &pRtree->pDeleteNode;
132509: appStmt[3] = &pRtree->pReadRowid;
132510: appStmt[4] = &pRtree->pWriteRowid;
132511: appStmt[5] = &pRtree->pDeleteRowid;
132512: appStmt[6] = &pRtree->pReadParent;
132513: appStmt[7] = &pRtree->pWriteParent;
132514: appStmt[8] = &pRtree->pDeleteParent;
132515:
132516: for(i=0; i<N_STATEMENT && rc==SQLITE_OK; i++){
132517: char *zSql = sqlite3_mprintf(azSql[i], zDb, zPrefix);
132518: if( zSql ){
132519: rc = sqlite3_prepare_v2(db, zSql, -1, appStmt[i], 0);
132520: }else{
132521: rc = SQLITE_NOMEM;
132522: }
132523: sqlite3_free(zSql);
132524: }
132525:
132526: return rc;
132527: }
132528:
132529: /*
132530: ** The second argument to this function contains the text of an SQL statement
132531: ** that returns a single integer value. The statement is compiled and executed
132532: ** using database connection db. If successful, the integer value returned
132533: ** is written to *piVal and SQLITE_OK returned. Otherwise, an SQLite error
132534: ** code is returned and the value of *piVal after returning is not defined.
132535: */
132536: static int getIntFromStmt(sqlite3 *db, const char *zSql, int *piVal){
132537: int rc = SQLITE_NOMEM;
132538: if( zSql ){
132539: sqlite3_stmt *pStmt = 0;
132540: rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
132541: if( rc==SQLITE_OK ){
132542: if( SQLITE_ROW==sqlite3_step(pStmt) ){
132543: *piVal = sqlite3_column_int(pStmt, 0);
132544: }
132545: rc = sqlite3_finalize(pStmt);
132546: }
132547: }
132548: return rc;
132549: }
132550:
132551: /*
132552: ** This function is called from within the xConnect() or xCreate() method to
132553: ** determine the node-size used by the rtree table being created or connected
132554: ** to. If successful, pRtree->iNodeSize is populated and SQLITE_OK returned.
132555: ** Otherwise, an SQLite error code is returned.
132556: **
132557: ** If this function is being called as part of an xConnect(), then the rtree
132558: ** table already exists. In this case the node-size is determined by inspecting
132559: ** the root node of the tree.
132560: **
132561: ** Otherwise, for an xCreate(), use 64 bytes less than the database page-size.
132562: ** This ensures that each node is stored on a single database page. If the
132563: ** database page-size is so large that more than RTREE_MAXCELLS entries
132564: ** would fit in a single node, use a smaller node-size.
132565: */
132566: static int getNodeSize(
132567: sqlite3 *db, /* Database handle */
132568: Rtree *pRtree, /* Rtree handle */
132569: int isCreate /* True for xCreate, false for xConnect */
132570: ){
132571: int rc;
132572: char *zSql;
132573: if( isCreate ){
132574: int iPageSize = 0;
132575: zSql = sqlite3_mprintf("PRAGMA %Q.page_size", pRtree->zDb);
132576: rc = getIntFromStmt(db, zSql, &iPageSize);
132577: if( rc==SQLITE_OK ){
132578: pRtree->iNodeSize = iPageSize-64;
132579: if( (4+pRtree->nBytesPerCell*RTREE_MAXCELLS)<pRtree->iNodeSize ){
132580: pRtree->iNodeSize = 4+pRtree->nBytesPerCell*RTREE_MAXCELLS;
132581: }
132582: }
132583: }else{
132584: zSql = sqlite3_mprintf(
132585: "SELECT length(data) FROM '%q'.'%q_node' WHERE nodeno = 1",
132586: pRtree->zDb, pRtree->zName
132587: );
132588: rc = getIntFromStmt(db, zSql, &pRtree->iNodeSize);
132589: }
132590:
132591: sqlite3_free(zSql);
132592: return rc;
132593: }
132594:
132595: /*
132596: ** This function is the implementation of both the xConnect and xCreate
132597: ** methods of the r-tree virtual table.
132598: **
132599: ** argv[0] -> module name
132600: ** argv[1] -> database name
132601: ** argv[2] -> table name
132602: ** argv[...] -> column names...
132603: */
132604: static int rtreeInit(
132605: sqlite3 *db, /* Database connection */
132606: void *pAux, /* One of the RTREE_COORD_* constants */
132607: int argc, const char *const*argv, /* Parameters to CREATE TABLE statement */
132608: sqlite3_vtab **ppVtab, /* OUT: New virtual table */
132609: char **pzErr, /* OUT: Error message, if any */
132610: int isCreate /* True for xCreate, false for xConnect */
132611: ){
132612: int rc = SQLITE_OK;
132613: Rtree *pRtree;
132614: int nDb; /* Length of string argv[1] */
132615: int nName; /* Length of string argv[2] */
132616: int eCoordType = (pAux ? RTREE_COORD_INT32 : RTREE_COORD_REAL32);
132617:
132618: const char *aErrMsg[] = {
132619: 0, /* 0 */
132620: "Wrong number of columns for an rtree table", /* 1 */
132621: "Too few columns for an rtree table", /* 2 */
132622: "Too many columns for an rtree table" /* 3 */
132623: };
132624:
132625: int iErr = (argc<6) ? 2 : argc>(RTREE_MAX_DIMENSIONS*2+4) ? 3 : argc%2;
132626: if( aErrMsg[iErr] ){
132627: *pzErr = sqlite3_mprintf("%s", aErrMsg[iErr]);
132628: return SQLITE_ERROR;
132629: }
132630:
132631: sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1);
132632:
132633: /* Allocate the sqlite3_vtab structure */
132634: nDb = strlen(argv[1]);
132635: nName = strlen(argv[2]);
132636: pRtree = (Rtree *)sqlite3_malloc(sizeof(Rtree)+nDb+nName+2);
132637: if( !pRtree ){
132638: return SQLITE_NOMEM;
132639: }
132640: memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2);
132641: pRtree->nBusy = 1;
132642: pRtree->base.pModule = &rtreeModule;
132643: pRtree->zDb = (char *)&pRtree[1];
132644: pRtree->zName = &pRtree->zDb[nDb+1];
132645: pRtree->nDim = (argc-4)/2;
132646: pRtree->nBytesPerCell = 8 + pRtree->nDim*4*2;
132647: pRtree->eCoordType = eCoordType;
132648: memcpy(pRtree->zDb, argv[1], nDb);
132649: memcpy(pRtree->zName, argv[2], nName);
132650:
132651: /* Figure out the node size to use. */
132652: rc = getNodeSize(db, pRtree, isCreate);
132653:
132654: /* Create/Connect to the underlying relational database schema. If
132655: ** that is successful, call sqlite3_declare_vtab() to configure
132656: ** the r-tree table schema.
132657: */
132658: if( rc==SQLITE_OK ){
132659: if( (rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate)) ){
132660: *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
132661: }else{
132662: char *zSql = sqlite3_mprintf("CREATE TABLE x(%s", argv[3]);
132663: char *zTmp;
132664: int ii;
132665: for(ii=4; zSql && ii<argc; ii++){
132666: zTmp = zSql;
132667: zSql = sqlite3_mprintf("%s, %s", zTmp, argv[ii]);
132668: sqlite3_free(zTmp);
132669: }
132670: if( zSql ){
132671: zTmp = zSql;
132672: zSql = sqlite3_mprintf("%s);", zTmp);
132673: sqlite3_free(zTmp);
132674: }
132675: if( !zSql ){
132676: rc = SQLITE_NOMEM;
132677: }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
132678: *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
132679: }
132680: sqlite3_free(zSql);
132681: }
132682: }
132683:
132684: if( rc==SQLITE_OK ){
132685: *ppVtab = (sqlite3_vtab *)pRtree;
132686: }else{
132687: rtreeRelease(pRtree);
132688: }
132689: return rc;
132690: }
132691:
132692:
132693: /*
132694: ** Implementation of a scalar function that decodes r-tree nodes to
132695: ** human readable strings. This can be used for debugging and analysis.
132696: **
132697: ** The scalar function takes two arguments, a blob of data containing
132698: ** an r-tree node, and the number of dimensions the r-tree indexes.
132699: ** For a two-dimensional r-tree structure called "rt", to deserialize
132700: ** all nodes, a statement like:
132701: **
132702: ** SELECT rtreenode(2, data) FROM rt_node;
132703: **
132704: ** The human readable string takes the form of a Tcl list with one
132705: ** entry for each cell in the r-tree node. Each entry is itself a
132706: ** list, containing the 8-byte rowid/pageno followed by the
132707: ** <num-dimension>*2 coordinates.
132708: */
132709: static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
132710: char *zText = 0;
132711: RtreeNode node;
132712: Rtree tree;
132713: int ii;
132714:
132715: UNUSED_PARAMETER(nArg);
132716: memset(&node, 0, sizeof(RtreeNode));
132717: memset(&tree, 0, sizeof(Rtree));
132718: tree.nDim = sqlite3_value_int(apArg[0]);
132719: tree.nBytesPerCell = 8 + 8 * tree.nDim;
132720: node.zData = (u8 *)sqlite3_value_blob(apArg[1]);
132721:
132722: for(ii=0; ii<NCELL(&node); ii++){
132723: char zCell[512];
132724: int nCell = 0;
132725: RtreeCell cell;
132726: int jj;
132727:
132728: nodeGetCell(&tree, &node, ii, &cell);
132729: sqlite3_snprintf(512-nCell,&zCell[nCell],"%lld", cell.iRowid);
132730: nCell = strlen(zCell);
132731: for(jj=0; jj<tree.nDim*2; jj++){
132732: sqlite3_snprintf(512-nCell,&zCell[nCell]," %f",(double)cell.aCoord[jj].f);
132733: nCell = strlen(zCell);
132734: }
132735:
132736: if( zText ){
132737: char *zTextNew = sqlite3_mprintf("%s {%s}", zText, zCell);
132738: sqlite3_free(zText);
132739: zText = zTextNew;
132740: }else{
132741: zText = sqlite3_mprintf("{%s}", zCell);
132742: }
132743: }
132744:
132745: sqlite3_result_text(ctx, zText, -1, sqlite3_free);
132746: }
132747:
132748: static void rtreedepth(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
132749: UNUSED_PARAMETER(nArg);
132750: if( sqlite3_value_type(apArg[0])!=SQLITE_BLOB
132751: || sqlite3_value_bytes(apArg[0])<2
132752: ){
132753: sqlite3_result_error(ctx, "Invalid argument to rtreedepth()", -1);
132754: }else{
132755: u8 *zBlob = (u8 *)sqlite3_value_blob(apArg[0]);
132756: sqlite3_result_int(ctx, readInt16(zBlob));
132757: }
132758: }
132759:
132760: /*
132761: ** Register the r-tree module with database handle db. This creates the
132762: ** virtual table module "rtree" and the debugging/analysis scalar
132763: ** function "rtreenode".
132764: */
132765: SQLITE_PRIVATE int sqlite3RtreeInit(sqlite3 *db){
132766: const int utf8 = SQLITE_UTF8;
132767: int rc;
132768:
132769: rc = sqlite3_create_function(db, "rtreenode", 2, utf8, 0, rtreenode, 0, 0);
132770: if( rc==SQLITE_OK ){
132771: rc = sqlite3_create_function(db, "rtreedepth", 1, utf8, 0,rtreedepth, 0, 0);
132772: }
132773: if( rc==SQLITE_OK ){
132774: void *c = (void *)RTREE_COORD_REAL32;
132775: rc = sqlite3_create_module_v2(db, "rtree", &rtreeModule, c, 0);
132776: }
132777: if( rc==SQLITE_OK ){
132778: void *c = (void *)RTREE_COORD_INT32;
132779: rc = sqlite3_create_module_v2(db, "rtree_i32", &rtreeModule, c, 0);
132780: }
132781:
132782: return rc;
132783: }
132784:
132785: /*
132786: ** A version of sqlite3_free() that can be used as a callback. This is used
132787: ** in two places - as the destructor for the blob value returned by the
132788: ** invocation of a geometry function, and as the destructor for the geometry
132789: ** functions themselves.
132790: */
132791: static void doSqlite3Free(void *p){
132792: sqlite3_free(p);
132793: }
132794:
132795: /*
132796: ** Each call to sqlite3_rtree_geometry_callback() creates an ordinary SQLite
132797: ** scalar user function. This C function is the callback used for all such
132798: ** registered SQL functions.
132799: **
132800: ** The scalar user functions return a blob that is interpreted by r-tree
132801: ** table MATCH operators.
132802: */
132803: static void geomCallback(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){
132804: RtreeGeomCallback *pGeomCtx = (RtreeGeomCallback *)sqlite3_user_data(ctx);
132805: RtreeMatchArg *pBlob;
132806: int nBlob;
132807:
132808: nBlob = sizeof(RtreeMatchArg) + (nArg-1)*sizeof(double);
132809: pBlob = (RtreeMatchArg *)sqlite3_malloc(nBlob);
132810: if( !pBlob ){
132811: sqlite3_result_error_nomem(ctx);
132812: }else{
132813: int i;
132814: pBlob->magic = RTREE_GEOMETRY_MAGIC;
132815: pBlob->xGeom = pGeomCtx->xGeom;
132816: pBlob->pContext = pGeomCtx->pContext;
132817: pBlob->nParam = nArg;
132818: for(i=0; i<nArg; i++){
132819: pBlob->aParam[i] = sqlite3_value_double(aArg[i]);
132820: }
132821: sqlite3_result_blob(ctx, pBlob, nBlob, doSqlite3Free);
132822: }
132823: }
132824:
132825: /*
132826: ** Register a new geometry function for use with the r-tree MATCH operator.
132827: */
132828: SQLITE_API int sqlite3_rtree_geometry_callback(
132829: sqlite3 *db,
132830: const char *zGeom,
132831: int (*xGeom)(sqlite3_rtree_geometry *, int, double *, int *),
132832: void *pContext
132833: ){
132834: RtreeGeomCallback *pGeomCtx; /* Context object for new user-function */
132835:
132836: /* Allocate and populate the context object. */
132837: pGeomCtx = (RtreeGeomCallback *)sqlite3_malloc(sizeof(RtreeGeomCallback));
132838: if( !pGeomCtx ) return SQLITE_NOMEM;
132839: pGeomCtx->xGeom = xGeom;
132840: pGeomCtx->pContext = pContext;
132841:
132842: /* Create the new user-function. Register a destructor function to delete
132843: ** the context object when it is no longer required. */
132844: return sqlite3_create_function_v2(db, zGeom, -1, SQLITE_ANY,
132845: (void *)pGeomCtx, geomCallback, 0, 0, doSqlite3Free
132846: );
132847: }
132848:
132849: #if !SQLITE_CORE
132850: SQLITE_API int sqlite3_extension_init(
132851: sqlite3 *db,
132852: char **pzErrMsg,
132853: const sqlite3_api_routines *pApi
132854: ){
132855: SQLITE_EXTENSION_INIT2(pApi)
132856: return sqlite3RtreeInit(db);
132857: }
132858: #endif
132859:
132860: #endif
132861:
132862: /************** End of rtree.c ***********************************************/
132863: /************** Begin file icu.c *********************************************/
132864: /*
132865: ** 2007 May 6
132866: **
132867: ** The author disclaims copyright to this source code. In place of
132868: ** a legal notice, here is a blessing:
132869: **
132870: ** May you do good and not evil.
132871: ** May you find forgiveness for yourself and forgive others.
132872: ** May you share freely, never taking more than you give.
132873: **
132874: *************************************************************************
132875: ** $Id: sqlite3.c,v 1.2 2012/10/12 08:22:46 misho Exp $
132876: **
132877: ** This file implements an integration between the ICU library
132878: ** ("International Components for Unicode", an open-source library
132879: ** for handling unicode data) and SQLite. The integration uses
132880: ** ICU to provide the following to SQLite:
132881: **
132882: ** * An implementation of the SQL regexp() function (and hence REGEXP
132883: ** operator) using the ICU uregex_XX() APIs.
132884: **
132885: ** * Implementations of the SQL scalar upper() and lower() functions
132886: ** for case mapping.
132887: **
132888: ** * Integration of ICU and SQLite collation seqences.
132889: **
132890: ** * An implementation of the LIKE operator that uses ICU to
132891: ** provide case-independent matching.
132892: */
132893:
132894: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU)
132895:
132896: /* Include ICU headers */
132897: #include <unicode/utypes.h>
132898: #include <unicode/uregex.h>
132899: #include <unicode/ustring.h>
132900: #include <unicode/ucol.h>
132901:
132902: /* #include <assert.h> */
132903:
132904: #ifndef SQLITE_CORE
132905: SQLITE_EXTENSION_INIT1
132906: #else
132907: #endif
132908:
132909: /*
132910: ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
132911: ** operator.
132912: */
132913: #ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
132914: # define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
132915: #endif
132916:
132917: /*
132918: ** Version of sqlite3_free() that is always a function, never a macro.
132919: */
132920: static void xFree(void *p){
132921: sqlite3_free(p);
132922: }
132923:
132924: /*
132925: ** Compare two UTF-8 strings for equality where the first string is
132926: ** a "LIKE" expression. Return true (1) if they are the same and
132927: ** false (0) if they are different.
132928: */
132929: static int icuLikeCompare(
132930: const uint8_t *zPattern, /* LIKE pattern */
132931: const uint8_t *zString, /* The UTF-8 string to compare against */
132932: const UChar32 uEsc /* The escape character */
132933: ){
132934: static const int MATCH_ONE = (UChar32)'_';
132935: static const int MATCH_ALL = (UChar32)'%';
132936:
132937: int iPattern = 0; /* Current byte index in zPattern */
132938: int iString = 0; /* Current byte index in zString */
132939:
132940: int prevEscape = 0; /* True if the previous character was uEsc */
132941:
132942: while( zPattern[iPattern]!=0 ){
132943:
132944: /* Read (and consume) the next character from the input pattern. */
132945: UChar32 uPattern;
132946: U8_NEXT_UNSAFE(zPattern, iPattern, uPattern);
132947: assert(uPattern!=0);
132948:
132949: /* There are now 4 possibilities:
132950: **
132951: ** 1. uPattern is an unescaped match-all character "%",
132952: ** 2. uPattern is an unescaped match-one character "_",
132953: ** 3. uPattern is an unescaped escape character, or
132954: ** 4. uPattern is to be handled as an ordinary character
132955: */
132956: if( !prevEscape && uPattern==MATCH_ALL ){
132957: /* Case 1. */
132958: uint8_t c;
132959:
132960: /* Skip any MATCH_ALL or MATCH_ONE characters that follow a
132961: ** MATCH_ALL. For each MATCH_ONE, skip one character in the
132962: ** test string.
132963: */
132964: while( (c=zPattern[iPattern]) == MATCH_ALL || c == MATCH_ONE ){
132965: if( c==MATCH_ONE ){
132966: if( zString[iString]==0 ) return 0;
132967: U8_FWD_1_UNSAFE(zString, iString);
132968: }
132969: iPattern++;
132970: }
132971:
132972: if( zPattern[iPattern]==0 ) return 1;
132973:
132974: while( zString[iString] ){
132975: if( icuLikeCompare(&zPattern[iPattern], &zString[iString], uEsc) ){
132976: return 1;
132977: }
132978: U8_FWD_1_UNSAFE(zString, iString);
132979: }
132980: return 0;
132981:
132982: }else if( !prevEscape && uPattern==MATCH_ONE ){
132983: /* Case 2. */
132984: if( zString[iString]==0 ) return 0;
132985: U8_FWD_1_UNSAFE(zString, iString);
132986:
132987: }else if( !prevEscape && uPattern==uEsc){
132988: /* Case 3. */
132989: prevEscape = 1;
132990:
132991: }else{
132992: /* Case 4. */
132993: UChar32 uString;
132994: U8_NEXT_UNSAFE(zString, iString, uString);
132995: uString = u_foldCase(uString, U_FOLD_CASE_DEFAULT);
132996: uPattern = u_foldCase(uPattern, U_FOLD_CASE_DEFAULT);
132997: if( uString!=uPattern ){
132998: return 0;
132999: }
133000: prevEscape = 0;
133001: }
133002: }
133003:
133004: return zString[iString]==0;
133005: }
133006:
133007: /*
133008: ** Implementation of the like() SQL function. This function implements
133009: ** the build-in LIKE operator. The first argument to the function is the
133010: ** pattern and the second argument is the string. So, the SQL statements:
133011: **
133012: ** A LIKE B
133013: **
133014: ** is implemented as like(B, A). If there is an escape character E,
133015: **
133016: ** A LIKE B ESCAPE E
133017: **
133018: ** is mapped to like(B, A, E).
133019: */
133020: static void icuLikeFunc(
133021: sqlite3_context *context,
133022: int argc,
133023: sqlite3_value **argv
133024: ){
133025: const unsigned char *zA = sqlite3_value_text(argv[0]);
133026: const unsigned char *zB = sqlite3_value_text(argv[1]);
133027: UChar32 uEsc = 0;
133028:
133029: /* Limit the length of the LIKE or GLOB pattern to avoid problems
133030: ** of deep recursion and N*N behavior in patternCompare().
133031: */
133032: if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){
133033: sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
133034: return;
133035: }
133036:
133037:
133038: if( argc==3 ){
133039: /* The escape character string must consist of a single UTF-8 character.
133040: ** Otherwise, return an error.
133041: */
133042: int nE= sqlite3_value_bytes(argv[2]);
133043: const unsigned char *zE = sqlite3_value_text(argv[2]);
133044: int i = 0;
133045: if( zE==0 ) return;
133046: U8_NEXT(zE, i, nE, uEsc);
133047: if( i!=nE){
133048: sqlite3_result_error(context,
133049: "ESCAPE expression must be a single character", -1);
133050: return;
133051: }
133052: }
133053:
133054: if( zA && zB ){
133055: sqlite3_result_int(context, icuLikeCompare(zA, zB, uEsc));
133056: }
133057: }
133058:
133059: /*
133060: ** This function is called when an ICU function called from within
133061: ** the implementation of an SQL scalar function returns an error.
133062: **
133063: ** The scalar function context passed as the first argument is
133064: ** loaded with an error message based on the following two args.
133065: */
133066: static void icuFunctionError(
133067: sqlite3_context *pCtx, /* SQLite scalar function context */
133068: const char *zName, /* Name of ICU function that failed */
133069: UErrorCode e /* Error code returned by ICU function */
133070: ){
133071: char zBuf[128];
133072: sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
133073: zBuf[127] = '\0';
133074: sqlite3_result_error(pCtx, zBuf, -1);
133075: }
133076:
133077: /*
133078: ** Function to delete compiled regexp objects. Registered as
133079: ** a destructor function with sqlite3_set_auxdata().
133080: */
133081: static void icuRegexpDelete(void *p){
133082: URegularExpression *pExpr = (URegularExpression *)p;
133083: uregex_close(pExpr);
133084: }
133085:
133086: /*
133087: ** Implementation of SQLite REGEXP operator. This scalar function takes
133088: ** two arguments. The first is a regular expression pattern to compile
133089: ** the second is a string to match against that pattern. If either
133090: ** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
133091: ** is 1 if the string matches the pattern, or 0 otherwise.
133092: **
133093: ** SQLite maps the regexp() function to the regexp() operator such
133094: ** that the following two are equivalent:
133095: **
133096: ** zString REGEXP zPattern
133097: ** regexp(zPattern, zString)
133098: **
133099: ** Uses the following ICU regexp APIs:
133100: **
133101: ** uregex_open()
133102: ** uregex_matches()
133103: ** uregex_close()
133104: */
133105: static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){
133106: UErrorCode status = U_ZERO_ERROR;
133107: URegularExpression *pExpr;
133108: UBool res;
133109: const UChar *zString = sqlite3_value_text16(apArg[1]);
133110:
133111: (void)nArg; /* Unused parameter */
133112:
133113: /* If the left hand side of the regexp operator is NULL,
133114: ** then the result is also NULL.
133115: */
133116: if( !zString ){
133117: return;
133118: }
133119:
133120: pExpr = sqlite3_get_auxdata(p, 0);
133121: if( !pExpr ){
133122: const UChar *zPattern = sqlite3_value_text16(apArg[0]);
133123: if( !zPattern ){
133124: return;
133125: }
133126: pExpr = uregex_open(zPattern, -1, 0, 0, &status);
133127:
133128: if( U_SUCCESS(status) ){
133129: sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
133130: }else{
133131: assert(!pExpr);
133132: icuFunctionError(p, "uregex_open", status);
133133: return;
133134: }
133135: }
133136:
133137: /* Configure the text that the regular expression operates on. */
133138: uregex_setText(pExpr, zString, -1, &status);
133139: if( !U_SUCCESS(status) ){
133140: icuFunctionError(p, "uregex_setText", status);
133141: return;
133142: }
133143:
133144: /* Attempt the match */
133145: res = uregex_matches(pExpr, 0, &status);
133146: if( !U_SUCCESS(status) ){
133147: icuFunctionError(p, "uregex_matches", status);
133148: return;
133149: }
133150:
133151: /* Set the text that the regular expression operates on to a NULL
133152: ** pointer. This is not really necessary, but it is tidier than
133153: ** leaving the regular expression object configured with an invalid
133154: ** pointer after this function returns.
133155: */
133156: uregex_setText(pExpr, 0, 0, &status);
133157:
133158: /* Return 1 or 0. */
133159: sqlite3_result_int(p, res ? 1 : 0);
133160: }
133161:
133162: /*
133163: ** Implementations of scalar functions for case mapping - upper() and
133164: ** lower(). Function upper() converts its input to upper-case (ABC).
133165: ** Function lower() converts to lower-case (abc).
133166: **
133167: ** ICU provides two types of case mapping, "general" case mapping and
133168: ** "language specific". Refer to ICU documentation for the differences
133169: ** between the two.
133170: **
133171: ** To utilise "general" case mapping, the upper() or lower() scalar
133172: ** functions are invoked with one argument:
133173: **
133174: ** upper('ABC') -> 'abc'
133175: ** lower('abc') -> 'ABC'
133176: **
133177: ** To access ICU "language specific" case mapping, upper() or lower()
133178: ** should be invoked with two arguments. The second argument is the name
133179: ** of the locale to use. Passing an empty string ("") or SQL NULL value
133180: ** as the second argument is the same as invoking the 1 argument version
133181: ** of upper() or lower().
133182: **
133183: ** lower('I', 'en_us') -> 'i'
133184: ** lower('I', 'tr_tr') -> 'ı' (small dotless i)
133185: **
133186: ** http://www.icu-project.org/userguide/posix.html#case_mappings
133187: */
133188: static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){
133189: const UChar *zInput;
133190: UChar *zOutput;
133191: int nInput;
133192: int nOutput;
133193:
133194: UErrorCode status = U_ZERO_ERROR;
133195: const char *zLocale = 0;
133196:
133197: assert(nArg==1 || nArg==2);
133198: if( nArg==2 ){
133199: zLocale = (const char *)sqlite3_value_text(apArg[1]);
133200: }
133201:
133202: zInput = sqlite3_value_text16(apArg[0]);
133203: if( !zInput ){
133204: return;
133205: }
133206: nInput = sqlite3_value_bytes16(apArg[0]);
133207:
133208: nOutput = nInput * 2 + 2;
133209: zOutput = sqlite3_malloc(nOutput);
133210: if( !zOutput ){
133211: return;
133212: }
133213:
133214: if( sqlite3_user_data(p) ){
133215: u_strToUpper(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status);
133216: }else{
133217: u_strToLower(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status);
133218: }
133219:
133220: if( !U_SUCCESS(status) ){
133221: icuFunctionError(p, "u_strToLower()/u_strToUpper", status);
133222: return;
133223: }
133224:
133225: sqlite3_result_text16(p, zOutput, -1, xFree);
133226: }
133227:
133228: /*
133229: ** Collation sequence destructor function. The pCtx argument points to
133230: ** a UCollator structure previously allocated using ucol_open().
133231: */
133232: static void icuCollationDel(void *pCtx){
133233: UCollator *p = (UCollator *)pCtx;
133234: ucol_close(p);
133235: }
133236:
133237: /*
133238: ** Collation sequence comparison function. The pCtx argument points to
133239: ** a UCollator structure previously allocated using ucol_open().
133240: */
133241: static int icuCollationColl(
133242: void *pCtx,
133243: int nLeft,
133244: const void *zLeft,
133245: int nRight,
133246: const void *zRight
133247: ){
133248: UCollationResult res;
133249: UCollator *p = (UCollator *)pCtx;
133250: res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2);
133251: switch( res ){
133252: case UCOL_LESS: return -1;
133253: case UCOL_GREATER: return +1;
133254: case UCOL_EQUAL: return 0;
133255: }
133256: assert(!"Unexpected return value from ucol_strcoll()");
133257: return 0;
133258: }
133259:
133260: /*
133261: ** Implementation of the scalar function icu_load_collation().
133262: **
133263: ** This scalar function is used to add ICU collation based collation
133264: ** types to an SQLite database connection. It is intended to be called
133265: ** as follows:
133266: **
133267: ** SELECT icu_load_collation(<locale>, <collation-name>);
133268: **
133269: ** Where <locale> is a string containing an ICU locale identifier (i.e.
133270: ** "en_AU", "tr_TR" etc.) and <collation-name> is the name of the
133271: ** collation sequence to create.
133272: */
133273: static void icuLoadCollation(
133274: sqlite3_context *p,
133275: int nArg,
133276: sqlite3_value **apArg
133277: ){
133278: sqlite3 *db = (sqlite3 *)sqlite3_user_data(p);
133279: UErrorCode status = U_ZERO_ERROR;
133280: const char *zLocale; /* Locale identifier - (eg. "jp_JP") */
133281: const char *zName; /* SQL Collation sequence name (eg. "japanese") */
133282: UCollator *pUCollator; /* ICU library collation object */
133283: int rc; /* Return code from sqlite3_create_collation_x() */
133284:
133285: assert(nArg==2);
133286: zLocale = (const char *)sqlite3_value_text(apArg[0]);
133287: zName = (const char *)sqlite3_value_text(apArg[1]);
133288:
133289: if( !zLocale || !zName ){
133290: return;
133291: }
133292:
133293: pUCollator = ucol_open(zLocale, &status);
133294: if( !U_SUCCESS(status) ){
133295: icuFunctionError(p, "ucol_open", status);
133296: return;
133297: }
133298: assert(p);
133299:
133300: rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
133301: icuCollationColl, icuCollationDel
133302: );
133303: if( rc!=SQLITE_OK ){
133304: ucol_close(pUCollator);
133305: sqlite3_result_error(p, "Error registering collation function", -1);
133306: }
133307: }
133308:
133309: /*
133310: ** Register the ICU extension functions with database db.
133311: */
133312: SQLITE_PRIVATE int sqlite3IcuInit(sqlite3 *db){
133313: struct IcuScalar {
133314: const char *zName; /* Function name */
133315: int nArg; /* Number of arguments */
133316: int enc; /* Optimal text encoding */
133317: void *pContext; /* sqlite3_user_data() context */
133318: void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
133319: } scalars[] = {
133320: {"regexp", 2, SQLITE_ANY, 0, icuRegexpFunc},
133321:
133322: {"lower", 1, SQLITE_UTF16, 0, icuCaseFunc16},
133323: {"lower", 2, SQLITE_UTF16, 0, icuCaseFunc16},
133324: {"upper", 1, SQLITE_UTF16, (void*)1, icuCaseFunc16},
133325: {"upper", 2, SQLITE_UTF16, (void*)1, icuCaseFunc16},
133326:
133327: {"lower", 1, SQLITE_UTF8, 0, icuCaseFunc16},
133328: {"lower", 2, SQLITE_UTF8, 0, icuCaseFunc16},
133329: {"upper", 1, SQLITE_UTF8, (void*)1, icuCaseFunc16},
133330: {"upper", 2, SQLITE_UTF8, (void*)1, icuCaseFunc16},
133331:
133332: {"like", 2, SQLITE_UTF8, 0, icuLikeFunc},
133333: {"like", 3, SQLITE_UTF8, 0, icuLikeFunc},
133334:
133335: {"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation},
133336: };
133337:
133338: int rc = SQLITE_OK;
133339: int i;
133340:
133341: for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){
133342: struct IcuScalar *p = &scalars[i];
133343: rc = sqlite3_create_function(
133344: db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
133345: );
133346: }
133347:
133348: return rc;
133349: }
133350:
133351: #if !SQLITE_CORE
133352: SQLITE_API int sqlite3_extension_init(
133353: sqlite3 *db,
133354: char **pzErrMsg,
133355: const sqlite3_api_routines *pApi
133356: ){
133357: SQLITE_EXTENSION_INIT2(pApi)
133358: return sqlite3IcuInit(db);
133359: }
133360: #endif
133361:
133362: #endif
133363:
133364: /************** End of icu.c *************************************************/
133365: /************** Begin file fts3_icu.c ****************************************/
133366: /*
133367: ** 2007 June 22
133368: **
133369: ** The author disclaims copyright to this source code. In place of
133370: ** a legal notice, here is a blessing:
133371: **
133372: ** May you do good and not evil.
133373: ** May you find forgiveness for yourself and forgive others.
133374: ** May you share freely, never taking more than you give.
133375: **
133376: *************************************************************************
133377: ** This file implements a tokenizer for fts3 based on the ICU library.
133378: */
133379: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3)
133380: #ifdef SQLITE_ENABLE_ICU
133381:
133382: /* #include <assert.h> */
133383: /* #include <string.h> */
133384:
133385: #include <unicode/ubrk.h>
133386: /* #include <unicode/ucol.h> */
133387: /* #include <unicode/ustring.h> */
133388: #include <unicode/utf16.h>
133389:
133390: typedef struct IcuTokenizer IcuTokenizer;
133391: typedef struct IcuCursor IcuCursor;
133392:
133393: struct IcuTokenizer {
133394: sqlite3_tokenizer base;
133395: char *zLocale;
133396: };
133397:
133398: struct IcuCursor {
133399: sqlite3_tokenizer_cursor base;
133400:
133401: UBreakIterator *pIter; /* ICU break-iterator object */
133402: int nChar; /* Number of UChar elements in pInput */
133403: UChar *aChar; /* Copy of input using utf-16 encoding */
133404: int *aOffset; /* Offsets of each character in utf-8 input */
133405:
133406: int nBuffer;
133407: char *zBuffer;
133408:
133409: int iToken;
133410: };
133411:
133412: /*
133413: ** Create a new tokenizer instance.
133414: */
133415: static int icuCreate(
133416: int argc, /* Number of entries in argv[] */
133417: const char * const *argv, /* Tokenizer creation arguments */
133418: sqlite3_tokenizer **ppTokenizer /* OUT: Created tokenizer */
133419: ){
133420: IcuTokenizer *p;
133421: int n = 0;
133422:
133423: if( argc>0 ){
133424: n = strlen(argv[0])+1;
133425: }
133426: p = (IcuTokenizer *)sqlite3_malloc(sizeof(IcuTokenizer)+n);
133427: if( !p ){
133428: return SQLITE_NOMEM;
133429: }
133430: memset(p, 0, sizeof(IcuTokenizer));
133431:
133432: if( n ){
133433: p->zLocale = (char *)&p[1];
133434: memcpy(p->zLocale, argv[0], n);
133435: }
133436:
133437: *ppTokenizer = (sqlite3_tokenizer *)p;
133438:
133439: return SQLITE_OK;
133440: }
133441:
133442: /*
133443: ** Destroy a tokenizer
133444: */
133445: static int icuDestroy(sqlite3_tokenizer *pTokenizer){
133446: IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
133447: sqlite3_free(p);
133448: return SQLITE_OK;
133449: }
133450:
133451: /*
133452: ** Prepare to begin tokenizing a particular string. The input
133453: ** string to be tokenized is pInput[0..nBytes-1]. A cursor
133454: ** used to incrementally tokenize this string is returned in
133455: ** *ppCursor.
133456: */
133457: static int icuOpen(
133458: sqlite3_tokenizer *pTokenizer, /* The tokenizer */
133459: const char *zInput, /* Input string */
133460: int nInput, /* Length of zInput in bytes */
133461: sqlite3_tokenizer_cursor **ppCursor /* OUT: Tokenization cursor */
133462: ){
133463: IcuTokenizer *p = (IcuTokenizer *)pTokenizer;
133464: IcuCursor *pCsr;
133465:
133466: const int32_t opt = U_FOLD_CASE_DEFAULT;
133467: UErrorCode status = U_ZERO_ERROR;
133468: int nChar;
133469:
133470: UChar32 c;
133471: int iInput = 0;
133472: int iOut = 0;
133473:
133474: *ppCursor = 0;
133475:
133476: if( nInput<0 ){
133477: nInput = strlen(zInput);
133478: }
133479: nChar = nInput+1;
133480: pCsr = (IcuCursor *)sqlite3_malloc(
133481: sizeof(IcuCursor) + /* IcuCursor */
133482: nChar * sizeof(UChar) + /* IcuCursor.aChar[] */
133483: (nChar+1) * sizeof(int) /* IcuCursor.aOffset[] */
133484: );
133485: if( !pCsr ){
133486: return SQLITE_NOMEM;
133487: }
133488: memset(pCsr, 0, sizeof(IcuCursor));
133489: pCsr->aChar = (UChar *)&pCsr[1];
133490: pCsr->aOffset = (int *)&pCsr->aChar[nChar];
133491:
133492: pCsr->aOffset[iOut] = iInput;
133493: U8_NEXT(zInput, iInput, nInput, c);
133494: while( c>0 ){
133495: int isError = 0;
133496: c = u_foldCase(c, opt);
133497: U16_APPEND(pCsr->aChar, iOut, nChar, c, isError);
133498: if( isError ){
133499: sqlite3_free(pCsr);
133500: return SQLITE_ERROR;
133501: }
133502: pCsr->aOffset[iOut] = iInput;
133503:
133504: if( iInput<nInput ){
133505: U8_NEXT(zInput, iInput, nInput, c);
133506: }else{
133507: c = 0;
133508: }
133509: }
133510:
133511: pCsr->pIter = ubrk_open(UBRK_WORD, p->zLocale, pCsr->aChar, iOut, &status);
133512: if( !U_SUCCESS(status) ){
133513: sqlite3_free(pCsr);
133514: return SQLITE_ERROR;
133515: }
133516: pCsr->nChar = iOut;
133517:
133518: ubrk_first(pCsr->pIter);
133519: *ppCursor = (sqlite3_tokenizer_cursor *)pCsr;
133520: return SQLITE_OK;
133521: }
133522:
133523: /*
133524: ** Close a tokenization cursor previously opened by a call to icuOpen().
133525: */
133526: static int icuClose(sqlite3_tokenizer_cursor *pCursor){
133527: IcuCursor *pCsr = (IcuCursor *)pCursor;
133528: ubrk_close(pCsr->pIter);
133529: sqlite3_free(pCsr->zBuffer);
133530: sqlite3_free(pCsr);
133531: return SQLITE_OK;
133532: }
133533:
133534: /*
133535: ** Extract the next token from a tokenization cursor.
133536: */
133537: static int icuNext(
133538: sqlite3_tokenizer_cursor *pCursor, /* Cursor returned by simpleOpen */
133539: const char **ppToken, /* OUT: *ppToken is the token text */
133540: int *pnBytes, /* OUT: Number of bytes in token */
133541: int *piStartOffset, /* OUT: Starting offset of token */
133542: int *piEndOffset, /* OUT: Ending offset of token */
133543: int *piPosition /* OUT: Position integer of token */
133544: ){
133545: IcuCursor *pCsr = (IcuCursor *)pCursor;
133546:
133547: int iStart = 0;
133548: int iEnd = 0;
133549: int nByte = 0;
133550:
133551: while( iStart==iEnd ){
133552: UChar32 c;
133553:
133554: iStart = ubrk_current(pCsr->pIter);
133555: iEnd = ubrk_next(pCsr->pIter);
133556: if( iEnd==UBRK_DONE ){
133557: return SQLITE_DONE;
133558: }
133559:
133560: while( iStart<iEnd ){
133561: int iWhite = iStart;
133562: U8_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);
133563: if( u_isspace(c) ){
133564: iStart = iWhite;
133565: }else{
133566: break;
133567: }
133568: }
133569: assert(iStart<=iEnd);
133570: }
133571:
133572: do {
133573: UErrorCode status = U_ZERO_ERROR;
133574: if( nByte ){
133575: char *zNew = sqlite3_realloc(pCsr->zBuffer, nByte);
133576: if( !zNew ){
133577: return SQLITE_NOMEM;
133578: }
133579: pCsr->zBuffer = zNew;
133580: pCsr->nBuffer = nByte;
133581: }
133582:
133583: u_strToUTF8(
133584: pCsr->zBuffer, pCsr->nBuffer, &nByte, /* Output vars */
133585: &pCsr->aChar[iStart], iEnd-iStart, /* Input vars */
133586: &status /* Output success/failure */
133587: );
133588: } while( nByte>pCsr->nBuffer );
133589:
133590: *ppToken = pCsr->zBuffer;
133591: *pnBytes = nByte;
133592: *piStartOffset = pCsr->aOffset[iStart];
133593: *piEndOffset = pCsr->aOffset[iEnd];
133594: *piPosition = pCsr->iToken++;
133595:
133596: return SQLITE_OK;
133597: }
133598:
133599: /*
133600: ** The set of routines that implement the simple tokenizer
133601: */
133602: static const sqlite3_tokenizer_module icuTokenizerModule = {
133603: 0, /* iVersion */
133604: icuCreate, /* xCreate */
133605: icuDestroy, /* xCreate */
133606: icuOpen, /* xOpen */
133607: icuClose, /* xClose */
133608: icuNext, /* xNext */
133609: };
133610:
133611: /*
133612: ** Set *ppModule to point at the implementation of the ICU tokenizer.
133613: */
133614: SQLITE_PRIVATE void sqlite3Fts3IcuTokenizerModule(
133615: sqlite3_tokenizer_module const**ppModule
133616: ){
133617: *ppModule = &icuTokenizerModule;
133618: }
133619:
133620: #endif /* defined(SQLITE_ENABLE_ICU) */
133621: #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_FTS3) */
133622:
133623: /************** End of fts3_icu.c ********************************************/
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sqlite3.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / elwix / files / sqlite / dist